GAABB3 SphereObject::compute_local_bbox() const
{
const auto r = static_cast<GScalar>(get_uncached_radius());
GAABB3 bbox(GVector3(-r), GVector3(r));
bbox.translate(GVector3(get_uncached_center()));
return bbox;
}
void compute_smooth_vertex_normals_base_pose(MeshObject& object)
{
assert(object.get_vertex_normal_count() == 0);
const size_t vertex_count = object.get_vertex_count();
const size_t triangle_count = object.get_triangle_count();
vector<GVector3> normals(vertex_count, GVector3(0.0));
for (size_t i = 0; i < triangle_count; ++i)
{
Triangle& triangle = object.get_triangle(i);
triangle.m_n0 = triangle.m_v0;
triangle.m_n1 = triangle.m_v1;
triangle.m_n2 = triangle.m_v2;
const GVector3& v0 = object.get_vertex(triangle.m_v0);
const GVector3& v1 = object.get_vertex(triangle.m_v1);
const GVector3& v2 = object.get_vertex(triangle.m_v2);
const GVector3 normal = normalize(cross(v1 - v0, v2 - v0));
normals[triangle.m_v0] += normal;
normals[triangle.m_v1] += normal;
normals[triangle.m_v2] += normal;
}
object.reserve_vertex_normals(vertex_count);
for (size_t i = 0; i < vertex_count; ++i)
object.push_vertex_normal(safe_normalize(normals[i]));
}
void compute_smooth_vertex_tangents_base_pose(MeshObject& object)
{
assert(object.get_vertex_tangent_count() == 0);
assert(object.get_tex_coords_count() > 0);
const size_t vertex_count = object.get_vertex_count();
const size_t triangle_count = object.get_triangle_count();
vector<GVector3> tangents(vertex_count, GVector3(0.0));
for (size_t i = 0; i < triangle_count; ++i)
{
const Triangle& triangle = object.get_triangle(i);
if (!triangle.has_vertex_attributes())
continue;
const GVector2 v0_uv = object.get_tex_coords(triangle.m_a0);
const GVector2 v1_uv = object.get_tex_coords(triangle.m_a1);
const GVector2 v2_uv = object.get_tex_coords(triangle.m_a2);
//
// Reference:
//
// Physically Based Rendering, first edition, pp. 128-129
//
const GScalar du0 = v0_uv[0] - v2_uv[0];
const GScalar dv0 = v0_uv[1] - v2_uv[1];
const GScalar du1 = v1_uv[0] - v2_uv[0];
const GScalar dv1 = v1_uv[1] - v2_uv[1];
const GScalar det = du0 * dv1 - dv0 * du1;
if (det == GScalar(0.0))
continue;
const GVector3& v2 = object.get_vertex(triangle.m_v2);
const GVector3 dp0 = object.get_vertex(triangle.m_v0) - v2;
const GVector3 dp1 = object.get_vertex(triangle.m_v1) - v2;
const GVector3 tangent = normalize(dv1 * dp0 - dv0 * dp1);
tangents[triangle.m_v0] += tangent;
tangents[triangle.m_v1] += tangent;
tangents[triangle.m_v2] += tangent;
}
object.reserve_vertex_tangents(vertex_count);
for (size_t i = 0; i < vertex_count; ++i)
object.push_vertex_tangent(safe_normalize(tangents[i]));
}
void QuatTestComp::EndUpdate( GActorHandle i_actor )
{
if ( m_keyDown )
{
// Attempt 1. Works, but weird...
/*
float totalRot = fabs(acosf(m_quat.DotProduct(m_targetQuat)));
// time / (rot speed / totalRot).
if (totalRot > 0.0f)
m_quat.Slerp(m_quat, m_targetQuat, g_Clock::Get().SecondsSinceLastFrame() * (GMath::Deg2Rad(30.0f) / totalRot));
m_quat.Normalize();
*/
// Attempt 2.
GVector3 target = m_targetQuat * GVector3::Forward;
target.Normalize();
GVector3 current = m_quat * GVector3::Forward;
current.Normalize();
float dot = target.Dot( current );
if (dot < 0.99999f)
{
GVector3 cross = current.Cross( target );
float sign = GMath::Sign( cross.y() );
cross.Normalize();
GQuat delta;
delta.FromAngleAxis( GMath::Deg2Rad( 30.0f ) * g_Clock::Get().SecondsSinceLastFrame(), cross );
m_quat = m_quat * delta;
if( GMath::Sign( ( m_quat * GVector3::Forward ).Cross( m_targetQuat * GVector3::Forward ).y() ) != sign )
m_quat = m_targetQuat;
}
}
GActor* actor = GActor::FromHandle( i_actor );
assert( actor );
GVector3 vStartPoint = actor->m_position;
GVector3 vEndPoint = actor->m_position + ( m_quat * GVector3::Forward * 100.0f );
GDebugDraw::DrawLine( vStartPoint, vEndPoint, 0.002f, 0.002f, GDebugDraw::RED );
GVector3 vEndTargetPoint = actor->m_position + ( m_targetQuat * GVector3( 0.0f, 0.0f, 100.0f ) );
GDebugDraw::DrawLine( vStartPoint, vEndTargetPoint, 0.002f, 0.002f, GDebugDraw::BLUE );
}
void Scene::create_render_data()
{
assert(!m_has_render_data);
m_render_data.m_bbox = compute_bbox();
if (m_render_data.m_bbox.is_valid())
{
m_render_data.m_center = m_render_data.m_bbox.center();
m_render_data.m_radius = m_render_data.m_bbox.radius();
m_render_data.m_diameter = m_render_data.m_bbox.diameter();
m_render_data.m_safe_diameter = m_render_data.m_diameter * GScalar(1.01);
}
else
{
m_render_data.m_center = GVector3(0.0);
m_render_data.m_radius = GScalar(0.0);
m_render_data.m_diameter = GScalar(0.0);
m_render_data.m_safe_diameter = GScalar(0.0);
}
m_has_render_data = true;
}
void compute_smooth_vertex_normals_pose(MeshObject& object, const size_t motion_segment_index)
{
const size_t vertex_count = object.get_vertex_count();
const size_t triangle_count = object.get_triangle_count();
vector<GVector3> normals(vertex_count, GVector3(0.0));
for (size_t i = 0; i < triangle_count; ++i)
{
const Triangle& triangle = object.get_triangle(i);
const GVector3& v0 = object.get_vertex_pose(triangle.m_v0, motion_segment_index);
const GVector3& v1 = object.get_vertex_pose(triangle.m_v1, motion_segment_index);
const GVector3& v2 = object.get_vertex_pose(triangle.m_v2, motion_segment_index);
const GVector3 normal = normalize(cross(v1 - v0, v2 - v0));
normals[triangle.m_v0] += normal;
normals[triangle.m_v1] += normal;
normals[triangle.m_v2] += normal;
}
for (size_t i = 0; i < vertex_count; ++i)
object.set_vertex_normal_pose(i, motion_segment_index, safe_normalize(normals[i]));
}
GAABB3 Scene::compute_bbox() const
{
const AssemblyInstanceContainer& instances = assembly_instances();
const GAABB3 bbox = compute_parent_bbox<GAABB3>(instances.begin(), instances.end());
return bbox.is_valid() ? bbox : GAABB3(GVector3(0.0f), GVector3(0.0f));
}
GVector3 GKeyValue::Vect3Value() const {
return GVector3(gValue[0], gValue[1], gValue[2]);
}
void CurveTree::collect_curves(vector<GAABB3>& curve_bboxes)
{
const ObjectInstanceContainer& object_instances = m_arguments.m_assembly.object_instances();
for (size_t i = 0; i < object_instances.size(); ++i)
{
// Retrieve the object instance.
const ObjectInstance* object_instance = object_instances.get_by_index(i);
assert(object_instance);
// Retrieve the object.
const Object& object = object_instance->get_object();
// Process only curve objects.
if (strcmp(object.get_model(), CurveObjectFactory::get_model()))
continue;
const CurveObject& curve_object = static_cast<const CurveObject&>(object);
// Retrieve the object instance transform.
const Transformd::MatrixType& transform =
object_instance->get_transform().get_local_to_parent();
// Store degree-1 curves, curve keys and curve bounding boxes.
const size_t curve1_count = curve_object.get_curve1_count();
for (size_t j = 0; j < curve1_count; ++j)
{
const Curve1Type curve(curve_object.get_curve1(j), transform);
const CurveKey curve_key(
i, // object instance index
j, // curve index in object
m_curves1.size(), // curve index in tree
0, // for now we assume all the curves have the same material
1); // curve degree
GAABB3 curve_bbox = curve.compute_bbox();
curve_bbox.grow(GVector3(GScalar(0.5) * curve.compute_max_width()));
m_curves1.push_back(curve);
m_curve_keys.push_back(curve_key);
curve_bboxes.push_back(curve_bbox);
}
// Store degree-3 curves, curve keys and curve bounding boxes.
const size_t curve3_count = curve_object.get_curve3_count();
for (size_t j = 0; j < curve3_count; ++j)
{
const Curve3Type curve(curve_object.get_curve3(j), transform);
const CurveKey curve_key(
i, // object instance index
j, // curve index in object
m_curves3.size(), // curve index in tree
0, // for now we assume all the curves have the same material
3); // curve degree
GAABB3 curve_bbox = curve.compute_bbox();
curve_bbox.grow(GVector3(GScalar(0.5) * curve.compute_max_width()));
m_curves3.push_back(curve);
m_curve_keys.push_back(curve_key);
curve_bboxes.push_back(curve_bbox);
}
}
}
GVector3 GVector3::operator/(float n)
{
return GVector3(x/n,y/n,z/n);
}
GVector3 GVector3::operator*(float n)
{
return GVector3(x*n,y*n,z*n);
}
GVector3 GVector3::operator-(GVector3 v)
{
return GVector3(x-v.x,y-v.y,z-v.z);
}
GVector3 GVector3::operator+(GVector3 v)
{
return GVector3(x+v.x,v.y+y,v.z+z);
}
GThreeConstantProperty1D::GThreeConstantProperty1D(const GElement* Owner) : GMultiProperty1D(Owner) {
this->Init(3, G_CONSTANTPROPERTY1D_CLASSID, GKeyValue(GVector3(0, 0, 0)), "x;y;z");
}
GThreeLinearProperty1D::GThreeLinearProperty1D(const GElement* Owner) : GMultiProperty1D(Owner) {
this->Init(3, G_LINEARPROPERTY1D_CLASSID, GKeyValue(GVector3(0, 0, 0)), "x;y;z");
}
GThreeHermiteProperty1D::GThreeHermiteProperty1D(const GElement* Owner) : GMultiProperty1D(Owner) {
this->Init(3, G_HERMITEPROPERTY1D_CLASSID, GKeyValue(GVector3(0, 0, 0)), "x;y;z");
}
void QGLWidgetTest::TestLinearGradient(const GUInt32 TestIndex, const GReal RotAngle, const GReal Scale) {
GUInt32 idx = (TestIndex % 4);
GMatrix33 ofsTransf, m;
GMatrix33 rot, scl, preTrans, postTrans;
TranslationToMatrix(preTrans, GPoint2(-120, -88));
TranslationToMatrix(postTrans, GPoint2(120, 88));
RotationToMatrix(rot, RotAngle);
ScaleToMatrix(scl, GVector2(Scale, Scale));
ofsTransf = (postTrans * (rot * (scl * preTrans)));
gDrawBoard->SetTargetMode(G_COLOR_MODE);
gDrawBoard->SetStrokePaintType(G_COLOR_PAINT_TYPE);
gDrawBoard->SetStrokeStyle(G_SOLID_STROKE);
gDrawBoard->SetStrokeJoinStyle(G_MITER_JOIN);
gDrawBoard->SetStrokeEnabled(G_TRUE);
gDrawBoard->SetStrokeWidth(4);
gDrawBoard->SetStrokeColor(GVector4(0.0, 0.0, 0.0, 1.000));
gDrawBoard->SetFillEnabled(G_TRUE);
gDrawBoard->SetFillPaintType(G_GRADIENT_PAINT_TYPE);
// OPAQUE
if (idx == 0) {
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 1.0));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
else
if (idx == 1) {
// TRANSPARENT
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 0.5));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad1->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad1->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad1->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad1->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad1->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad1);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
else
if (idx == 2) {
// TRANSPARENT IN KEYS
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 1.0));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
else {
// TRANSPARENT IN KEYS AND COLOR
gDrawBoard->SetFillColor(GVector4(0.0, 0.0, 0.0, 0.5));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_HERMITE_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 18), GPoint2(260, 194));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 18), GPoint2(520, 194));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+18,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 18), GPoint2(780, 194));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_LINEAR_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 212), GPoint2(260, 388));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 212), GPoint2(520, 388));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+212,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 212), GPoint2(780, 388));
// --------------------------------------------------------------
gLinGrad2->SetColorInterpolation(G_CONSTANT_COLOR_INTERPOLATION);
gLinGrad2->SetSpreadMode(G_PAD_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+20,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(20, 406), GPoint2(260, 582));
gLinGrad2->SetSpreadMode(G_REPEAT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+280,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(280, 406), GPoint2(520, 582));
gLinGrad2->SetSpreadMode(G_REFLECT_COLOR_RAMP_SPREAD);
TranslationToMatrix(m, GVector3(+540,+406,0));
gLinGrad2->SetMatrix(m * ofsTransf);
gDrawBoard->SetFillGradient(gLinGrad2);
gDrawBoard->DrawRectangle(GPoint2(540, 406), GPoint2(780, 582));
// --------------------------------------------------------------
}
}
// alright. this is the "state machine" :(
void CtfAiPlayerComp::Update( GActorHandle i_actor )
{
GActor* actor = GActor::FromHandle( i_actor );
// make sure the player is valid every frame.
if( !m_Player )
{
m_Player = g_World::Get().GetActorByName( "PlayerOne" );
if( !m_Player )
return;
}
g_AudioManager.UpdateChannelPosition( m_walkOnGroundSlow, actor->m_position );
StaminaBrain( i_actor );
if( m_usingStamina )
m_staminaMeter -= g_Clock::Get().SecondsSinceLastFrame() * 5.0f;
else
m_staminaMeter += g_Clock::Get().SecondsSinceLastFrame() * 1.66667f;
GMath::Clamp( &m_staminaMeter, 0.0f, 10.0f );
switch( m_State )
{
case SEEK:
Seek( i_actor );
break;
case CAPTURE:
Capture( i_actor );
break;
case PURSUE:
Pursue( i_actor );
break;
}
if( m_PathToTarget.m_pathFound )
{
GGroundFollowerComp* gFollower = GetComponent<GGroundFollowerComp>( i_actor );
assert( gFollower ); // you f****d up.
GVector3 velocity;
if( m_PathToTarget.m_PathNodes.size() <= 1 && m_State == PURSUE )
{
GActorHandle playerHandle = g_World::Get().GetActorByName( "PlayerOne" );
GActor* player = GActor::FromHandle( playerHandle );
if( !player )
velocity = GVector3( 0.0f, 0.0f, 0.0f );
else
velocity = player->m_position - actor->m_position;
}
else
{
velocity = m_TargetNodePos - actor->m_position;
}
velocity.Normalize();
if( m_usingStamina )
velocity *= 1000.0f;
else
velocity *= 500.0f;
m_LastVelocity = velocity;
gFollower->m_velocity = velocity;
}
}
