53 int firstHit=startHit;
62 islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag();
71 int rIslandId0, lIslandId0;
74 return lIslandId0 < rIslandId0;
134 int numCurConstraints = 0;
165 for (i = 0; i < numCurConstraints; i++)
193 m_sortedConstraints(),
254 for (
int i = 0; i < m_collisionObjects.size(); i++)
260 if (body->isKinematicObject())
275 bool drawConstraints =
false;
276 if (getDebugDrawer())
278 int mode = getDebugDrawer()->getDebugMode();
281 drawConstraints =
true;
297 if (getDebugDrawer() && getDebugDrawer()->getDebugMode())
305 if (getDebugDrawer())
306 getDebugDrawer()->flushLines();
328 if (body->isActive())
348 body->getInterpolationLinearVelocity(), body->getInterpolationAngularVelocity(),
350 interpolatedTransform);
362 for (
int i = 0; i < m_collisionObjects.size(); i++)
376 if (body->isActive())
386 int numSimulationSubSteps = 0;
395 numSimulationSubSteps = int(
m_localTime / fixedTimeStep);
396 m_localTime -= numSimulationSubSteps * fixedTimeStep;
402 fixedTimeStep = timeStep;
407 numSimulationSubSteps = 0;
412 numSimulationSubSteps = 1;
418 if (getDebugDrawer())
423 if (numSimulationSubSteps)
426 int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps) ? maxSubSteps : numSimulationSubSteps;
432 for (
int i = 0; i < clampedSimulationSteps; i++)
445 #ifndef BT_NO_PROFILE
446 CProfileManager::Increment_Frame_Counter();
449 return numSimulationSubSteps;
456 if (0 != m_internalPreTickCallback)
458 (*m_internalPreTickCallback)(
this, timeStep);
473 performDiscreteCollisionDetection();
477 getSolverInfo().m_timeStep = timeStep;
493 if (0 != m_internalTickCallback)
495 (*m_internalTickCallback)(
this, timeStep);
546 if (!body->isStaticObject())
555 bool isDynamic = !(body->isStaticObject() || body->isKinematicObject());
572 if (!body->isStaticObject())
588 for (
int i = 0; i <
m_actions.size(); i++)
590 m_actions[i]->updateAction(
this, timeStep);
607 if (body->isStaticOrKinematicObject())
635 btAssert(&constraint->getRigidBodyA() != &constraint->getRigidBodyB());
637 if (disableCollisionsBetweenLinkedBodies)
639 constraint->getRigidBodyA().addConstraintRef(constraint);
640 constraint->getRigidBodyB().addConstraintRef(constraint);
647 constraint->getRigidBodyA().removeConstraintRef(constraint);
648 constraint->getRigidBodyB().removeConstraintRef(constraint);
738 if (constraint->isEnabled())
740 const btRigidBody* colObj0 = &constraint->getRigidBodyA();
741 const btRigidBody* colObj1 = &constraint->getRigidBodyB();
786 btVector3 relativeVelocity = (linVelA - linVelB);
791 return ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace);
797 if (proxy0->m_clientObject ==
m_me)
826 if (collisionPair->m_algorithm)
829 collisionPair->m_algorithm->getAllContactManifolds(manifoldArray);
830 for (
int j=0;j<manifoldArray.
size();j++)
833 if (manifold->getNumContacts()>0)
855 body->setHitFraction(1.f);
857 if (body->isActive() && (!body->isStaticOrKinematicObject()))
861 btScalar squareMotion = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()).
length2();
863 if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion)
869 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY
880 if (!otherObj->isStaticOrKinematicObject())
886 StaticOnlyCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
888 btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
892 sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration;
894 sweepResults.m_collisionFilterGroup = body->
getBroadphaseProxy()->m_collisionFilterGroup;
895 sweepResults.m_collisionFilterMask = body->
getBroadphaseProxy()->m_collisionFilterMask;
896 btTransform modifiedPredictedTrans = predictedTrans;
897 modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis());
899 convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults);
900 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
902 btVector3 distVec = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()) * sweepResults.m_closestHitFraction;
905 btPersistentManifold* manifold = m_dispatcher1->getNewManifold(body, sweepResults.m_hitCollisionObject);
910 btVector3 worldPointB = body->getWorldTransform().getOrigin() + distVec;
911 btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse() * worldPointB;
915 bool isPredictive =
true;
916 int index = manifold->addManifoldPoint(newPoint, isPredictive);
931 BT_PROFILE(
"release predictive contact manifolds");
936 this->m_dispatcher1->releaseManifold(manifold);
957 body->setHitFraction(1.f);
959 if (body->isActive() && (!body->isStaticOrKinematicObject()))
963 btScalar squareMotion = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()).
length2();
965 if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion)
971 #ifdef USE_STATIC_ONLY
982 if (!otherObj->isStaticOrKinematicObject())
988 StaticOnlyCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
990 btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher());
994 sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration;
996 sweepResults.m_collisionFilterGroup = body->
getBroadphaseProxy()->m_collisionFilterGroup;
997 sweepResults.m_collisionFilterMask = body->
getBroadphaseProxy()->m_collisionFilterMask;
998 btTransform modifiedPredictedTrans = predictedTrans;
999 modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis());
1001 convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults);
1002 if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
1005 body->setHitFraction(sweepResults.m_closestHitFraction);
1007 body->setHitFraction(0.f);
1013 btScalar maxSpeed = body->getCcdMotionThreshold()/getSolverInfo().m_timeStep;
1014 btScalar maxSpeedSqr = maxSpeed*maxSpeed;
1015 if (linVel.length2()>maxSpeedSqr)
1023 btScalar sm2 = (predictedTrans.getOrigin()-body->getWorldTransform().getOrigin()).
length2();
1024 btScalar smt = body->getCcdSquareMotionThreshold();
1025 printf(
"sm2=%f\n",sm2);
1058 BT_PROFILE(
"apply speculative contact restitution");
1065 for (
int p = 0; p < manifold->getNumContacts(); p++)
1078 btVector3 rel_pos0 = pos1 - body0->getWorldTransform().getOrigin();
1079 btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin();
1097 if (!body->isStaticOrKinematicObject())
1112 #ifndef BT_NO_PROFILE
1113 CProfileManager::Reset();
1121 btScalar dbgDrawSize = constraint->getDbgDrawSize();
1127 switch (constraint->getConstraintType())
1135 pivot = p2pC->getRigidBodyA().getCenterOfMassTransform() * pivot;
1136 tr.setOrigin(pivot);
1137 getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1139 pivot = p2pC->getPivotInB();
1140 pivot = p2pC->getRigidBodyB().getCenterOfMassTransform() * pivot;
1141 tr.setOrigin(pivot);
1142 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1148 btTransform tr = pHinge->getRigidBodyA().getCenterOfMassTransform() * pHinge->getAFrame();
1149 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1150 tr = pHinge->getRigidBodyB().getCenterOfMassTransform() * pHinge->getBFrame();
1151 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1152 btScalar minAng = pHinge->getLowerLimit();
1153 btScalar maxAng = pHinge->getUpperLimit();
1154 if (minAng == maxAng)
1158 bool drawSect =
true;
1159 if (!pHinge->hasLimit())
1169 btVector3 axis = tr.getBasis().getColumn(0);
1170 getDebugDrawer()->drawArc(
center,
normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng,
btVector3(0, 0, 0), drawSect);
1177 btTransform tr = pCT->getRigidBodyA().getCenterOfMassTransform() * pCT->getAFrame();
1178 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1179 tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame();
1180 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1185 static int nSegments = 8 * 4;
1189 for (
int i = 0; i < nSegments; i++)
1194 getDebugDrawer()->drawLine(pPrev, pCur,
btVector3(0, 0, 0));
1196 if (i % (nSegments / 8) == 0)
1197 getDebugDrawer()->drawLine(tr.getOrigin(), pCur,
btVector3(0, 0, 0));
1201 btScalar tws = pCT->getTwistSpan();
1202 btScalar twa = pCT->getTwistAngle();
1203 bool useFrameB = (pCT->getRigidBodyB().getInvMass() >
btScalar(0.f));
1206 tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame();
1210 tr = pCT->getRigidBodyA().getCenterOfMassTransform() * pCT->getAFrame();
1214 btVector3 axis1 = tr.getBasis().getColumn(1);
1215 getDebugDrawer()->drawArc(pivot,
normal, axis1, dbgDrawSize, dbgDrawSize, -twa - tws, -twa + tws,
btVector3(0, 0, 0),
true);
1223 btTransform tr = p6DOF->getCalculatedTransformA();
1224 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1225 tr = p6DOF->getCalculatedTransformB();
1226 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1229 tr = p6DOF->getCalculatedTransformA();
1230 const btVector3&
center = p6DOF->getCalculatedTransformB().getOrigin();
1231 btVector3 up = tr.getBasis().getColumn(2);
1232 btVector3 axis = tr.getBasis().getColumn(0);
1233 btScalar minTh = p6DOF->getRotationalLimitMotor(1)->m_loLimit;
1234 btScalar maxTh = p6DOF->getRotationalLimitMotor(1)->m_hiLimit;
1235 btScalar minPs = p6DOF->getRotationalLimitMotor(2)->m_loLimit;
1236 btScalar maxPs = p6DOF->getRotationalLimitMotor(2)->m_hiLimit;
1237 getDebugDrawer()->drawSpherePatch(
center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1238 axis = tr.getBasis().getColumn(1);
1246 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] -
sy * axis[2];
1247 ref[1] = -sz * axis[0] + cz * axis[1];
1248 ref[2] = cz *
sy * axis[0] + sz *
sy * axis[1] + cy * axis[2];
1249 tr = p6DOF->getCalculatedTransformB();
1251 btScalar minFi = p6DOF->getRotationalLimitMotor(0)->m_loLimit;
1252 btScalar maxFi = p6DOF->getRotationalLimitMotor(0)->m_hiLimit;
1255 getDebugDrawer()->drawArc(
center,
normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1257 else if (minFi < maxFi)
1259 getDebugDrawer()->drawArc(
center,
normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1261 tr = p6DOF->getCalculatedTransformA();
1262 btVector3 bbMin = p6DOF->getTranslationalLimitMotor()->m_lowerLimit;
1263 btVector3 bbMax = p6DOF->getTranslationalLimitMotor()->m_upperLimit;
1264 getDebugDrawer()->drawBox(bbMin, bbMax, tr,
btVector3(0, 0, 0));
1273 btTransform tr = p6DOF->getCalculatedTransformA();
1274 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1275 tr = p6DOF->getCalculatedTransformB();
1276 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1279 tr = p6DOF->getCalculatedTransformA();
1280 const btVector3&
center = p6DOF->getCalculatedTransformB().getOrigin();
1281 btVector3 up = tr.getBasis().getColumn(2);
1282 btVector3 axis = tr.getBasis().getColumn(0);
1283 btScalar minTh = p6DOF->getRotationalLimitMotor(1)->m_loLimit;
1284 btScalar maxTh = p6DOF->getRotationalLimitMotor(1)->m_hiLimit;
1287 btScalar minPs = p6DOF->getRotationalLimitMotor(2)->m_loLimit;
1288 btScalar maxPs = p6DOF->getRotationalLimitMotor(2)->m_hiLimit;
1289 getDebugDrawer()->drawSpherePatch(
center, up, axis, dbgDrawSize *
btScalar(.9f), minTh, maxTh, minPs, maxPs,
btVector3(0, 0, 0));
1291 axis = tr.getBasis().getColumn(1);
1299 ref[0] = cy * cz * axis[0] + cy * sz * axis[1] -
sy * axis[2];
1300 ref[1] = -sz * axis[0] + cz * axis[1];
1301 ref[2] = cz *
sy * axis[0] + sz *
sy * axis[1] + cy * axis[2];
1302 tr = p6DOF->getCalculatedTransformB();
1304 btScalar minFi = p6DOF->getRotationalLimitMotor(0)->m_loLimit;
1305 btScalar maxFi = p6DOF->getRotationalLimitMotor(0)->m_hiLimit;
1308 getDebugDrawer()->drawArc(
center,
normal, ref, dbgDrawSize, dbgDrawSize, -
SIMD_PI,
SIMD_PI,
btVector3(0, 0, 0),
false);
1310 else if (minFi < maxFi)
1312 getDebugDrawer()->drawArc(
center,
normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi,
btVector3(0, 0, 0),
true);
1314 tr = p6DOF->getCalculatedTransformA();
1315 btVector3 bbMin = p6DOF->getTranslationalLimitMotor()->m_lowerLimit;
1316 btVector3 bbMax = p6DOF->getTranslationalLimitMotor()->m_upperLimit;
1317 getDebugDrawer()->drawBox(bbMin, bbMax, tr,
btVector3(0, 0, 0));
1325 btTransform tr = pSlider->getCalculatedTransformA();
1326 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1327 tr = pSlider->getCalculatedTransformB();
1328 if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize);
1331 btTransform tr = pSlider->getUseLinearReferenceFrameA() ? pSlider->getCalculatedTransformA() : pSlider->getCalculatedTransformB();
1334 getDebugDrawer()->drawLine(li_min, li_max,
btVector3(0, 0, 0));
1336 btVector3 axis = tr.getBasis().getColumn(1);
1337 btScalar a_min = pSlider->getLowerAngLimit();
1338 btScalar a_max = pSlider->getUpperAngLimit();
1339 const btVector3&
center = pSlider->getCalculatedTransformB().getOrigin();
1340 getDebugDrawer()->drawArc(
center,
normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max,
btVector3(0, 0, 0),
true);
1383 for (i = 0; i < m_collisionObjects.size(); i++)
1388 int len = colObj->calculateSerializeBufferSize();
1390 const char* structType = colObj->serialize(chunk->
m_oldPtr, serializer);
1398 int size = constraint->calculateSerializeBufferSize();
1400 const char* structType = constraint->serialize(chunk->
m_oldPtr, serializer);
1407 #ifdef BT_USE_DOUBLE_PRECISION
1417 memset(worldInfo, 0x00,
len);
1448 #ifdef BT_USE_DOUBLE_PRECISION
1449 const char* structType =
"btDynamicsWorldDoubleData";
1451 const char* structType =
"btDynamicsWorldFloatData";
1462 serializeCollisionObjects(serializer);
1466 serializeContactManifolds(serializer);
NSNotificationCenter * center
#define btAlignedFree(ptr)
#define btAlignedAlloc(size, alignment)
SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
#define DISABLE_DEACTIVATION
#define WANTS_DEACTIVATION
SIMD_FORCE_INLINE int getIslandTag() const
btConeTwistConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &rbAFrame, const btTransform &rbBFrame)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
SIMD_FORCE_INLINE int btGetConstraintIslandId(const btTypedConstraint *lhs)
int gNumClampedCcdMotions
internal debugging variable. this value shouldn't be too high
void updateActions(btScalar timeStep)
virtual void clearForces()
the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
void integrateTransformsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
btSimulationIslandManager * m_islandManager
virtual void saveKinematicState(btScalar timeStep)
virtual void solveConstraints(btContactSolverInfo &solverInfo)
virtual btConstraintSolver * getConstraintSolver()
virtual void removeRigidBody(btRigidBody *body)
InplaceSolverIslandCallback * m_solverIslandCallback
virtual void removeConstraint(btTypedConstraint *constraint)
bool m_applySpeculativeContactRestitution
virtual void createPredictiveContacts(btScalar timeStep)
void synchronizeSingleMotionState(btRigidBody *body)
this can be useful to synchronize a single rigid body -> graphics object
void createPredictiveContactsInternal(btRigidBody **bodies, int numBodies, btScalar timeStep)
virtual void addRigidBody(btRigidBody *body)
virtual void removeCharacter(btActionInterface *character)
obsolete, use removeAction instead
bool m_ownsConstraintSolver
void serializeRigidBodies(btSerializer *serializer)
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
virtual void synchronizeMotionStates()
bool m_synchronizeAllMotionStates
virtual btTypedConstraint * getConstraint(int index)
void serializeDynamicsWorldInfo(btSerializer *serializer)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::StaticFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter)
virtual void addAction(btActionInterface *)
virtual void addVehicle(btActionInterface *vehicle)
obsolete, use addAction instead
virtual void updateActivationState(btScalar timeStep)
btDiscreteDynamicsWorld(btDispatcher *dispatcher, btBroadphaseInterface *pairCache, btConstraintSolver *constraintSolver, btCollisionConfiguration *collisionConfiguration)
this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete thos...
virtual int getNumConstraints() const
virtual void addConstraint(btTypedConstraint *constraint, bool disableCollisionsBetweenLinkedBodies=false)
virtual void removeAction(btActionInterface *)
virtual void calculateSimulationIslands()
virtual void debugDrawWorld()
virtual void predictUnconstraintMotion(btScalar timeStep)
btAlignedObjectArray< btTypedConstraint * > m_constraints
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
virtual void integrateTransforms(btScalar timeStep)
btSimulationIslandManager * getSimulationIslandManager()
virtual void removeCollisionObject(btCollisionObject *collisionObject)
removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise ca...
btCollisionWorld * getCollisionWorld()
virtual void addCharacter(btActionInterface *character)
obsolete, use addAction instead
btAlignedObjectArray< btActionInterface * > m_actions
virtual void setConstraintSolver(btConstraintSolver *solver)
bool m_latencyMotionStateInterpolation
virtual int stepSimulation(btScalar timeStep, int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.))
if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
virtual void removeVehicle(btActionInterface *vehicle)
obsolete, use removeAction instead
virtual void debugDrawConstraint(btTypedConstraint *constraint)
btSpinMutex m_predictiveManifoldsMutex
btConstraintSolver * m_constraintSolver
virtual ~btDiscreteDynamicsWorld()
virtual void applyGravity()
apply gravity, call this once per timestep
virtual void internalSingleStepSimulation(btScalar timeStep)
void releasePredictiveContacts()
void startProfiling(btScalar timeStep)
btGeneric6DofConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btGeneric6DofSpring2Constraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, RotateOrder rotOrder=RO_XYZ)
void convexSweepTest(const class btConvexShape *castShape, const btTransform &convexFromWorld, const btTransform &convexToWorld, btCollisionWorld::ConvexResultCallback &resultCallback, btScalar allowedCcdPenetration=0.f) const
btHingeConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB, const btVector3 &axisInA, const btVector3 &axisInB, bool useReferenceFrameA=false)
btVector3 getGravity() const
void setGravity(const btVector3 &gravity)
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)
CalculateCombinedCallback gCalculateCombinedFrictionCallback
CalculateCombinedCallback gCalculateCombinedRestitutionCallback
btPoint2PointConstraint(btRigidBody &rbA, btRigidBody &rbB, const btVector3 &pivotInA, const btVector3 &pivotInB)
virtual bool serialize(void *o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const
Data buffer MUST be 16 byte aligned.
bool gDisableDeactivation
@ BT_DISABLE_WORLD_GRAVITY
SIMD_FORCE_INLINE btScalar btCos(btScalar x)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
SIMD_FORCE_INLINE btScalar btSin(btScalar x)
SIMD_FORCE_INLINE bool btFuzzyZero(btScalar x)
#define SIMD_FORCE_INLINE
btSequentialImpulseConstraintSolverMt int btPersistentManifold int btTypedConstraint ** constraints
btSequentialImpulseConstraintSolverMt int btPersistentManifold int btTypedConstraint int numConstraints
btSequentialImpulseConstraintSolverMt int numBodies
btSequentialImpulseConstraintSolverMt int btPersistentManifold int numManifolds
btSequentialImpulseConstraintSolver()
#define BT_RIGIDBODY_CODE
#define BT_DYNAMICSWORLD_CODE
#define BT_CONSTRAINT_CODE
btSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btSphereShape(btScalar radius)
SIMD_FORCE_INLINE void btMutexUnlock(btSpinMutex *mutex)
SIMD_FORCE_INLINE void btMutexLock(btSpinMutex *mutex)
btTypedConstraint(btTypedConstraintType type, btRigidBody &rbA)
@ CONETWIST_CONSTRAINT_TYPE
@ POINT2POINT_CONSTRAINT_TYPE
@ D6_SPRING_2_CONSTRAINT_TYPE
@ D6_SPRING_CONSTRAINT_TYPE
SIMD_FORCE_INLINE btScalar length2() const
Return the length of the vector squared.
btVector3
btVector3 can be used to represent 3D points and vectors. It has an un-used w component to suit 16-by...
Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWor...
SIMD_FORCE_INLINE void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
SIMD_FORCE_INLINE int size() const
return the number of elements in the array
void remove(const T &key)
SIMD_FORCE_INLINE void resize(int newsize, const T &fillData=T())
void quickSort(const L &CompareFunc)
SIMD_FORCE_INLINE void push_back(const T &_Val)
btDispatcher * m_dispatcher
btClosestNotMeConvexResultCallback(btCollisionObject *me, const btVector3 &fromA, const btVector3 &toA, btOverlappingPairCache *pairCache, btDispatcher *dispatcher)
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace)
btOverlappingPairCache * m_pairCache
btScalar m_allowedPenetration
virtual bool needsCollision(btBroadphaseProxy *proxy0) const
CollisionWorld is interface and container for the collision detection.
virtual void debugDrawWorld()
virtual void removeCollisionObject(btCollisionObject *collisionObject)
virtual void addCollisionObject(btCollisionObject *collisionObject, int collisionFilterGroup=btBroadphaseProxy::DefaultFilter, int collisionFilterMask=btBroadphaseProxy::AllFilter)
virtual void allSolved(const btContactSolverInfo &, class btIDebugDraw *)
virtual ~btConstraintSolver()
virtual void prepareSolve(int, int)
virtual btScalar solveGroup(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifold, int numManifolds, btTypedConstraint **constraints, int numConstraints, const btContactSolverInfo &info, class btIDebugDraw *debugDrawer, btDispatcher *dispatcher)=0
solve a group of constraints
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)=0
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)=0
The btDynamicsWorld is the interface class for several dynamics implementation, basic,...
virtual int getDebugMode() const =0
@ DBG_DrawConstraintLimits
const btVector3 & getPositionWorldOnB() const
btScalar m_combinedRestitution
btVector3 m_positionWorldOnA
m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
btScalar m_appliedImpulse
const btVector3 & getPositionWorldOnA() const
btVector3 m_normalWorldOnB
btScalar m_combinedFriction
btVector3 m_positionWorldOnB
virtual void setWorldTransform(const btTransform &worldTrans)=0
virtual btOverlapFilterCallback * getOverlapFilterCallback()=0
virtual btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
virtual bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const =0
SIMD_FORCE_INLINE const btCollisionShape * getCollisionShape() const
btMotionState * getMotionState()
void applyDamping(btScalar timeStep)
applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping
static const btRigidBody * upcast(const btCollisionObject *colObj)
void setGravity(const btVector3 &acceleration)
void proceedToTransform(const btTransform &newTrans)
void saveKinematicState(btScalar step)
const btBroadphaseProxy * getBroadphaseProxy() const
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
const btVector3 & getLinearVelocity() const
SIMD_FORCE_INLINE bool wantsSleeping()
SIMD_FORCE_INLINE void updateDeactivation(btScalar timeStep)
void setAngularVelocity(const btVector3 &ang_vel)
void setLinearVelocity(const btVector3 &lin_vel)
void predictIntegratedTransform(btScalar step, btTransform &predictedTransform)
continuous collision detection needs prediction
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void finishSerialization()=0
virtual void startSerialization()=0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
SimulationIslandManager creates and handles simulation islands, using btUnionFind.
virtual void storeIslandActivationState(btCollisionWorld *world)
btUnionFind & getUnionFind()
virtual void updateActivationState(btCollisionWorld *colWorld, btDispatcher *dispatcher)
void buildAndProcessIslands(btDispatcher *dispatcher, btCollisionWorld *collisionWorld, IslandCallback *callback)
virtual ~btSimulationIslandManager()
bool operator()(const btTypedConstraint *lhs, const btTypedConstraint *rhs) const
The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out)
SyclQueue void void size_t num_bytes void
IconTextureDrawCall normal
ccl_gpu_kernel_postfix ccl_global float int int sy
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
T length(const vec_base< T, Size > &a)
T distance(const T &a, const T &b)
btContactSolverInfo * m_solverInfo
btAlignedObjectArray< btCollisionObject * > m_bodies
InplaceSolverIslandCallback(btConstraintSolver *solver, btStackAlloc *stackAlloc, btDispatcher *dispatcher)
btAlignedObjectArray< btTypedConstraint * > m_constraints
void processConstraints()
InplaceSolverIslandCallback & operator=(InplaceSolverIslandCallback &other)
btDispatcher * m_dispatcher
btConstraintSolver * m_solver
btIDebugDraw * m_debugDrawer
btAlignedObjectArray< btPersistentManifold * > m_manifolds
virtual void processIsland(btCollisionObject **bodies, int numBodies, btPersistentManifold **manifolds, int numManifolds, int islandId)
btTypedConstraint ** m_sortedConstraints
SIMD_FORCE_INLINE void setup(btContactSolverInfo *solverInfo, btTypedConstraint **sortedConstraints, int numConstraints, btIDebugDraw *debugDrawer)
btVector3 m_convexToWorld
ClosestConvexResultCallback(const btVector3 &convexFromWorld, const btVector3 &convexToWorld)
btVector3 m_convexFromWorld
btVector3 m_hitNormalLocal
const btCollisionObject * m_hitCollisionObject
class btIDebugDraw * m_debugDraw
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btContactSolverInfoDoubleData m_solverInfo
btVector3DoubleData m_gravity
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64