btDiscreteDynamicsWorld.h

Go to the documentation of this file.
00001 /*
00002 Bullet Continuous Collision Detection and Physics Library
00003 Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
00004 
00005 This software is provided 'as-is', without any express or implied warranty.
00006 In no event will the authors be held liable for any damages arising from the use of this software.
00007 Permission is granted to anyone to use this software for any purpose, 
00008 including commercial applications, and to alter it and redistribute it freely, 
00009 subject to the following restrictions:
00010 
00011 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.
00012 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
00013 3. This notice may not be removed or altered from any source distribution.
00014 */
00015 
00016 
00017 #ifndef BT_DISCRETE_DYNAMICS_WORLD_H
00018 #define BT_DISCRETE_DYNAMICS_WORLD_H
00019 
00020 #include "btDynamicsWorld.h"
00021 
00022 class btDispatcher;
00023 class btOverlappingPairCache;
00024 class btConstraintSolver;
00025 class btSimulationIslandManager;
00026 class btTypedConstraint;
00027 class btActionInterface;
00028 class btPersistentManifold;
00029 class btIDebugDraw;
00030 struct InplaceSolverIslandCallback;
00031 
00032 #include "LinearMath/btAlignedObjectArray.h"
00033 
00034 
00037 ATTRIBUTE_ALIGNED16(class) btDiscreteDynamicsWorld : public btDynamicsWorld
00038 {
00039 protected:
00040         
00041     btAlignedObjectArray<btTypedConstraint*>    m_sortedConstraints;
00042         InplaceSolverIslandCallback*    m_solverIslandCallback;
00043 
00044         btConstraintSolver*     m_constraintSolver;
00045 
00046         btSimulationIslandManager*      m_islandManager;
00047 
00048         btAlignedObjectArray<btTypedConstraint*> m_constraints;
00049 
00050         btAlignedObjectArray<btRigidBody*> m_nonStaticRigidBodies;
00051 
00052         btVector3       m_gravity;
00053 
00054         //for variable timesteps
00055         btScalar        m_localTime;
00056         //for variable timesteps
00057 
00058         bool    m_ownsIslandManager;
00059         bool    m_ownsConstraintSolver;
00060         bool    m_synchronizeAllMotionStates;
00061         bool    m_applySpeculativeContactRestitution;
00062 
00063         btAlignedObjectArray<btActionInterface*>        m_actions;
00064         
00065         int     m_profileTimings;
00066 
00067         btAlignedObjectArray<btPersistentManifold*>     m_predictiveManifolds;
00068 
00069         virtual void    predictUnconstraintMotion(btScalar timeStep);
00070         
00071         virtual void    integrateTransforms(btScalar timeStep);
00072                 
00073         virtual void    calculateSimulationIslands();
00074 
00075         virtual void    solveConstraints(btContactSolverInfo& solverInfo);
00076         
00077         void    updateActivationState(btScalar timeStep);
00078 
00079         void    updateActions(btScalar timeStep);
00080 
00081         void    startProfiling(btScalar timeStep);
00082 
00083         virtual void    internalSingleStepSimulation( btScalar timeStep);
00084 
00085         void    createPredictiveContacts(btScalar timeStep);
00086 
00087         virtual void    saveKinematicState(btScalar timeStep);
00088 
00089         void    serializeRigidBodies(btSerializer* serializer);
00090 
00091         void    serializeDynamicsWorldInfo(btSerializer* serializer);
00092 
00093 public:
00094 
00095 
00096         BT_DECLARE_ALIGNED_ALLOCATOR();
00097 
00099         btDiscreteDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration);
00100 
00101         virtual ~btDiscreteDynamicsWorld();
00102 
00104         virtual int     stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
00105 
00106 
00107         virtual void    synchronizeMotionStates();
00108 
00110         void    synchronizeSingleMotionState(btRigidBody* body);
00111 
00112         virtual void    addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies=false);
00113 
00114         virtual void    removeConstraint(btTypedConstraint* constraint);
00115 
00116         virtual void    addAction(btActionInterface*);
00117 
00118         virtual void    removeAction(btActionInterface*);
00119         
00120         btSimulationIslandManager*      getSimulationIslandManager()
00121         {
00122                 return m_islandManager;
00123         }
00124 
00125         const btSimulationIslandManager*        getSimulationIslandManager() const 
00126         {
00127                 return m_islandManager;
00128         }
00129 
00130         btCollisionWorld*       getCollisionWorld()
00131         {
00132                 return this;
00133         }
00134 
00135         virtual void    setGravity(const btVector3& gravity);
00136 
00137         virtual btVector3 getGravity () const;
00138 
00139         virtual void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::StaticFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
00140 
00141         virtual void    addRigidBody(btRigidBody* body);
00142 
00143         virtual void    addRigidBody(btRigidBody* body, short group, short mask);
00144 
00145         virtual void    removeRigidBody(btRigidBody* body);
00146 
00148         virtual void    removeCollisionObject(btCollisionObject* collisionObject);
00149 
00150 
00151         void    debugDrawConstraint(btTypedConstraint* constraint);
00152 
00153         virtual void    debugDrawWorld();
00154 
00155         virtual void    setConstraintSolver(btConstraintSolver* solver);
00156 
00157         virtual btConstraintSolver* getConstraintSolver();
00158         
00159         virtual int             getNumConstraints() const;
00160 
00161         virtual btTypedConstraint* getConstraint(int index)     ;
00162 
00163         virtual const btTypedConstraint* getConstraint(int index) const;
00164 
00165         
00166         virtual btDynamicsWorldType     getWorldType() const
00167         {
00168                 return BT_DISCRETE_DYNAMICS_WORLD;
00169         }
00170         
00172         virtual void    clearForces();
00173 
00175         virtual void    applyGravity();
00176 
00177         virtual void    setNumTasks(int numTasks)
00178         {
00179         (void) numTasks;
00180         }
00181 
00183         virtual void updateVehicles(btScalar timeStep)
00184         {
00185                 updateActions(timeStep);
00186         }
00187 
00189         virtual void    addVehicle(btActionInterface* vehicle);
00191         virtual void    removeVehicle(btActionInterface* vehicle);
00193         virtual void    addCharacter(btActionInterface* character);
00195         virtual void    removeCharacter(btActionInterface* character);
00196 
00197         void    setSynchronizeAllMotionStates(bool synchronizeAll)
00198         {
00199                 m_synchronizeAllMotionStates = synchronizeAll;
00200         }
00201         bool getSynchronizeAllMotionStates() const
00202         {
00203                 return m_synchronizeAllMotionStates;
00204         }
00205 
00206         void setApplySpeculativeContactRestitution(bool enable)
00207         {
00208                 m_applySpeculativeContactRestitution = enable;
00209         }
00210         
00211         bool getApplySpeculativeContactRestitution() const
00212         {
00213                 return m_applySpeculativeContactRestitution;
00214         }
00215 
00217         virtual void    serialize(btSerializer* serializer);
00218 
00219 };
00220 
00221 #endif //BT_DISCRETE_DYNAMICS_WORLD_H