Back to index

supertuxkart  0.5+dfsg1
Public Member Functions | Private Attributes
btGjkConvexCast Class Reference

GjkConvexCast performs a raycast on a convex object using support mapping. More...

#include <btGjkConvexCast.h>

Inheritance diagram for btGjkConvexCast:
Inheritance graph
Collaboration diagram for btGjkConvexCast:
Collaboration graph

List of all members.

Public Member Functions

 btGjkConvexCast (const btConvexShape *convexA, const btConvexShape *convexB, btSimplexSolverInterface *simplexSolver)
virtual bool calcTimeOfImpact (const btTransform &fromA, const btTransform &toA, const btTransform &fromB, const btTransform &toB, CastResult &result)
 cast a convex against another convex object

Private Attributes

const btConvexShape * m_convexA
const btConvexShape * m_convexB

Detailed Description

GjkConvexCast performs a raycast on a convex object using support mapping.

Definition at line 30 of file btGjkConvexCast.h.

Constructor & Destructor Documentation

btGjkConvexCast::btGjkConvexCast ( const btConvexShape *  convexA,
const btConvexShape *  convexB,
btSimplexSolverInterface simplexSolver 

Definition at line 30 of file btGjkConvexCast.cpp.


Member Function Documentation

bool btGjkConvexCast::calcTimeOfImpact ( const btTransform fromA,
const btTransform toA,
const btTransform fromB,
const btTransform toB,
CastResult result 
) [virtual]

cast a convex against another convex object

compute linear velocity for this interval, to interpolate

Implements btConvexCast.

Definition at line 37 of file btGjkConvexCast.cpp.



       //assume no rotation/angular velocity, assert here?
       btVector3 linVelA,linVelB;
       linVelA = toA.getOrigin()-fromA.getOrigin();
       linVelB = toB.getOrigin()-fromB.getOrigin();

       btScalar radius = btScalar(0.001);
       btScalar lambda = btScalar(0.);
       btVector3 v(1,0,0);

       int maxIter = MAX_ITERATIONS;

       btVector3 n;
       bool hasResult = false;
       btVector3 c;
       btVector3 r = (linVelA-linVelB);

       btScalar lastLambda = lambda;
       //btScalar epsilon = btScalar(0.001);

       int numIter = 0;
       //first solution, using GJK

       btTransform identityTrans;

//     result.drawCoordSystem(sphereTr);

       btPointCollector     pointCollector;

       btGjkPairDetector gjk(m_convexA,m_convexB,m_simplexSolver,0);//m_penetrationDepthSolver);         
       btGjkPairDetector::ClosestPointInput input;

       //we don't use margins during CCD
       //     gjk.setIgnoreMargin(true);

       input.m_transformA = fromA;
       input.m_transformB = fromB;

       hasResult = pointCollector.m_hasResult;
       c = pointCollector.m_pointInWorld;

       if (hasResult)
              btScalar dist;
              dist = pointCollector.m_distance;
              n = pointCollector.m_normalOnBInWorld;


              //not close enough
              while (dist > radius)
                     if (numIter > maxIter)
                            return false; //todo: report a failure
                     btScalar dLambda = btScalar(0.);

                     btScalar projectedLinearVelocity =;
                     dLambda = dist / (projectedLinearVelocity);

                     lambda = lambda - dLambda;

                     if (lambda > btScalar(1.))
                            return false;

                     if (lambda < btScalar(0.))
                            return false;

                     //todo: next check with relative epsilon
                     if (lambda <= lastLambda)
                            return false;
                     lastLambda = lambda;

                     //interpolate to next lambda
                     result.DebugDraw( lambda );
                     if (pointCollector.m_hasResult)
                            if (pointCollector.m_distance < btScalar(0.))
                                   result.m_fraction = lastLambda;
                                   n = pointCollector.m_normalOnBInWorld;
                                   result.m_hitPoint = pointCollector.m_pointInWorld;
                                   return true;
                            c = pointCollector.m_pointInWorld;        
                            n = pointCollector.m_normalOnBInWorld;
                            dist = pointCollector.m_distance;
                     } else
                            return false;


              result.m_fraction = lambda;
              result.m_normal = n;
              result.m_hitPoint = c;
              return true;

       return false;


Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const btConvexShape* btGjkConvexCast::m_convexA [private]

Definition at line 33 of file btGjkConvexCast.h.

const btConvexShape* btGjkConvexCast::m_convexB [private]

Definition at line 34 of file btGjkConvexCast.h.

Definition at line 32 of file btGjkConvexCast.h.

The documentation for this class was generated from the following files: