From 4050da0e2f81f0114c98a8000f21fc8e4a6972ca Mon Sep 17 00:00:00 2001 From: ejcoumans Date: Thu, 2 Nov 2006 03:42:53 +0000 Subject: [PATCH] One of the last parts of the refactoring (hopefully), made most members of btCollisionObject protected. Also did some work on improving the constraint solver. --- Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp | 20 +- Demos/ColladaDemo/ColladaConverter.cpp | 8 +- .../CollisionInterfaceDemo.cpp | 22 +- Demos/ConcaveDemo/ConcavePhysicsDemo.cpp | 8 +- Demos/OpenGL/DemoApplication.cpp | 14 +- .../UserCollisionAlgorithm.cpp | 2 +- .../btCollisionAlgorithm.h | 2 +- .../BroadphaseCollision/btDispatcher.h | 2 +- .../CollisionDispatch/btCollisionCreateFunc.h | 4 +- .../btCollisionDispatcher.cpp | 12 +- .../CollisionDispatch/btCollisionObject.h | 188 ++++++++++++++++-- .../CollisionDispatch/btCollisionWorld.cpp | 27 +-- .../CollisionDispatch/btCollisionWorld.h | 2 +- .../btCompoundCollisionAlgorithm.cpp | 42 ++-- .../btConvexConcaveCollisionAlgorithm.cpp | 47 ++--- .../btConvexConvexAlgorithm.cpp | 49 +++-- .../CollisionDispatch/btManifoldResult.cpp | 8 +- .../CollisionDispatch/btManifoldResult.h | 6 +- .../btSimulationIslandManager.cpp | 32 +-- .../btSphereBoxCollisionAlgorithm.cpp | 10 +- .../btSphereSphereCollisionAlgorithm.cpp | 10 +- .../btSphereTriangleCollisionAlgorithm.cpp | 8 +- .../btDiscreteCollisionDetectorInterface.h | 6 +- .../ConstraintSolver/btContactConstraint.cpp | 24 ++- .../btSequentialImpulseConstraintSolver.cpp | 83 ++++---- .../ConstraintSolver/btTypedConstraint.cpp | 2 +- .../Dynamics/btDiscreteDynamicsWorld.cpp | 33 +-- .../Dynamics/btDiscreteDynamicsWorld.h | 3 +- src/BulletDynamics/Dynamics/btDynamicsWorld.h | 4 + src/BulletDynamics/Dynamics/btRigidBody.cpp | 40 ++-- src/BulletDynamics/Dynamics/btRigidBody.h | 8 +- .../Dynamics/btSimpleDynamicsWorld.cpp | 19 +- .../Dynamics/btSimpleDynamicsWorld.h | 2 + .../Vehicle/btRaycastVehicle.cpp | 3 +- 34 files changed, 485 insertions(+), 265 deletions(-) diff --git a/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp b/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp index b1cae4b72..d0f953f26 100644 --- a/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp +++ b/Demos/CcdPhysicsDemo/CcdPhysicsDemo.cpp @@ -12,7 +12,6 @@ subject to the following restrictions: 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ - //#define USE_KINEMATIC_GROUND 1 //#define PRINT_CONTACT_STATISTICS 1 //#define REGISTER_CUSTOM_COLLISION_ALGORITHM 1 @@ -82,7 +81,7 @@ btCollisionShape* shapePtr[numShapes] = ///Please don't make the box sizes larger then 1000: the collision detection will be inaccurate. ///See http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=346 -#define USE_GROUND_PLANE 1 +//#define USE_GROUND_PLANE 1 #ifdef USE_GROUND_PLANE new btStaticPlaneShape(btVector3(0,1,0),10), #else @@ -164,6 +163,19 @@ void CcdPhysicsDemo::clientMoveAndDisplay() if (m_dynamicsWorld) { + + //swap solver +#ifdef COMPARE_WITH_QUICKSTEP + if (m_debugMode & btIDebugDraw::DBG_DisableBulletLCP) + { + m_dynamicsWorld->setConstraintSolver( new OdeConstraintSolver()); + } else + { + m_dynamicsWorld->setConstraintSolver( new btSequentialImpulseConstraintSolver()); + } +#endif //COMPARE_WITH_QUICKSTEP + + //during idle mode, just run 1 simulation step maximum int maxSimSubSteps = m_idle ? 1 : 1; if (m_idle) @@ -356,10 +368,10 @@ void CcdPhysicsDemo::initPhysics() // Only do CCD if motion in one timestep (1.f/60.f) exceeds CUBE_HALF_EXTENTS - body->m_ccdSquareMotionThreshold = CUBE_HALF_EXTENTS; + body->setCcdSquareMotionThreshold( CUBE_HALF_EXTENTS ); //Experimental: better estimation of CCD Time of Impact: - body->m_ccdSweptSphereRadius = 0.2*CUBE_HALF_EXTENTS; + body->setCcdSweptSphereRadius( 0.2*CUBE_HALF_EXTENTS ); #ifdef USER_DEFINED_FRICTION_MODEL ///Advanced use: override the friction solver diff --git a/Demos/ColladaDemo/ColladaConverter.cpp b/Demos/ColladaDemo/ColladaConverter.cpp index 53d5e15ae..95eb4b7aa 100644 --- a/Demos/ColladaDemo/ColladaConverter.cpp +++ b/Demos/ColladaDemo/ColladaConverter.cpp @@ -543,9 +543,9 @@ void ColladaConverter::prepareConstraints(ConstraintInput& input) for (int i=0;im_userObjectPointer) + if (m_rigidBodies[i]->getUserPointer()) { - char* bodyName = (char*)m_rigidBodies[i]->m_userObjectPointer; + char* bodyName = (char*)m_rigidBodies[i]->getUserPointer(); if (!strcmp(bodyName,orgUri0)) { body0=m_rigidBodies[i]; @@ -707,7 +707,7 @@ void ColladaConverter::PreparePhysicsObject(struct btRigidBodyInput& input, bool if (body) { //bodyName is used as identifier for constraints - body->m_userObjectPointer = (void*)input.m_bodyName; + body->setUserPointer((void*)input.m_bodyName); m_rigidBodies[m_numObjects] = body; m_numObjects++; } @@ -737,7 +737,7 @@ bool ColladaConverter::saveAs(const char* filename) { - btVector3 np = m_rigidBodies[i]->m_worldTransform.getOrigin(); + btVector3 np = m_rigidBodies[i]->getWorldTransform().getOrigin(); domFloat3 newPos = m_colladadomNodes[i]->getTranslate_array().get(0)->getValue(); newPos.set(0,np[0]); newPos.set(1,np[1]); diff --git a/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp b/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp index 4bba84fc5..bfdd44924 100644 --- a/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp +++ b/Demos/CollisionInterfaceDemo/CollisionInterfaceDemo.cpp @@ -65,8 +65,8 @@ void CollisionInterfaceDemo::initPhysics() btMatrix3x3 basisB; basisB.setIdentity(); - objects[0].m_worldTransform.setBasis(basisA); - objects[1].m_worldTransform.setBasis(basisB); + objects[0].getWorldTransform().setBasis(basisA); + objects[1].getWorldTransform().setBasis(basisB); //btPoint3 points0[3]={btPoint3(1,0,0),btPoint3(0,1,0),btPoint3(0,0,1)}; //btPoint3 points1[5]={btPoint3(1,0,0),btPoint3(0,1,0),btPoint3(0,0,1),btPoint3(0,0,-1),btPoint3(-1,-1,0)}; @@ -78,8 +78,8 @@ void CollisionInterfaceDemo::initPhysics() //ConvexHullShape hullB(points1,4); //hullB.setLocalScaling(btVector3(4,4,4)); - objects[0].m_collisionShape = boxA;//&hullA; - objects[1].m_collisionShape = boxB;//&hullB; + objects[0].setCollisionShape(boxA);//&hullA; + objects[1].setCollisionShape(boxB);//&hullB; btCollisionDispatcher* dispatcher = new btCollisionDispatcher; btVector3 worldAabbMin(-1000,-1000,-1000); @@ -130,7 +130,7 @@ void CollisionInterfaceDemo::displayCallback(void) { btPersistentManifold* contactManifold = collisionWorld->getDispatcher()->getManifoldByIndexInternal(i); btCollisionObject* obA = static_cast(contactManifold->getBody0()); btCollisionObject* obB = static_cast(contactManifold->getBody1()); - contactManifold->refreshContactPoints(obA->m_worldTransform,obB->m_worldTransform); + contactManifold->refreshContactPoints(obA->getWorldTransform(),obB->getWorldTransform()); int numContacts = contactManifold->getNumContacts(); for (int j=0;jgetRestitution(); float restitution1 = colObj1->getRestitution(); - if (colObj0->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) + if (colObj0->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) { friction0 = 1.0;//partId0,index0 restitution0 = 0.f; } - if (colObj1->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) + if (colObj1->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) { if (index1&1) { @@ -161,10 +161,10 @@ void ConcaveDemo::initPhysics() btRigidBody* staticBody = localCreateRigidBody(mass, startTransform,trimeshShape); - staticBody->m_collisionFlags |=btCollisionObject::CF_STATIC_OBJECT; + staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_STATIC_OBJECT); //enable custom material callback - staticBody->m_collisionFlags |= btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK; + staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK); { for (int i=0;i<10;i++) diff --git a/Demos/OpenGL/DemoApplication.cpp b/Demos/OpenGL/DemoApplication.cpp index 13e260be4..104ee36f8 100644 --- a/Demos/OpenGL/DemoApplication.cpp +++ b/Demos/OpenGL/DemoApplication.cpp @@ -435,8 +435,8 @@ void DemoApplication::shootBox(const btVector3& destination) linVel.normalize(); linVel*=m_ShootBoxInitialSpeed; - body->m_worldTransform.setOrigin(camPos); - body->m_worldTransform.setRotation(btQuaternion(0,0,0,1)); + body->getWorldTransform().setOrigin(camPos); + body->getWorldTransform().setRotation(btQuaternion(0,0,0,1)); body->setLinearVelocity(linVel); body->setAngularVelocity(btVector3(0,0,0)); } @@ -597,7 +597,7 @@ void DemoApplication::mouseFunc(int button, int state, int x, int y) //printf("removed constraint %i",gPickingConstraintId); m_pickConstraint = 0; pickedBody->ForceActivationState(ACTIVE_TAG); - pickedBody->m_deactivationTime = 0.f; + pickedBody->setDeactivationTime( 0.f ); pickedBody = 0; } @@ -690,7 +690,7 @@ void DemoApplication::renderme() myMotionState->m_graphicsWorldTrans.getOpenGLMatrix(m); } else { - colObj->m_worldTransform.getOpenGLMatrix(m); + colObj->getWorldTransform().getOpenGLMatrix(m); } btVector3 wireColor(1.f,1.0f,0.5f); //wants deactivation @@ -720,7 +720,7 @@ void DemoApplication::renderme() } } - GL_ShapeDrawer::drawOpenGL(m,colObj->m_collisionShape,wireColor,getDebugMode()); + GL_ShapeDrawer::drawOpenGL(m,colObj->getCollisionShape(),wireColor,getDebugMode()); } @@ -832,8 +832,8 @@ void DemoApplication::clientResetScene() { btDefaultMotionState* myMotionState = (btDefaultMotionState*)body->getMotionState(); myMotionState->m_graphicsWorldTrans = myMotionState->m_startWorldTrans; - colObj->m_worldTransform = myMotionState->m_graphicsWorldTrans; - colObj->m_interpolationWorldTransform = myMotionState->m_startWorldTrans; + colObj->setWorldTransform( myMotionState->m_graphicsWorldTrans ); + colObj->setInterpolationWorldTransform( myMotionState->m_startWorldTrans ); btRigidBody* body = btRigidBody::upcast(colObj); if (body && !body->isStaticObject()) { diff --git a/Demos/UserCollisionAlgorithm/UserCollisionAlgorithm.cpp b/Demos/UserCollisionAlgorithm/UserCollisionAlgorithm.cpp index 2b7520ce9..2f3af6f39 100644 --- a/Demos/UserCollisionAlgorithm/UserCollisionAlgorithm.cpp +++ b/Demos/UserCollisionAlgorithm/UserCollisionAlgorithm.cpp @@ -123,7 +123,7 @@ void UserCollisionAlgorithm::initPhysics() btRigidBody* staticBody= localCreateRigidBody(mass, startTransform,trimeshShape); //enable custom material callback - staticBody->m_collisionFlags |= btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK; + staticBody->setCollisionFlags(staticBody->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK); { for (int i=0;i<10;i++) diff --git a/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h b/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h index 3195f996f..f9e220570 100644 --- a/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h +++ b/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h @@ -19,7 +19,7 @@ subject to the following restrictions: struct btBroadphaseProxy; class btDispatcher; class btManifoldResult; -struct btCollisionObject; +class btCollisionObject; struct btDispatcherInfo; class btPersistentManifold; diff --git a/src/BulletCollision/BroadphaseCollision/btDispatcher.h b/src/BulletCollision/BroadphaseCollision/btDispatcher.h index 75ef338fd..2b7f19fc4 100644 --- a/src/BulletCollision/BroadphaseCollision/btDispatcher.h +++ b/src/BulletCollision/BroadphaseCollision/btDispatcher.h @@ -19,7 +19,7 @@ subject to the following restrictions: class btCollisionAlgorithm; struct btBroadphaseProxy; class btRigidBody; -struct btCollisionObject; +class btCollisionObject; class btOverlappingPairCache; enum btCollisionDispatcherId diff --git a/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h b/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h index 77274ceb8..b4a46ca61 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h +++ b/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h @@ -18,9 +18,9 @@ subject to the following restrictions: #include -typedef std::vector btCollisionObjectArray; +typedef std::vector btCollisionObjectArray; class btCollisionAlgorithm; -struct btCollisionObject; +class btCollisionObject; struct btCollisionAlgorithmConstructionInfo; diff --git a/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp b/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp index ebfccef9c..e463adbd5 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp +++ b/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp @@ -150,7 +150,7 @@ btCollisionAlgorithm* btCollisionDispatcher::findAlgorithm(btCollisionObject* bo btCollisionAlgorithmConstructionInfo ci; ci.m_dispatcher = this; ci.m_manifold = sharedManifold; - btCollisionAlgorithm* algo = m_doubleDispatch[body0->m_collisionShape->getShapeType()][body1->m_collisionShape->getShapeType()] + btCollisionAlgorithm* algo = m_doubleDispatch[body0->getCollisionShape()->getShapeType()][body1->getCollisionShape()->getShapeType()] ->CreateCollisionAlgorithm(ci,body0,body1); #else btCollisionAlgorithm* algo = internalFindAlgorithm(body0,body1); @@ -201,27 +201,27 @@ btCollisionAlgorithm* btCollisionDispatcher::internalFindAlgorithm(btCollisionOb btCollisionAlgorithmConstructionInfo ci; ci.m_dispatcher = this; - if (body0->m_collisionShape->isConvex() && body1->m_collisionShape->isConvex() ) + if (body0->getCollisionShape()->isConvex() && body1->getCollisionShape()->isConvex() ) { return new btConvexConvexAlgorithm(sharedManifold,ci,body0,body1); } - if (body0->m_collisionShape->isConvex() && body1->m_collisionShape->isConcave()) + if (body0->getCollisionShape()->isConvex() && body1->getCollisionShape()->isConcave()) { return new btConvexConcaveCollisionAlgorithm(ci,body0,body1,false); } - if (body1->m_collisionShape->isConvex() && body0->m_collisionShape->isConcave()) + if (body1->getCollisionShape()->isConvex() && body0->getCollisionShape()->isConcave()) { return new btConvexConcaveCollisionAlgorithm(ci,body0,body1,true); } - if (body0->m_collisionShape->isCompound()) + if (body0->getCollisionShape()->isCompound()) { return new btCompoundCollisionAlgorithm(ci,body0,body1,false); } else { - if (body1->m_collisionShape->isCompound()) + if (body1->getCollisionShape()->isCompound()) { return new btCompoundCollisionAlgorithm(ci,body0,body1,true); } diff --git a/src/BulletCollision/CollisionDispatch/btCollisionObject.h b/src/BulletCollision/CollisionDispatch/btCollisionObject.h index 5df3de489..087ea7f4a 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionObject.h +++ b/src/BulletCollision/CollisionDispatch/btCollisionObject.h @@ -34,8 +34,11 @@ class btCollisionShape; /// btCollisionObject can be used to manage collision detection objects. /// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. /// They can be added to the btCollisionWorld. -struct btCollisionObject +class btCollisionObject { + +protected: + btTransform m_worldTransform; btBroadphaseProxy* m_broadphaseHandle; btCollisionShape* m_collisionShape; @@ -48,15 +51,6 @@ struct btCollisionObject btVector3 m_interpolationLinearVelocity; btVector3 m_interpolationAngularVelocity; - - enum CollisionFlags - { - CF_STATIC_OBJECT= 1, - CF_KINEMATIC_OJBECT= 2, - CF_NO_CONTACT_RESPONSE = 4, - CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution) - }; - int m_collisionFlags; int m_islandTag1; @@ -66,7 +60,7 @@ struct btCollisionObject btScalar m_friction; btScalar m_restitution; - ///users can point to their objects, m_userPointer is not used by Bullet + ///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer void* m_userObjectPointer; ///m_internalOwner is reserved to point to Bullet's btRigidBody. Don't use this, use m_userObjectPointer instead. @@ -81,6 +75,17 @@ struct btCollisionObject /// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold float m_ccdSquareMotionThreshold; +public: + + enum CollisionFlags + { + CF_STATIC_OBJECT= 1, + CF_KINEMATIC_OJBECT= 2, + CF_NO_CONTACT_RESPONSE = 4, + CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution) + }; + + inline bool mergesSimulationIslands() const { ///static objects, kinematic and object without contact response don't merge islands @@ -107,20 +112,40 @@ struct btCollisionObject } - - btCollisionObject(); - void SetCollisionShape(btCollisionShape* collisionShape) + void setCollisionShape(btCollisionShape* collisionShape) { m_collisionShape = collisionShape; } + const btCollisionShape* getCollisionShape() const + { + return m_collisionShape; + } + + btCollisionShape* getCollisionShape() + { + return m_collisionShape; + } + + + + int GetActivationState() const { return m_activationState1;} void SetActivationState(int newState); + void setDeactivationTime(float time) + { + m_deactivationTime = time; + } + float getDeactivationTime() const + { + return m_deactivationTime; + } + void ForceActivationState(int newState); void activate(); @@ -147,6 +172,141 @@ struct btCollisionObject return m_friction; } + ///reserved for Bullet internal usage + void* getInternalOwner() + { + return m_internalOwner; + } + + const void* getInternalOwner() const + { + return m_internalOwner; + } + + btTransform& getWorldTransform() + { + return m_worldTransform; + } + + const btTransform& getWorldTransform() const + { + return m_worldTransform; + } + + void setWorldTransform(const btTransform& worldTrans) + { + m_worldTransform = worldTrans; + } + + + btBroadphaseProxy* getBroadphaseHandle() + { + return m_broadphaseHandle; + } + + const btBroadphaseProxy* getBroadphaseHandle() const + { + return m_broadphaseHandle; + } + + void setBroadphaseHandle(btBroadphaseProxy* handle) + { + m_broadphaseHandle = handle; + } + + + const btTransform& getInterpolationWorldTransform() const + { + return m_interpolationWorldTransform; + } + + btTransform& getInterpolationWorldTransform() + { + return m_interpolationWorldTransform; + } + + void setInterpolationWorldTransform(const btTransform& trans) + { + m_interpolationWorldTransform = trans; + } + + + const btVector3& getInterpolationLinearVelocity() const + { + return m_interpolationLinearVelocity; + } + + const btVector3& getInterpolationAngularVelocity() const + { + return m_interpolationAngularVelocity; + } + + const int getIslandTag() const + { + return m_islandTag1; + } + + void setIslandTag(int tag) + { + m_islandTag1 = tag; + } + + const float getHitFraction() const + { + return m_hitFraction; + } + + void setHitFraction(float hitFraction) + { + m_hitFraction = hitFraction; + } + + + const int getCollisionFlags() const + { + return m_collisionFlags; + } + + void setCollisionFlags(int flags) + { + m_collisionFlags = flags; + } + + ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: + float getCcdSweptSphereRadius() const + { + return m_ccdSweptSphereRadius; + } + + ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: + void setCcdSweptSphereRadius(float radius) + { + m_ccdSweptSphereRadius = radius; + } + + float getCcdSquareMotionThreshold() const + { + return m_ccdSquareMotionThreshold; + } + + + /// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold + void setCcdSquareMotionThreshold(float ccdSquareMotionThreshold) + { + m_ccdSquareMotionThreshold = ccdSquareMotionThreshold; + } + + ///users can point to their objects, userPointer is not used by Bullet + void* getUserPointer() + { + return m_userObjectPointer; + } + + ///users can point to their objects, userPointer is not used by Bullet + void setUserPointer(void* userPointer) + { + m_userObjectPointer = userPointer; + } }; diff --git a/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp b/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp index e24a5c6a0..5f6f70b9f 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp +++ b/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp @@ -60,7 +60,7 @@ btCollisionWorld::~btCollisionWorld() { btCollisionObject* collisionObject= (*i); - btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle; + btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle(); if (bp) { // @@ -98,21 +98,22 @@ void btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject,sho m_collisionObjects.push_back(collisionObject); //calculate new AABB - btTransform trans = collisionObject->m_worldTransform; + btTransform trans = collisionObject->getWorldTransform(); btVector3 minAabb; btVector3 maxAabb; - collisionObject->m_collisionShape->getAabb(trans,minAabb,maxAabb); + collisionObject->getCollisionShape()->getAabb(trans,minAabb,maxAabb); - int type = collisionObject->m_collisionShape->getShapeType(); - collisionObject->m_broadphaseHandle = getBroadphase()->createProxy( + int type = collisionObject->getCollisionShape()->getShapeType(); + collisionObject->setBroadphaseHandle( getBroadphase()->createProxy( minAabb, maxAabb, type, collisionObject, collisionFilterGroup, collisionFilterMask - ); + )) ; + @@ -132,8 +133,8 @@ void btCollisionWorld::performDiscreteCollisionDetection() btVector3 aabbMin,aabbMax; for (size_t i=0;im_collisionShape->getAabb(m_collisionObjects[i]->m_worldTransform,aabbMin,aabbMax); - m_broadphasePairCache->setAabb(m_collisionObjects[i]->m_broadphaseHandle,aabbMin,aabbMax); + m_collisionObjects[i]->getCollisionShape()->getAabb(m_collisionObjects[i]->getWorldTransform(),aabbMin,aabbMax); + m_broadphasePairCache->setAabb(m_collisionObjects[i]->getBroadphaseHandle(),aabbMin,aabbMax); } m_broadphasePairCache->refreshOverlappingPairs(); @@ -155,7 +156,7 @@ void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject) { - btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle; + btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle(); if (bp) { // @@ -163,7 +164,7 @@ void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject) // getBroadphase()->cleanProxyFromPairs(bp); getBroadphase()->destroyProxy(bp); - collisionObject->m_broadphaseHandle = 0; + collisionObject->setBroadphaseHandle(0); } } @@ -338,7 +339,7 @@ void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); btVector3 collisionObjectAabbMin,collisionObjectAabbMax; - collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax); + collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax); //check aabb overlap @@ -346,8 +347,8 @@ void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r { rayTestSingle(rayFromTrans,rayToTrans, collisionObject, - collisionObject->m_collisionShape, - collisionObject->m_worldTransform, + collisionObject->getCollisionShape(), + collisionObject->getWorldTransform(), resultCallback); } diff --git a/src/BulletCollision/CollisionDispatch/btCollisionWorld.h b/src/BulletCollision/CollisionDispatch/btCollisionWorld.h index a1cf3a0e5..e2b8eb112 100644 --- a/src/BulletCollision/CollisionDispatch/btCollisionWorld.h +++ b/src/BulletCollision/CollisionDispatch/btCollisionWorld.h @@ -194,7 +194,7 @@ public: m_closestHitFraction = rayResult.m_hitFraction; m_collisionObject = rayResult.m_collisionObject; - m_hitNormalWorld = m_collisionObject->m_worldTransform.getBasis()*rayResult.m_hitNormalLocal; + m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal; m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction); return rayResult.m_hitFraction; } diff --git a/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp index febd726b5..43887d26a 100644 --- a/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp @@ -23,9 +23,9 @@ btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlg { btCollisionObject* colObj = m_isSwapped? body1 : body0; btCollisionObject* otherObj = m_isSwapped? body0 : body1; - assert (colObj->m_collisionShape->isCompound()); + assert (colObj->getCollisionShape()->isCompound()); - btCompoundShape* compoundShape = static_cast(colObj->m_collisionShape); + btCompoundShape* compoundShape = static_cast(colObj->getCollisionShape()); int numChildren = compoundShape->getNumChildShapes(); int i; @@ -33,10 +33,10 @@ btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm( const btCollisionAlg for (i=0;igetChildShape(i); - btCollisionShape* orgShape = colObj->m_collisionShape; - colObj->m_collisionShape = childShape; + btCollisionShape* orgShape = colObj->getCollisionShape(); + colObj->setCollisionShape( childShape ); m_childCollisionAlgorithms[i] = ci.m_dispatcher->findAlgorithm(colObj,otherObj); - colObj->m_collisionShape =orgShape; + colObj->setCollisionShape( orgShape ); } } @@ -56,8 +56,8 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt btCollisionObject* colObj = m_isSwapped? body1 : body0; btCollisionObject* otherObj = m_isSwapped? body0 : body1; - assert (colObj->m_collisionShape->isCompound()); - btCompoundShape* compoundShape = static_cast(colObj->m_collisionShape); + assert (colObj->getCollisionShape()->isCompound()); + btCompoundShape* compoundShape = static_cast(colObj->getCollisionShape()); //We will use the OptimizedBVH, AABB tree to cull potential child-overlaps //If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals @@ -74,18 +74,18 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt btCollisionShape* childShape = compoundShape->getChildShape(i); //backup - btTransform orgTrans = colObj->m_worldTransform; - btCollisionShape* orgShape = colObj->m_collisionShape; + btTransform orgTrans = colObj->getWorldTransform(); + btCollisionShape* orgShape = colObj->getCollisionShape(); btTransform childTrans = compoundShape->getChildTransform(i); btTransform newChildWorldTrans = orgTrans*childTrans ; - colObj->m_worldTransform = newChildWorldTrans; + colObj->setWorldTransform( newChildWorldTrans ); //the contactpoint is still projected back using the original inverted worldtrans - colObj->m_collisionShape = childShape; + colObj->setCollisionShape( childShape ); m_childCollisionAlgorithms[i]->processCollision(colObj,otherObj,dispatchInfo,resultOut); //revert back - colObj->m_collisionShape =orgShape; - colObj->m_worldTransform = orgTrans; + colObj->setCollisionShape( orgShape); + colObj->setWorldTransform( orgTrans ); } } @@ -95,9 +95,9 @@ float btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod btCollisionObject* colObj = m_isSwapped? body1 : body0; btCollisionObject* otherObj = m_isSwapped? body0 : body1; - assert (colObj->m_collisionShape->isCompound()); + assert (colObj->getCollisionShape()->isCompound()); - btCompoundShape* compoundShape = static_cast(colObj->m_collisionShape); + btCompoundShape* compoundShape = static_cast(colObj->getCollisionShape()); //We will use the OptimizedBVH, AABB tree to cull potential child-overlaps //If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals @@ -116,22 +116,22 @@ float btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod btCollisionShape* childShape = compoundShape->getChildShape(i); //backup - btTransform orgTrans = colObj->m_worldTransform; - btCollisionShape* orgShape = colObj->m_collisionShape; + btTransform orgTrans = colObj->getWorldTransform(); + btCollisionShape* orgShape = colObj->getCollisionShape(); btTransform childTrans = compoundShape->getChildTransform(i); btTransform newChildWorldTrans = orgTrans*childTrans ; - colObj->m_worldTransform = newChildWorldTrans; + colObj->setWorldTransform( newChildWorldTrans ); - colObj->m_collisionShape = childShape; + colObj->setCollisionShape( childShape ); float frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut); if (fracm_collisionShape =orgShape; - colObj->m_worldTransform = orgTrans; + colObj->setCollisionShape( orgShape); + colObj->setWorldTransform( orgTrans); } return hitFraction; diff --git a/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp index 7cb0bba62..8ad3967ba 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp @@ -89,7 +89,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && m_dispatchInfoPtr->m_debugDraw->getDebugMode() > 0) { btVector3 color(255,255,0); - btTransform& tr = ob->m_worldTransform; + btTransform& tr = ob->getWorldTransform(); m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(triangle[1]),color); m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color); m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color); @@ -105,14 +105,14 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i //btCollisionObject* colObj = static_cast(m_convexProxy->m_clientObject); - if (m_convexBody->m_collisionShape->isConvex()) + if (m_convexBody->getCollisionShape()->isConvex()) { btTriangleShape tm(triangle[0],triangle[1],triangle[2]); tm.setMargin(m_collisionMarginTriangle); - btCollisionShape* tmpShape = ob->m_collisionShape; - ob->m_collisionShape = &tm; + btCollisionShape* tmpShape = ob->getCollisionShape(); + ob->setCollisionShape( &tm ); btCollisionAlgorithm* colAlgo = ci.m_dispatcher->findAlgorithm(m_convexBody,m_triBody,m_manifoldPtr); @@ -124,7 +124,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i // cvxcvxalgo.processCollision(m_convexBody,m_triBody,*m_dispatchInfoPtr,m_resultOut); colAlgo->processCollision(m_convexBody,m_triBody,*m_dispatchInfoPtr,m_resultOut); delete colAlgo; - ob->m_collisionShape = tmpShape; + ob->setCollisionShape( tmpShape ); } @@ -142,8 +142,8 @@ void btConvexTriangleCallback::setTimeStepAndCounters(float collisionMarginTrian //recalc aabbs btTransform convexInTriangleSpace; - convexInTriangleSpace = m_triBody->m_worldTransform.inverse() * m_convexBody->m_worldTransform; - btCollisionShape* convexShape = static_cast(m_convexBody->m_collisionShape); + convexInTriangleSpace = m_triBody->getWorldTransform().inverse() * m_convexBody->getWorldTransform(); + btCollisionShape* convexShape = static_cast(m_convexBody->getCollisionShape()); //CollisionShape* triangleShape = static_cast(triBody->m_collisionShape); convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax); float extraMargin = collisionMarginTriangle; @@ -167,14 +167,14 @@ void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* bod btCollisionObject* convexBody = m_isSwapped ? body1 : body0; btCollisionObject* triBody = m_isSwapped ? body0 : body1; - if (triBody->m_collisionShape->isConcave()) + if (triBody->getCollisionShape()->isConcave()) { btCollisionObject* triOb = triBody; - ConcaveShape* concaveShape = static_cast( triOb->m_collisionShape); + ConcaveShape* concaveShape = static_cast( triOb->getCollisionShape()); - if (convexBody->m_collisionShape->isConvex()) + if (convexBody->getCollisionShape()->isConvex()) { float collisionMarginTriangle = concaveShape->getMargin(); @@ -207,8 +207,8 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject //only perform CCD above a certain threshold, this prevents blocking on the long run //because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame... - float squareMot0 = (convexbody->m_interpolationWorldTransform.getOrigin() - convexbody->m_worldTransform.getOrigin()).length2(); - if (squareMot0 < convexbody->m_ccdSquareMotionThreshold) + float squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2(); + if (squareMot0 < convexbody->getCcdSquareMotionThreshold()) { return 1.f; } @@ -217,9 +217,9 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject //btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin(); //todo: only do if the motion exceeds the 'radius' - btTransform triInv = triBody->m_worldTransform.inverse(); - btTransform convexFromLocal = triInv * convexbody->m_worldTransform; - btTransform convexToLocal = triInv * convexbody->m_interpolationWorldTransform; + btTransform triInv = triBody->getWorldTransform().inverse(); + btTransform convexFromLocal = triInv * convexbody->getWorldTransform(); + btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform(); struct LocalTriangleSphereCastCallback : public btTriangleCallback { @@ -270,24 +270,25 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject - if (triBody->m_collisionShape->isConcave()) + if (triBody->getCollisionShape()->isConcave()) { btVector3 rayAabbMin = convexFromLocal.getOrigin(); rayAabbMin.setMin(convexToLocal.getOrigin()); btVector3 rayAabbMax = convexFromLocal.getOrigin(); rayAabbMax.setMax(convexToLocal.getOrigin()); - rayAabbMin -= btVector3(convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius); - rayAabbMax += btVector3(convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius,convexbody->m_ccdSweptSphereRadius); + float ccdRadius0 = convexbody->getCcdSweptSphereRadius(); + rayAabbMin -= btVector3(ccdRadius0,ccdRadius0,ccdRadius0); + rayAabbMax += btVector3(ccdRadius0,ccdRadius0,ccdRadius0); float curHitFraction = 1.f; //is this available? LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal, - convexbody->m_ccdSweptSphereRadius,curHitFraction); + convexbody->getCcdSweptSphereRadius(),curHitFraction); - raycastCallback.m_hitFraction = convexbody->m_hitFraction; + raycastCallback.m_hitFraction = convexbody->getHitFraction(); btCollisionObject* concavebody = triBody; - ConcaveShape* triangleMesh = (ConcaveShape*) concavebody->m_collisionShape; + ConcaveShape* triangleMesh = (ConcaveShape*) concavebody->getCollisionShape(); if (triangleMesh) { @@ -296,9 +297,9 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject - if (raycastCallback.m_hitFraction < convexbody->m_hitFraction) + if (raycastCallback.m_hitFraction < convexbody->getHitFraction()) { - convexbody->m_hitFraction = raycastCallback.m_hitFraction; + convexbody->setHitFraction( raycastCallback.m_hitFraction); return raycastCallback.m_hitFraction; } } diff --git a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp index 5347ef05b..36b0d15ea 100644 --- a/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp @@ -157,8 +157,8 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl checkPenetrationDepthSolver(); - btConvexShape* min0 = static_cast(body0->m_collisionShape); - btConvexShape* min1 = static_cast(body1->m_collisionShape); + btConvexShape* min0 = static_cast(body0->getCollisionShape()); + btConvexShape* min1 = static_cast(body1->getCollisionShape()); btGjkPairDetector::ClosestPointInput input; @@ -170,8 +170,8 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl // input.m_maximumDistanceSquared = 1e30f; - input.m_transformA = body0->m_worldTransform; - input.m_transformB = body1->m_worldTransform; + input.m_transformA = body0->getWorldTransform(); + input.m_transformB = body1->getWorldTransform(); resultOut->setPersistentManifold(m_manifoldPtr); m_gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw); @@ -190,14 +190,13 @@ float btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btC float resultFraction = 1.f; - float squareMot0 = (col0->m_interpolationWorldTransform.getOrigin() - col0->m_worldTransform.getOrigin()).length2(); + float squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2(); + float squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2(); - if (squareMot0 < col0->m_ccdSquareMotionThreshold && - squareMot0 < col0->m_ccdSquareMotionThreshold) + if (squareMot0 < col0->getCcdSquareMotionThreshold() && + squareMot1 < col1->getCcdSquareMotionThreshold()) return resultFraction; - - if (disableCcd) return 1.f; @@ -212,26 +211,26 @@ float btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btC /// Convex0 against sphere for Convex1 { - btConvexShape* convex0 = static_cast(col0->m_collisionShape); + btConvexShape* convex0 = static_cast(col0->getCollisionShape()); - btSphereShape sphere1(col1->m_ccdSweptSphereRadius); //todo: allow non-zero sphere sizes, for better approximation + btSphereShape sphere1(col1->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation btConvexCast::CastResult result; btVoronoiSimplexSolver voronoiSimplex; //SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex); ///Simplification, one object is simplified as a sphere btGjkConvexCast ccd1( convex0 ,&sphere1,&voronoiSimplex); //ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0); - if (ccd1.calcTimeOfImpact(col0->m_worldTransform,col0->m_interpolationWorldTransform, - col1->m_worldTransform,col1->m_interpolationWorldTransform,result)) + if (ccd1.calcTimeOfImpact(col0->getWorldTransform(),col0->getInterpolationWorldTransform(), + col1->getWorldTransform(),col1->getInterpolationWorldTransform(),result)) { //store result.m_fraction in both bodies - if (col0->m_hitFraction > result.m_fraction) - col0->m_hitFraction = result.m_fraction; + if (col0->getHitFraction()> result.m_fraction) + col0->setHitFraction( result.m_fraction ); - if (col1->m_hitFraction > result.m_fraction) - col1->m_hitFraction = result.m_fraction; + if (col1->getHitFraction() > result.m_fraction) + col1->setHitFraction( result.m_fraction); if (resultFraction > result.m_fraction) resultFraction = result.m_fraction; @@ -245,26 +244,26 @@ float btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btC /// Sphere (for convex0) against Convex1 { - btConvexShape* convex1 = static_cast(col1->m_collisionShape); + btConvexShape* convex1 = static_cast(col1->getCollisionShape()); - btSphereShape sphere0(col0->m_ccdSweptSphereRadius); //todo: allow non-zero sphere sizes, for better approximation + btSphereShape sphere0(col0->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation btConvexCast::CastResult result; btVoronoiSimplexSolver voronoiSimplex; //SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex); ///Simplification, one object is simplified as a sphere btGjkConvexCast ccd1(&sphere0,convex1,&voronoiSimplex); //ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0); - if (ccd1.calcTimeOfImpact(col0->m_worldTransform,col0->m_interpolationWorldTransform, - col1->m_worldTransform,col1->m_interpolationWorldTransform,result)) + if (ccd1.calcTimeOfImpact(col0->getWorldTransform(),col0->getInterpolationWorldTransform(), + col1->getWorldTransform(),col1->getInterpolationWorldTransform(),result)) { //store result.m_fraction in both bodies - if (col0->m_hitFraction > result.m_fraction) - col0->m_hitFraction = result.m_fraction; + if (col0->getHitFraction() > result.m_fraction) + col0->setHitFraction( result.m_fraction); - if (col1->m_hitFraction > result.m_fraction) - col1->m_hitFraction = result.m_fraction; + if (col1->getHitFraction() > result.m_fraction) + col1->setHitFraction( result.m_fraction); if (resultFraction > result.m_fraction) resultFraction = result.m_fraction; diff --git a/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp b/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp index 1d3941101..cd22f3dd9 100644 --- a/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp +++ b/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp @@ -48,8 +48,8 @@ btManifoldResult::btManifoldResult(btCollisionObject* body0,btCollisionObject* b m_body0(body0), m_body1(body1) { - m_rootTransA = body0->m_worldTransform; - m_rootTransB = body1->m_worldTransform; + m_rootTransA = body0->getWorldTransform(); + m_rootTransB = body1->getWorldTransform(); } @@ -81,8 +81,8 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const b //User can override friction and/or restitution if (gContactAddedCallback && //and if either of the two bodies requires custom material - ((m_body0->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) || - (m_body1->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK))) + ((m_body0->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) || + (m_body1->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK))) { //experimental feature info, for per-triangle material etc. btCollisionObject* obj0 = isSwapped? m_body1 : m_body0; diff --git a/src/BulletCollision/CollisionDispatch/btManifoldResult.h b/src/BulletCollision/CollisionDispatch/btManifoldResult.h index f9aae4e9c..3d70689e3 100644 --- a/src/BulletCollision/CollisionDispatch/btManifoldResult.h +++ b/src/BulletCollision/CollisionDispatch/btManifoldResult.h @@ -17,10 +17,12 @@ subject to the following restrictions: #ifndef MANIFOLD_RESULT_H #define MANIFOLD_RESULT_H -#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" -struct btCollisionObject; +class btCollisionObject; class btPersistentManifold; class btManifoldPoint; + +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + #include "LinearMath/btTransform.h" typedef bool (*ContactAddedCallback)(btManifoldPoint& cp, const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1); diff --git a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp index c82e0d268..669f3bdb1 100644 --- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp +++ b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp @@ -42,8 +42,8 @@ void btSimulationIslandManager::findUnions(btDispatcher* dispatcher) ((colObj1) && ((colObj1)->mergesSimulationIslands()))) { - m_unionFind.unite((colObj0)->m_islandTag1, - (colObj1)->m_islandTag1); + m_unionFind.unite((colObj0)->getIslandTag(), + (colObj1)->getIslandTag()); } } } @@ -65,8 +65,8 @@ void btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld { btCollisionObject* collisionObject= (*i); - collisionObject->m_islandTag1 = index; - collisionObject->m_hitFraction = 1.f; + collisionObject->setIslandTag(index); + collisionObject->setHitFraction(1.f); index++; } @@ -98,10 +98,10 @@ void btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* col if (collisionObject->mergesSimulationIslands()) { - collisionObject->m_islandTag1 = m_unionFind.find(index); + collisionObject->setIslandTag( m_unionFind.find(index) ); } else { - collisionObject->m_islandTag1 = -1; + collisionObject->setIslandTag(-1); } index++; } @@ -113,7 +113,7 @@ inline int getIslandId(const btPersistentManifold* lhs) int islandId; const btCollisionObject* rcolObj0 = static_cast(lhs->getBody0()); const btCollisionObject* rcolObj1 = static_cast(lhs->getBody1()); - islandId= rcolObj0->m_islandTag1>=0?rcolObj0->m_islandTag1:rcolObj1->m_islandTag1; + islandId= rcolObj0->getIslandTag()>=0?rcolObj0->getIslandTag():rcolObj1->getIslandTag(); return islandId; } @@ -158,13 +158,13 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher, int i = getUnionFind().getElement(idx).m_sz; btCollisionObject* colObj0 = collisionObjects[i]; - if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1)) + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) { printf("error in island management\n"); } - assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1)); - if (colObj0->m_islandTag1 == islandId) + assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + if (colObj0->getIslandTag() == islandId) { if (colObj0->GetActivationState()== ACTIVE_TAG) { @@ -184,14 +184,14 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher, { int i = getUnionFind().getElement(idx).m_sz; btCollisionObject* colObj0 = collisionObjects[i]; - if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1)) + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) { printf("error in island management\n"); } - assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1)); + assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); - if (colObj0->m_islandTag1 == islandId) + if (colObj0->getIslandTag() == islandId) { colObj0->SetActivationState( ISLAND_SLEEPING ); } @@ -205,14 +205,14 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher, int i = getUnionFind().getElement(idx).m_sz; btCollisionObject* colObj0 = collisionObjects[i]; - if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1)) + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) { printf("error in island management\n"); } - assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1)); + assert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); - if (colObj0->m_islandTag1 == islandId) + if (colObj0->getIslandTag() == islandId) { if ( colObj0->GetActivationState() == ISLAND_SLEEPING) { diff --git a/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp index fc3941973..03622cf7a 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp @@ -57,11 +57,11 @@ void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,b btCollisionObject* boxObj = m_isSwapped? body0 : body1; - btSphereShape* sphere0 = (btSphereShape*)sphereObj ->m_collisionShape; + btSphereShape* sphere0 = (btSphereShape*)sphereObj->getCollisionShape(); btVector3 normalOnSurfaceB; btVector3 pOnBox,pOnSphere; - btVector3 sphereCenter = sphereObj->m_worldTransform.getOrigin(); + btVector3 sphereCenter = sphereObj->getWorldTransform().getOrigin(); btScalar radius = sphere0->getRadius(); float dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius); @@ -93,14 +93,14 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box btScalar margins; btVector3 bounds[2]; - btBoxShape* boxShape= (btBoxShape*)boxObj->m_collisionShape; + btBoxShape* boxShape= (btBoxShape*)boxObj->getCollisionShape(); bounds[0] = -boxShape->getHalfExtents(); bounds[1] = boxShape->getHalfExtents(); margins = boxShape->getMargin();//also add sphereShape margin? - const btTransform& m44T = boxObj->m_worldTransform; + const btTransform& m44T = boxObj->getWorldTransform(); btVector3 boundsVec[2]; btScalar fPenetration; @@ -209,7 +209,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject* n[4].setValue( 0.0f, 1.0f, 0.0f ); n[5].setValue( 0.0f, 0.0f, 1.0f ); - const btTransform& m44T = boxObj->m_worldTransform; + const btTransform& m44T = boxObj->getWorldTransform(); // convert point in local space prel = m44T.invXform( sphereCenter); diff --git a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp index 1c3ab81b7..799ce7a44 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp @@ -44,10 +44,10 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0 if (!m_manifoldPtr) return; - btSphereShape* sphere0 = (btSphereShape*)col0->m_collisionShape; - btSphereShape* sphere1 = (btSphereShape*)col1->m_collisionShape; + btSphereShape* sphere0 = (btSphereShape*)col0->getCollisionShape(); + btSphereShape* sphere1 = (btSphereShape*)col1->getCollisionShape(); - btVector3 diff = col0->m_worldTransform.getOrigin()- col1->m_worldTransform.getOrigin(); + btVector3 diff = col0->getWorldTransform().getOrigin()- col1->getWorldTransform().getOrigin(); float len = diff.length(); btScalar radius0 = sphere0->getRadius(); btScalar radius1 = sphere1->getRadius(); @@ -61,9 +61,9 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0 btVector3 normalOnSurfaceB = diff / len; ///point on A (worldspace) - btVector3 pos0 = col0->m_worldTransform.getOrigin() - radius0 * normalOnSurfaceB; + btVector3 pos0 = col0->getWorldTransform().getOrigin() - radius0 * normalOnSurfaceB; ///point on B (worldspace) - btVector3 pos1 = col1->m_worldTransform.getOrigin() + radius1* normalOnSurfaceB; + btVector3 pos1 = col1->getWorldTransform().getOrigin() + radius1* normalOnSurfaceB; /// report a contact. internally this will be kept persistent, and contact reduction is done resultOut->setPersistentManifold(m_manifoldPtr); diff --git a/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp b/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp index 3877969ec..0c3474b59 100644 --- a/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp +++ b/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp @@ -48,8 +48,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co if (!m_manifoldPtr) return; - btSphereShape* sphere = (btSphereShape*)col0->m_collisionShape; - btTriangleShape* triangle = (btTriangleShape*)col1->m_collisionShape; + btSphereShape* sphere = (btSphereShape*)col0->getCollisionShape(); + btTriangleShape* triangle = (btTriangleShape*)col1->getCollisionShape(); /// report a contact. internally this will be kept persistent, and contact reduction is done resultOut->setPersistentManifold(m_manifoldPtr); @@ -57,8 +57,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co btDiscreteCollisionDetectorInterface::ClosestPointInput input; input.m_maximumDistanceSquared = 1e30f;//todo: tighter bounds - input.m_transformA = col0->m_worldTransform; - input.m_transformB = col1->m_worldTransform; + input.m_transformA = col0->getWorldTransform(); + input.m_transformB = col1->getWorldTransform(); detector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw); diff --git a/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h b/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h index 8889699b3..ef2b480fa 100644 --- a/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h +++ b/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h @@ -14,8 +14,8 @@ subject to the following restrictions: */ -#ifndef DISCRETE_COLLISION_DETECTOR_INTERFACE_H -#define DISCRETE_COLLISION_DETECTOR_INTERFACE_H +#ifndef DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +#define DISCRETE_COLLISION_DETECTOR1_INTERFACE_H #include "LinearMath/btTransform.h" #include "LinearMath/btVector3.h" @@ -84,4 +84,4 @@ struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result } }; -#endif //DISCRETE_COLLISION_DETECTOR_INTERFACE_H +#endif //DISCRETE_COLLISION_DETECTOR_INTERFACE1_H diff --git a/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp index 429ad54d5..c8cdb5547 100644 --- a/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp +++ b/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp @@ -164,7 +164,8 @@ float resolveSingleFriction( float combinedFriction = cpd->m_friction; btScalar limit = cpd->m_appliedImpulse * combinedFriction; - //if (contactPoint.m_appliedImpulse>0.f) + + if (cpd->m_appliedImpulse>0.f) //friction { //apply friction in the 2 tangential directions @@ -182,11 +183,12 @@ float resolveSingleFriction( // calculate j that moves us to zero relative velocity j1 = -vrel * cpd->m_jacDiagABInvTangent0; - float total = cpd->m_accumulatedTangentImpulse0 + j1; - GEN_set_min(total, limit); - GEN_set_max(total, -limit); - j1 = total - cpd->m_accumulatedTangentImpulse0; - cpd->m_accumulatedTangentImpulse0 = total; + float oldTangentImpulse = cpd->m_accumulatedTangentImpulse0; + cpd->m_accumulatedTangentImpulse0 = oldTangentImpulse + j1; + GEN_set_min(cpd->m_accumulatedTangentImpulse0, limit); + GEN_set_max(cpd->m_accumulatedTangentImpulse0, -limit); + j1 = cpd->m_accumulatedTangentImpulse0 - oldTangentImpulse; + } { // 2nd tangent @@ -195,11 +197,11 @@ float resolveSingleFriction( // calculate j that moves us to zero relative velocity j2 = -vrel * cpd->m_jacDiagABInvTangent1; - float total = cpd->m_accumulatedTangentImpulse1 + j2; - GEN_set_min(total, limit); - GEN_set_max(total, -limit); - j2 = total - cpd->m_accumulatedTangentImpulse1; - cpd->m_accumulatedTangentImpulse1 = total; + float oldTangentImpulse = cpd->m_accumulatedTangentImpulse1; + cpd->m_accumulatedTangentImpulse1 = oldTangentImpulse + j2; + GEN_set_min(cpd->m_accumulatedTangentImpulse1, limit); + GEN_set_max(cpd->m_accumulatedTangentImpulse1, -limit); + j2 = cpd->m_accumulatedTangentImpulse1 - oldTangentImpulse; } #ifdef USE_INTERNAL_APPLY_IMPULSE diff --git a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp b/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp index ac06f718c..df787606c 100644 --- a/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp +++ b/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp @@ -32,6 +32,21 @@ int totalCpd = 0; int gTotalContactPoints = 0; +#define SEQUENTIAL_IMPULSE_MAX_SOLVER_BODIES 16384 +static int gOrder[SEQUENTIAL_IMPULSE_MAX_SOLVER_BODIES]; +static unsigned long btSeed2 = 0; +unsigned long btRand2() +{ + btSeed2 = (1664525L*btSeed2 + 1013904223L) & 0xffffffff; + return btSeed2; +} + +int btRandInt2 (int n) +{ + float a = float(n) / 4294967296.0f; + return (int) (float(btRand2()) * a); +} + bool MyContactDestroyedCallback(void* userPersistentData) { assert (userPersistentData); @@ -73,48 +88,40 @@ float btSequentialImpulseConstraintSolver::solveGroup(btPersistentManifold** man int j; for (j=0;jm_penetration/info.m_timeStep; - if (cpd->m_restitution >= penVel) + if (cpd->m_restitution > penVel) { cpd->m_penetration = 0.f; } @@ -233,7 +240,7 @@ void btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol float relaxation = info.m_damping; - cpd->m_appliedImpulse *= relaxation; + cpd->m_appliedImpulse =0.f;//*= relaxation; //for friction cpd->m_prevAppliedImpulse = cpd->m_appliedImpulse; @@ -260,8 +267,8 @@ void btSequentialImpulseConstraintSolver::prepareConstraints(btPersistentManifol btVector3 totalImpulse = #ifndef NO_FRICTION_WARMSTART - cp.m_frictionWorldTangential0*cp.m_accumulatedTangentImpulse0+ - cp.m_frictionWorldTangential1*cp.m_accumulatedTangentImpulse1+ + cpd->m_frictionWorldTangential0*cpd->m_accumulatedTangentImpulse0+ + cpd->m_frictionWorldTangential1*cpd->m_accumulatedTangentImpulse1+ #endif //NO_FRICTION_WARMSTART cp.m_normalWorldOnB*cpd->m_appliedImpulse; @@ -320,11 +327,7 @@ float btSequentialImpulseConstraintSolver::solve(btPersistentManifold* manifoldP { int j=i; - if (iter % 2) - j = numpoints-1-i; - else - j=i; - + btManifoldPoint& cp = manifoldPtr->getContactPoint(j); if (cp.getDistance() <= 0.f) { @@ -367,9 +370,7 @@ float btSequentialImpulseConstraintSolver::solveFriction(btPersistentManifold* m { int j=i; - //if (iter % 2) - // j = numpoints-1-i; - + btManifoldPoint& cp = manifoldPtr->getContactPoint(j); if (cp.getDistance() <= 0.f) { diff --git a/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp index ea7d5c8b9..cb3fa72d4 100644 --- a/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp +++ b/src/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp @@ -17,7 +17,7 @@ subject to the following restrictions: #include "btTypedConstraint.h" #include "BulletDynamics/Dynamics/btRigidBody.h" -static btRigidBody s_fixed(0, btTransform::getIdentity(),0); +static btRigidBody s_fixed(0, 0,0); btTypedConstraint::btTypedConstraint() : m_userConstraintType(-1), diff --git a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp b/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp index df5336371..ec9b55846 100644 --- a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp +++ b/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp @@ -56,9 +56,9 @@ subject to the following restrictions: #include -btDiscreteDynamicsWorld::btDiscreteDynamicsWorld() +btDiscreteDynamicsWorld::btDiscreteDynamicsWorld(btConstraintSolver* constraintSolver) :btDynamicsWorld(), -m_constraintSolver(new btSequentialImpulseConstraintSolver), +m_constraintSolver(constraintSolver? constraintSolver: new btSequentialImpulseConstraintSolver), m_debugDrawer(0), m_gravity(0,-10,0), m_localTime(1.f/60.f), @@ -66,8 +66,7 @@ m_profileTimings(0) { m_islandManager = new btSimulationIslandManager(); m_ownsIslandManager = true; - m_ownsConstraintSolver = true; - + m_ownsConstraintSolver = (constraintSolver==0); } btDiscreteDynamicsWorld::btDiscreteDynamicsWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache,btConstraintSolver* constraintSolver) @@ -142,7 +141,7 @@ void btDiscreteDynamicsWorld::synchronizeMotionStates() } }; - debugDrawObject(colObj->m_worldTransform,colObj->m_collisionShape,color); + debugDrawObject(colObj->getWorldTransform(),colObj->getCollisionShape(),color); } btRigidBody* body = btRigidBody::upcast(colObj); if (body && body->getMotionState() && !body->isStaticOrKinematicObject()) @@ -150,8 +149,8 @@ void btDiscreteDynamicsWorld::synchronizeMotionStates() if (body->GetActivationState() != ISLAND_SLEEPING) { btTransform interpolatedTransform; - btTransformUtil::integrateTransform(body->m_interpolationWorldTransform, - body->m_interpolationLinearVelocity,body->m_interpolationAngularVelocity,m_localTime,interpolatedTransform); + btTransformUtil::integrateTransform(body->getInterpolationWorldTransform(), + body->getInterpolationLinearVelocity(),body->getInterpolationAngularVelocity(),m_localTime,interpolatedTransform); body->getMotionState()->setWorldTransform(interpolatedTransform); } } @@ -439,8 +438,8 @@ void btDiscreteDynamicsWorld::calculateSimulationIslands() if (colObj0->IsActive() || colObj1->IsActive()) { - getSimulationIslandManager()->getUnionFind().unite((colObj0)->m_islandTag1, - (colObj1)->m_islandTag1); + getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), + (colObj1)->getIslandTag()); } } } @@ -501,13 +500,13 @@ void btDiscreteDynamicsWorld::updateAabbs() // if (body->IsActive() && (!body->IsStatic())) { btPoint3 minAabb,maxAabb; - colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb,maxAabb); + colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb); btSimpleBroadphase* bp = (btSimpleBroadphase*)m_broadphasePairCache; //moving objects should be moderately sized, probably something wrong if not if ( colObj->isStaticObject() || ((maxAabb-minAabb).length2() < 1e12f)) { - bp->setAabb(body->m_broadphaseHandle,minAabb,maxAabb); + bp->setAabb(body->getBroadphaseHandle(),minAabb,maxAabb); } else { //something went wrong, investigate @@ -575,7 +574,7 @@ void btDiscreteDynamicsWorld::predictUnconstraintMotion(float timeStep) { body->applyForces( timeStep); body->integrateVelocities( timeStep); - body->predictIntegratedTransform(timeStep,body->m_interpolationWorldTransform); + body->predictIntegratedTransform(timeStep,body->getInterpolationWorldTransform()); } } } @@ -768,3 +767,13 @@ void btDiscreteDynamicsWorld::debugDrawObject(const btTransform& worldTransform, } } } + +void btDiscreteDynamicsWorld::setConstraintSolver(btConstraintSolver* solver) +{ + if (m_ownsConstraintSolver) + { + delete m_constraintSolver; + } + m_ownsConstraintSolver = false; + m_constraintSolver = solver; +} \ No newline at end of file diff --git a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h b/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h index 9a10b7f0f..109592c2b 100644 --- a/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h +++ b/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h @@ -86,7 +86,7 @@ public: btDiscreteDynamicsWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache,btConstraintSolver* constraintSolver=0); ///this btDiscreteDynamicsWorld will create and own dispatcher, pairCache and constraintSolver, and deletes it in the destructor. - btDiscreteDynamicsWorld(); + btDiscreteDynamicsWorld(btConstraintSolver* constraintSolver = 0); virtual ~btDiscreteDynamicsWorld(); @@ -136,6 +136,7 @@ public: void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color); + virtual void setConstraintSolver(btConstraintSolver* solver); }; diff --git a/src/BulletDynamics/Dynamics/btDynamicsWorld.h b/src/BulletDynamics/Dynamics/btDynamicsWorld.h index 7aebf533e..e5c9a33b6 100644 --- a/src/BulletDynamics/Dynamics/btDynamicsWorld.h +++ b/src/BulletDynamics/Dynamics/btDynamicsWorld.h @@ -19,6 +19,8 @@ subject to the following restrictions: #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" class btTypedConstraint; class btRaycastVehicle; +class btConstraintSolver; + ///btDynamicsWorld is the baseclass for several dynamics implementation, basic, discrete, parallel, and continuous class btDynamicsWorld : public btCollisionWorld @@ -65,6 +67,8 @@ class btDynamicsWorld : public btCollisionWorld virtual void removeRigidBody(btRigidBody* body) = 0; + virtual void setConstraintSolver(btConstraintSolver* solver) = 0; + }; #endif //BT_DYNAMICS_WORLD_H diff --git a/src/BulletDynamics/Dynamics/btRigidBody.cpp b/src/BulletDynamics/Dynamics/btRigidBody.cpp index a434f5e41..66ba6c8a9 100644 --- a/src/BulletDynamics/Dynamics/btRigidBody.cpp +++ b/src/BulletDynamics/Dynamics/btRigidBody.cpp @@ -42,7 +42,13 @@ btRigidBody::btRigidBody(float mass, btMotionState* motionState, btCollisionShap m_frictionSolverType(0) { - motionState->getWorldTransform(m_worldTransform); + if (motionState) + { + motionState->getWorldTransform(m_worldTransform); + } else + { + m_worldTransform = btTransform::getIdentity(); + } m_interpolationWorldTransform = m_worldTransform; m_interpolationLinearVelocity.setValue(0,0,0); @@ -64,7 +70,7 @@ btRigidBody::btRigidBody(float mass, btMotionState* motionState, btCollisionShap } - +#ifdef OBSOLETE_MOTIONSTATE_LESS btRigidBody::btRigidBody( float mass,const btTransform& worldTransform,btCollisionShape* collisionShape,const btVector3& localInertia,btScalar linearDamping,btScalar angularDamping,btScalar friction,btScalar restitution) : m_gravity(0.0f, 0.0f, 0.0f), @@ -100,30 +106,34 @@ btRigidBody::btRigidBody( float mass,const btTransform& worldTransform,btCollisi } +#endif //OBSOLETE_MOTIONSTATE_LESS + + #define EXPERIMENTAL_JITTER_REMOVAL 1 #ifdef EXPERIMENTAL_JITTER_REMOVAL -//Bullet 2.20b has experimental code to reduce jitter just before objects fall asleep/deactivate -//doesn't work very well yet (value 0 only reduces performance a bit, no difference in functionality) -float gClippedAngvelThresholdSqr = 0.f; -float gClippedLinearThresholdSqr = 0.f; +//Bullet 2.20b has experimental damping code to reduce jitter just before objects fall asleep/deactivate +//doesn't work very well yet (value 0 disabled this damping) +//note there this influences deactivation thresholds! +float gClippedAngvelThresholdSqr = 0.01f; +float gClippedLinearThresholdSqr = 0.01f; +float gJitterVelocityDampingFactor = 1.0f; #endif //EXPERIMENTAL_JITTER_REMOVAL void btRigidBody::predictIntegratedTransform(btScalar timeStep,btTransform& predictedTransform) { #ifdef EXPERIMENTAL_JITTER_REMOVAL - //clip to avoid jitter - if (m_angularVelocity.length2() < gClippedAngvelThresholdSqr) + if (wantsSleeping()) { - m_angularVelocity.setValue(0,0,0); - printf("clipped!\n"); + //clip to avoid jitter +// if ((m_angularVelocity.length2() < gClippedAngvelThresholdSqr) && +// (m_linearVelocity.length2() < gClippedLinearThresholdSqr)) + { + m_angularVelocity *= gJitterVelocityDampingFactor; + m_linearVelocity *= gJitterVelocityDampingFactor; + } } - if (m_linearVelocity.length2() < gClippedLinearThresholdSqr) - { - m_linearVelocity.setValue(0,0,0); - printf("clipped!\n"); - } #endif //EXPERIMENTAL_JITTER_REMOVAL btTransformUtil::integrateTransform(m_worldTransform,m_linearVelocity,m_angularVelocity,timeStep,predictedTransform); diff --git a/src/BulletDynamics/Dynamics/btRigidBody.h b/src/BulletDynamics/Dynamics/btRigidBody.h index fca3658cb..9236d3722 100644 --- a/src/BulletDynamics/Dynamics/btRigidBody.h +++ b/src/BulletDynamics/Dynamics/btRigidBody.h @@ -62,7 +62,11 @@ class btRigidBody : public btCollisionObject public: +#ifdef OBSOLETE_MOTIONSTATE_LESS + //not supported, please use btMotionState btRigidBody(float mass, const btTransform& worldTransform, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=0.f,btScalar angularDamping=0.f,btScalar friction=0.5f,btScalar restitution=0.f); +#endif //OBSOLETE_MOTIONSTATE_LESS + btRigidBody(float mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0),btScalar linearDamping=0.f,btScalar angularDamping=0.f,btScalar friction=0.5f,btScalar restitution=0.f); void proceedToTransform(const btTransform& newTrans); @@ -71,11 +75,11 @@ public: ///but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast static const btRigidBody* upcast(const btCollisionObject* colObj) { - return (const btRigidBody*)colObj->m_internalOwner; + return (const btRigidBody*)colObj->getInternalOwner(); } static btRigidBody* upcast(btCollisionObject* colObj) { - return (btRigidBody*)colObj->m_internalOwner; + return (btRigidBody*)colObj->getInternalOwner(); } /// continuous collision detection needs prediction diff --git a/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp b/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp index 9d903be9b..a88298c82 100644 --- a/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp +++ b/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp @@ -117,9 +117,9 @@ void btSimpleDynamicsWorld::updateAabbs() if (body->IsActive() && (!body->isStaticObject())) { btPoint3 minAabb,maxAabb; - colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb,maxAabb); + colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb); btBroadphaseInterface* bp = getBroadphase(); - bp->setAabb(body->m_broadphaseHandle,minAabb,maxAabb); + bp->setAabb(body->getBroadphaseHandle(),minAabb,maxAabb); } } } @@ -159,7 +159,7 @@ void btSimpleDynamicsWorld::predictUnconstraintMotion(float timeStep) { body->applyForces( timeStep); body->integrateVelocities( timeStep); - body->predictIntegratedTransform(timeStep,body->m_interpolationWorldTransform); + body->predictIntegratedTransform(timeStep,body->getInterpolationWorldTransform()); } } } @@ -178,9 +178,20 @@ void btSimpleDynamicsWorld::synchronizeMotionStates() { if (body->GetActivationState() != ISLAND_SLEEPING) { - body->getMotionState()->setWorldTransform(body->m_worldTransform); + body->getMotionState()->setWorldTransform(body->getWorldTransform()); } } } } + + +void btSimpleDynamicsWorld::setConstraintSolver(btConstraintSolver* solver) +{ + if (m_ownsConstraintSolver) + { + delete m_constraintSolver; + } + m_ownsConstraintSolver = false; + m_constraintSolver = solver; +} \ No newline at end of file diff --git a/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h b/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h index 3886ee606..af43fd72a 100644 --- a/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h +++ b/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h @@ -77,6 +77,8 @@ public: void synchronizeMotionStates(); + virtual void setConstraintSolver(btConstraintSolver* solver); + }; #endif //BT_SIMPLE_DYNAMICS_WORLD_H diff --git a/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp b/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp index 544d3e594..d2407c182 100644 --- a/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp +++ b/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp @@ -11,6 +11,7 @@ #include "LinearMath/btVector3.h" #include "btRaycastVehicle.h" + #include "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h" #include "BulletDynamics/ConstraintSolver/btJacobianEntry.h" #include "LinearMath/btQuaternion.h" @@ -23,7 +24,7 @@ -static btRigidBody s_fixedObject( 0,btTransform(btQuaternion(0,0,0,1)),0); +static btRigidBody s_fixedObject( 0,0,0); btRaycastVehicle::btRaycastVehicle(const btVehicleTuning& tuning,btRigidBody* chassis, btVehicleRaycaster* raycaster ) :m_vehicleRaycaster(raycaster),