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
[legend]
Collaboration diagram for btGjkConvexCast:
Collaboration graph
[legend]

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

btSimplexSolverInterfacem_simplexSolver
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.

:m_simplexSolver(simplexSolver),
m_convexA(convexA),
m_convexB(convexB)
{
}

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.

{


       m_simplexSolver->reset();

       //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;
       n.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
       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;
       identityTrans.setIdentity();


//     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;
       gjk.getClosestPoints(input,pointCollector,0);

       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)
              {
                     numIter++;
                     if (numIter > maxIter)
                     {
                            return false; //todo: report a failure
                     }
                     btScalar dLambda = btScalar(0.);

                     btScalar projectedLinearVelocity = r.dot(n);
                     
                     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;
                            //n.setValue(0,0,0);
                            break;
                     }
                     lastLambda = lambda;

                     //interpolate to next lambda
                     result.DebugDraw( lambda );
                     input.m_transformA.getOrigin().setInterpolate3(fromA.getOrigin(),toA.getOrigin(),lambda);
                     input.m_transformB.getOrigin().setInterpolate3(fromB.getOrigin(),toB.getOrigin(),lambda);
                     
                     gjk.getClosestPoints(input,pointCollector,0);
                     if (pointCollector.m_hasResult)
                     {
                            if (pointCollector.m_distance < btScalar(0.))
                            {
                                   result.m_fraction = lastLambda;
                                   n = pointCollector.m_normalOnBInWorld;
                                   result.m_normal=n;
                                   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: