dali-physics/third-party/bullet3/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h

   1 /*
   2 Bullet Continuous Collision Detection and Physics Library
   3 Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
   4
   5 This software is provided 'as-is', without any express or implied warranty.
   6 In no event will the authors be held liable for any damages arising from the use of this software.
   7 Permission is granted to anyone to use this software for any purpose,
   8 including commercial applications, and to alter it and redistribute it freely,
   9 subject to the following restrictions:
  10
  11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  13 3. This notice may not be removed or altered from any source distribution.
  14 */
  15
  16 #ifndef BT_DISCRETE_DYNAMICS_WORLD_H
  17 #define BT_DISCRETE_DYNAMICS_WORLD_H
  18
  19 #include "btDynamicsWorld.h"
  20 class btDispatcher;
  21 class btOverlappingPairCache;
  22 class btConstraintSolver;
  23 class btSimulationIslandManager;
  24 class btTypedConstraint;
  25 class btActionInterface;
  26 class btPersistentManifold;
  27 class btIDebugDraw;
  28
  29 struct InplaceSolverIslandCallback;
  30
  31 #include "LinearMath/btAlignedObjectArray.h"
  32 #include "LinearMath/btThreads.h"
  33
  34 ///btDiscreteDynamicsWorld provides discrete rigid body simulation
  35 ///those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController
  36 ATTRIBUTE_ALIGNED16(class)
  37 btDiscreteDynamicsWorld : public btDynamicsWorld
  38 {
  39 protected:
  40         btAlignedObjectArray<btTypedConstraint*> m_sortedConstraints;
  41         InplaceSolverIslandCallback* m_solverIslandCallback;
  42
  43         btConstraintSolver* m_constraintSolver;
  44
  45         btSimulationIslandManager* m_islandManager;
  46
  47         btAlignedObjectArray<btTypedConstraint*> m_constraints;
  48
  49         btAlignedObjectArray<btRigidBody*> m_nonStaticRigidBodies;
  50
  51         btVector3 m_gravity;
  52
  53         //for variable timesteps
  54         btScalar m_localTime;
  55         btScalar m_fixedTimeStep;
  56         //for variable timesteps
  57
  58         bool m_ownsIslandManager;
  59         bool m_ownsConstraintSolver;
  60         bool m_synchronizeAllMotionStates;
  61         bool m_applySpeculativeContactRestitution;
  62
  63         btAlignedObjectArray<btActionInterface*> m_actions;
  64
  65         int m_profileTimings;
  66
  67         bool m_latencyMotionStateInterpolation;
  68
  69         btAlignedObjectArray<btPersistentManifold*> m_predictiveManifolds;
  70         btSpinMutex m_predictiveManifoldsMutex;  // used to synchronize threads creating predictive contacts
  71
  72         virtual void predictUnconstraintMotion(btScalar timeStep);
  73
  74         void integrateTransformsInternal(btRigidBody * *bodies, int numBodies, btScalar timeStep);  // can be called in parallel
  75         virtual void integrateTransforms(btScalar timeStep);
  76
  77         virtual void calculateSimulationIslands();
  78
  79
  80
  81         virtual void updateActivationState(btScalar timeStep);
  82
  83         void updateActions(btScalar timeStep);
  84
  85         void startProfiling(btScalar timeStep);
  86
  87         virtual void internalSingleStepSimulation(btScalar timeStep);
  88
  89         void releasePredictiveContacts();
  90         void createPredictiveContactsInternal(btRigidBody * *bodies, int numBodies, btScalar timeStep);  // can be called in parallel
  91         virtual void createPredictiveContacts(btScalar timeStep);
  92
  93         virtual void saveKinematicState(btScalar timeStep);
  94
  95         void serializeRigidBodies(btSerializer * serializer);
  96
  97         void serializeDynamicsWorldInfo(btSerializer * serializer);
  98
  99 public:
 100         BT_DECLARE_ALIGNED_ALLOCATOR();
 101
 102         ///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those
 103         btDiscreteDynamicsWorld(btDispatcher * dispatcher, btBroadphaseInterface * pairCache, btConstraintSolver * constraintSolver, btCollisionConfiguration * collisionConfiguration);
 104
 105         virtual ~btDiscreteDynamicsWorld();
 106
 107         ///if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
 108         virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.));
 109
 110     virtual void solveConstraints(btContactSolverInfo & solverInfo);
 111
 112         virtual void synchronizeMotionStates();
 113
 114         ///this can be useful to synchronize a single rigid body -> graphics object
 115         void synchronizeSingleMotionState(btRigidBody * body);
 116
 117         virtual void addConstraint(btTypedConstraint * constraint, bool disableCollisionsBetweenLinkedBodies = false);
 118
 119         virtual void removeConstraint(btTypedConstraint * constraint);
 120
 121         virtual void addAction(btActionInterface*);
 122
 123         virtual void removeAction(btActionInterface*);
 124
 125         btSimulationIslandManager* getSimulationIslandManager()
 126         {
 127                 return m_islandManager;
 128         }
 129
 130         const btSimulationIslandManager* getSimulationIslandManager() const
 131         {
 132                 return m_islandManager;
 133         }
 134
 135         btCollisionWorld* getCollisionWorld()
 136         {
 137                 return this;
 138         }
 139
 140         virtual void setGravity(const btVector3& gravity);
 141
 142         virtual btVector3 getGravity() const;
 143
 144         virtual void addCollisionObject(btCollisionObject * collisionObject, int collisionFilterGroup = btBroadphaseProxy::StaticFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
 145
 146         virtual void addRigidBody(btRigidBody * body);
 147
 148         virtual void addRigidBody(btRigidBody * body, int group, int mask);
 149
 150         virtual void removeRigidBody(btRigidBody * body);
 151
 152         ///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject
 153         virtual void removeCollisionObject(btCollisionObject * collisionObject);
 154
 155         virtual void debugDrawConstraint(btTypedConstraint * constraint);
 156
 157         virtual void debugDrawWorld();
 158
 159         virtual void setConstraintSolver(btConstraintSolver * solver);
 160
 161         virtual btConstraintSolver* getConstraintSolver();
 162
 163         virtual int getNumConstraints() const;
 164
 165         virtual btTypedConstraint* getConstraint(int index);
 166
 167         virtual const btTypedConstraint* getConstraint(int index) const;
 168
 169         virtual btDynamicsWorldType getWorldType() const
 170         {
 171                 return BT_DISCRETE_DYNAMICS_WORLD;
 172         }
 173
 174         ///the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
 175         virtual void clearForces();
 176
 177         ///apply gravity, call this once per timestep
 178         virtual void applyGravity();
 179
 180         virtual void setNumTasks(int numTasks)
 181         {
 182                 (void)numTasks;
 183         }
 184
 185         ///obsolete, use updateActions instead
 186         virtual void updateVehicles(btScalar timeStep)
 187         {
 188                 updateActions(timeStep);
 189         }
 190
 191         ///obsolete, use addAction instead
 192         virtual void addVehicle(btActionInterface * vehicle);
 193         ///obsolete, use removeAction instead
 194         virtual void removeVehicle(btActionInterface * vehicle);
 195         ///obsolete, use addAction instead
 196         virtual void addCharacter(btActionInterface * character);
 197         ///obsolete, use removeAction instead
 198         virtual void removeCharacter(btActionInterface * character);
 199
 200         void setSynchronizeAllMotionStates(bool synchronizeAll)
 201         {
 202                 m_synchronizeAllMotionStates = synchronizeAll;
 203         }
 204         bool getSynchronizeAllMotionStates() const
 205         {
 206                 return m_synchronizeAllMotionStates;
 207         }
 208
 209         void setApplySpeculativeContactRestitution(bool enable)
 210         {
 211                 m_applySpeculativeContactRestitution = enable;
 212         }
 213
 214         bool getApplySpeculativeContactRestitution() const
 215         {
 216                 return m_applySpeculativeContactRestitution;
 217         }
 218
 219         ///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo)
 220         virtual void serialize(btSerializer * serializer);
 221
 222         ///Interpolate motion state between previous and current transform, instead of current and next transform.
 223         ///This can relieve discontinuities in the rendering, due to penetrations
 224         void setLatencyMotionStateInterpolation(bool latencyInterpolation)
 225         {
 226                 m_latencyMotionStateInterpolation = latencyInterpolation;
 227         }
 228         bool getLatencyMotionStateInterpolation() const
 229         {
 230                 return m_latencyMotionStateInterpolation;
 231         }
 232
 233     btAlignedObjectArray<btRigidBody*>& getNonStaticRigidBodies()
 234     {
 235         return m_nonStaticRigidBodies;
 236     }
 237
 238     const btAlignedObjectArray<btRigidBody*>& getNonStaticRigidBodies() const
 239     {
 240         return m_nonStaticRigidBodies;
 241     }
 242 };
 243
 244 #endif  //BT_DISCRETE_DYNAMICS_WORLD_H