About Bezier Curve.

In my project I need a curve to follow. I created a bezier curve in blend file. But I found that the gkCurve don't support bezier curve. So I do a little work to make class gkCurve to support bezier.

First, in gkCurveProperties of gkSerialize.h:

class gkCurveProperties

{

public:

enum CurveType

{

CU_Bezier,

CU_Spline,

CU_Points

};

public:

gkCurveProperties() :m_type(CU_Points), m_isCyclic(false)

{

}

CurveType m_type;

utArray<gkVector3> m_points;

typedef utArray<utArray<gkVector3> > BezTriples;

BezTriples m_BezTriples;

bool m_isCyclic;

};

Second, in function gkBlenderSceneConverter::convertObjectCurve of gkBlenderSceneConverter:

void gkBlenderSceneConverter::convertObjectCurve(gkGameObject* gobj, Blender::Object* bobj)

{

GK_ASSERT(gobj->getType() == GK_CURVE && bobj->data);

gkCurve* obj = static_cast<gkCurve*>(gobj);

gkCurveProperties& props = obj->getCurveProperties();

Blender::Curve* curve = static_cast<Blender::Curve*>(bobj->data);

Blender::Nurb* nurb = (Blender::Nurb* )curve->nurb.first;

// if (nurb->type != CU_NURBS) {

// gkLogger::write("Only Nurb-Curves are supported, atm! ("+obj->getName()+")");

// return;

// }

props.m_isCyclic = (nurb->flagu & CU_CYCLIC) || (nurb->flagv & CU_CYCLIC);

switch (nurb->type)

{

case CU_NURBS:

{

for (int i=0;i<nurb->pntsu;i++){

short int nurbType = nurb->type;

const Blender::BPoint& pnt = nurb->bp[i];

// TODO: check if these are converted properly

gkVector3 point(pnt.vec[0],pnt.vec[1],pnt.vec[2]);

props.m_points.push_back(point);

}

break;

}

case CU_BEZIER:

{

for (int i = 0; i < nurb->pntsu; i++)

{

const Blender::BezTriple& trp = nurb->bezt[i];

utArray<gkVector3> bezTriple;

for (int j = 0; j < 3; j++)

{

gkVector3 bt;

bt.x = trp.vec[j][0];

bt.y = trp.vec[j][1];

bt.z = trp.vec[j][2];

bezTriple.push_back(bt);

printf("%f %f %f ", bt.x, bt.y, bt.z);

}

props.m_BezTriples.push_back(bezTriple);

}

printf("\n");

props.m_type = gkCurveProperties::CU_Bezier;

break;

}

default:

gkLogger::write("Only Nurb-Curves and Bezier-Curves are supported, atm! ("+obj->getName()+")");

return;

}

}

Third, in gkCurve.h:

private:

gkGameObject* clone(const gkString& name);

void makeBezier(gkScalar _t, utArray<gkVector3>& _first, utArray<gkVector3>& _second);

gkCurveProperties m_curveProps;

virtual void createInstanceImpl(void);

virtual void destroyInstanceImpl(void);

utArray<gkVector3> m_bezierPoints;

Fourth, in gkCurve.cpp I rewiter the follow functions:

const gkVector3 gkCurve::getPoint(int nr)

{

switch (m_curveProps.m_type)

{

case gkCurveProperties::CU_Points:

{

if (nr < (int)m_curveProps.m_points.size()) {

return getWorldTransform() * m_curveProps.m_points.at(nr);

}

else

{

// TODO: better error handling

return gkVector3::ZERO;

}

}

case gkCurveProperties::CU_Bezier:

{

if (nr < (int)m_bezierPoints.size()) {

return getWorldTransform() * m_bezierPoints.at(nr);

}

else

{

// TODO: better error handling

return gkVector3::ZERO;

}

}

}

}

int gkCurve::getPointCount()

{

switch (m_curveProps.m_type)

{

case gkCurveProperties::CU_Points:

return m_curveProps.m_points.size();

case gkCurveProperties::CU_Bezier:

return m_bezierPoints.size();

}

}

void gkCurve::generateBezierPoints(gkScalar _t)

{

m_bezierPoints.clear();

UTsize triCount = m_curveProps.m_BezTriples.size();

for (UTsize i = 0; i < triCount - 1; i++)

{

utArray<gkVector3>& bezFirst = m_curveProps.m_BezTriples.at(i);

utArray<gkVector3>& bezSecond = m_curveProps.m_BezTriples.at(i + 1);

makeBezier(_t, bezFirst, bezSecond);

}

if (m_curveProps.m_isCyclic)

{

utArray<gkVector3>& bezFirst = m_curveProps.m_BezTriples.at(triCount - 1);

utArray<gkVector3>& bezSecond = m_curveProps.m_BezTriples.at(0);

makeBezier(_t, bezFirst, bezSecond);

}

}

void gkCurve::makeBezier(gkScalar _t, utArray< gkVector3 >& _first, utArray< gkVector3 >& _second)

{

gkVector3& pt0 = _first.at(1);

gkVector3& pt1 = _first.at(2);

gkVector3& pt2 = _second.at(0);

gkVector3& pt3 = _second.at(1);

for (gkScalar t = 0.f; t < 1.f; t += _t)

{

gkScalar yt = 1 - t;

gkScalar t1 = yt * yt;

gkScalar t2 = 3 * yt * t;

gkVector3 pt = pt0 * t1 * yt + pt1 * t2 * yt + pt2 * t2 * t + pt3 * t * t * t;

m_bezierPoints.push_back(pt);

}

}

void gkCurve::showDebug()

{

if (m_scene)

{

gkDebugger* debug = m_scene->getDebugger();

if (!debug)

{

return;

}

unsigned int n = getPointCount();

if (n)

{

static const gkVector3 RED_COLOR(0.8f, 0.5f, 0);

gkVector3 oldPoint = getPoint(0);

for (unsigned int i = 1; i < n; i++)

{

gkVector3 point = getPoint(i);

debug->drawLine(

oldPoint,

point,

RED_COLOR

);

oldPoint = point;

}

}

}

}

In my code. I just use gkCurve like:

gkCurve* m_pathCurve = m_scene->getObject("PATH_CURVE”)->getCurve();

m_pathCurve->generateBezierPoints(0.05f);

Then you can use m_pathCurve->getPointCount() and m_pathCurve->getPoint(n) to manipulate the bezier.

Follow is a snapshot of blend file:

Follow is a snapshot of program: