Bullet Collision Detection & Physics Library: btDiscreteDynamicsWorld.h Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btDiscreteDynamicsWorld.h
Go to the documentation of this file.
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
17 #ifndef BT_DISCRETE_DYNAMICS_WORLD_H
18 #define BT_DISCRETE_DYNAMICS_WORLD_H
19
20 #include "btDynamicsWorld.h"
21
22 class btDispatcher;
23 class btOverlappingPairCache;
24 class btConstraintSolver;
25 class btSimulationIslandManager;
26 class btTypedConstraint;
27 class btActionInterface;
28 class btPersistentManifold;
29 class btIDebugDraw;
30 struct InplaceSolverIslandCallback;
31
32 #include "LinearMath/btAlignedObjectArray.h"
33
34
37 ATTRIBUTE_ALIGNED16(class) btDiscreteDynamicsWorld : public btDynamicsWorld
38 {
39 protected:
40
41 btAlignedObjectArray<btTypedConstraint*> m_sortedConstraints;
42 InplaceSolverIslandCallback* m_solverIslandCallback;
43
44 btConstraintSolver* m_constraintSolver;
45
46 btSimulationIslandManager* m_islandManager;
47
48 btAlignedObjectArray<btTypedConstraint*> m_constraints;
49
50 btAlignedObjectArray<btRigidBody*> m_nonStaticRigidBodies;
51
52 btVector3 m_gravity;
53
54 //for variable timesteps
55 btScalar m_localTime;
56 btScalar m_fixedTimeStep;
57 //for variable timesteps
58
59 bool m_ownsIslandManager;
60 bool m_ownsConstraintSolver;
61 bool m_synchronizeAllMotionStates;
62 bool m_applySpeculativeContactRestitution;
63
64 btAlignedObjectArray<btActionInterface*> m_actions;
65
66 int m_profileTimings;
67
68 bool m_latencyMotionStateInterpolation;
69
70 btAlignedObjectArray<btPersistentManifold*> m_predictiveManifolds;
71
72 virtual void predictUnconstraintMotion(btScalar timeStep);
73
74 virtual void integrateTransforms(btScalar timeStep);
75
76 virtual void calculateSimulationIslands();
77
78 virtual void solveConstraints(btContactSolverInfo& solverInfo);
79
80 virtual void updateActivationState(btScalar timeStep);
81
82 void updateActions(btScalar timeStep);
83
84 void startProfiling(btScalar timeStep);
85
86 virtual void internalSingleStepSimulation( btScalar timeStep);
87
88 void createPredictiveContacts(btScalar timeStep);
89
90 virtual void saveKinematicState(btScalar timeStep);
91
92 void serializeRigidBodies(btSerializer* serializer);
93
94 void serializeDynamicsWorldInfo(btSerializer* serializer);
95
96 public:
97
98
99 BT_DECLARE_ALIGNED_ALLOCATOR();
100
102 btDiscreteDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration);
103
104 virtual ~btDiscreteDynamicsWorld();
105
107 virtual int stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
108
109
110 virtual void synchronizeMotionStates();
111
113 void synchronizeSingleMotionState(btRigidBody* body);
114
115 virtual void addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies=false);
116
117 virtual void removeConstraint(btTypedConstraint* constraint);
118
119 virtual void addAction(btActionInterface*);
120
121 virtual void removeAction(btActionInterface*);
122
123 btSimulationIslandManager* getSimulationIslandManager()
124 {
125 return m_islandManager;
126 }
127
128 const btSimulationIslandManager* getSimulationIslandManager() const
129 {
130 return m_islandManager;
131 }
132
133 btCollisionWorld* getCollisionWorld()
134 {
135 return this;
136 }
137
138 virtual void setGravity(const btVector3& gravity);
139
140 virtual btVector3 getGravity () const;
141
142 virtual void addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::StaticFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
143
144 virtual void addRigidBody(btRigidBody* body);
145
146 virtual void addRigidBody(btRigidBody* body, short group, short mask);
147
148 virtual void removeRigidBody(btRigidBody* body);
149
151 virtual void removeCollisionObject(btCollisionObject* collisionObject);
152
153
154 virtual void debugDrawConstraint(btTypedConstraint* constraint);
155
156 virtual void debugDrawWorld();
157
158 virtual void setConstraintSolver(btConstraintSolver* solver);
159
160 virtual btConstraintSolver* getConstraintSolver();
161
162 virtual int getNumConstraints() const;
163
164 virtual btTypedConstraint* getConstraint(int index) ;
165
166 virtual const btTypedConstraint* getConstraint(int index) const;
167
168
169 virtual btDynamicsWorldType getWorldType() const
170 {
171 return BT_DISCRETE_DYNAMICS_WORLD;
172 }
173
175 virtual void clearForces();
176
178 virtual void applyGravity();
179
180 virtual void setNumTasks(int numTasks)
181 {
182 (void) numTasks;
183 }
184
186 virtual void updateVehicles(btScalar timeStep)
187 {
188 updateActions(timeStep);
189 }
190
192 virtual void addVehicle(btActionInterface* vehicle);
194 virtual void removeVehicle(btActionInterface* vehicle);
196 virtual void addCharacter(btActionInterface* character);
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
220 virtual void serialize(btSerializer* serializer);
221
224 void setLatencyMotionStateInterpolation(bool latencyInterpolation )
225 {
226 m_latencyMotionStateInterpolation = latencyInterpolation;
227 }
228 bool getLatencyMotionStateInterpolation() const
229 {
230 return m_latencyMotionStateInterpolation;
231 }
232 };
233
234 #endif //BT_DISCRETE_DYNAMICS_WORLD_H
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:54
btDiscreteDynamicsWorld::m_localTime
btScalar m_localTime
Definition: btDiscreteDynamicsWorld.h:55
btDiscreteDynamicsWorld::m_islandManager
btSimulationIslandManager * m_islandManager
Definition: btDiscreteDynamicsWorld.h:46
btDiscreteDynamicsWorld::m_nonStaticRigidBodies
btAlignedObjectArray< btRigidBody * > m_nonStaticRigidBodies
Definition: btDiscreteDynamicsWorld.h:50
InplaceSolverIslandCallback
Definition: btDiscreteDynamicsWorld.cpp:84
btAlignedObjectArray< btTypedConstraint * >
btDiscreteDynamicsWorld::setSynchronizeAllMotionStates
void setSynchronizeAllMotionStates(bool synchronizeAll)
Definition: btDiscreteDynamicsWorld.h:200
btDiscreteDynamicsWorld::m_sortedConstraints
btAlignedObjectArray< btTypedConstraint * > m_sortedConstraints
Definition: btDiscreteDynamicsWorld.h:41
btDiscreteDynamicsWorld
btDiscreteDynamicsWorld provides discrete rigid body simulation those classes replace the obsolete Cc...
Definition: btDiscreteDynamicsWorld.h:37
btSimulationIslandManager
SimulationIslandManager creates and handles simulation islands, using btUnionFind.
Definition: btSimulationIslandManager.h:31
btDynamicsWorld
The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc.
Definition: btDynamicsWorld.h:41
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size...
Definition: btCollisionConfiguration.h:26
btDiscreteDynamicsWorld::m_actions
btAlignedObjectArray< btActionInterface * > m_actions
Definition: btDiscreteDynamicsWorld.h:64
btDiscreteDynamicsWorld::getSimulationIslandManager
btSimulationIslandManager * getSimulationIslandManager()
Definition: btDiscreteDynamicsWorld.h:123
btDiscreteDynamicsWorld::updateVehicles
virtual void updateVehicles(btScalar timeStep)
obsolete, use updateActions instead
Definition: btDiscreteDynamicsWorld.h:186
btDiscreteDynamicsWorld::m_ownsConstraintSolver
bool m_ownsConstraintSolver
Definition: btDiscreteDynamicsWorld.h:60
btActionInterface
Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWor...
Definition: btActionInterface.h:26
btDynamicsWorld.h
btSerializer
Definition: btSerializer.h:68
btOverlappingPairCache
The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
Definition: btOverlappingPairCache.h:60
btDiscreteDynamicsWorld::getCollisionWorld
btCollisionWorld * getCollisionWorld()
Definition: btDiscreteDynamicsWorld.h:133
btBroadphaseProxy::StaticFilter
Definition: btBroadphaseProxy.h:94
btDiscreteDynamicsWorld::m_gravity
btVector3 m_gravity
Definition: btDiscreteDynamicsWorld.h:52
btDiscreteDynamicsWorld::getLatencyMotionStateInterpolation
bool getLatencyMotionStateInterpolation() const
Definition: btDiscreteDynamicsWorld.h:228
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:49
btIDebugDraw
The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations...
Definition: btIDebugDraw.h:29
btDiscreteDynamicsWorld::m_predictiveManifolds
btAlignedObjectArray< btPersistentManifold * > m_predictiveManifolds
Definition: btDiscreteDynamicsWorld.h:70
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:62
btBroadphaseInterface
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs...
Definition: btBroadphaseInterface.h:51
btDiscreteDynamicsWorld::m_fixedTimeStep
btScalar m_fixedTimeStep
Definition: btDiscreteDynamicsWorld.h:56
btDiscreteDynamicsWorld::getApplySpeculativeContactRestitution
bool getApplySpeculativeContactRestitution() const
Definition: btDiscreteDynamicsWorld.h:214
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:64
btContactSolverInfo
Definition: btContactSolverInfo.h:65
btCollisionWorld
CollisionWorld is interface and container for the collision detection.
Definition: btCollisionWorld.h:88
btDiscreteDynamicsWorld::m_latencyMotionStateInterpolation
bool m_latencyMotionStateInterpolation
Definition: btDiscreteDynamicsWorld.h:68
btDiscreteDynamicsWorld::getWorldType
virtual btDynamicsWorldType getWorldType() const
Definition: btDiscreteDynamicsWorld.h:169
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:78
btDiscreteDynamicsWorld::m_synchronizeAllMotionStates
bool m_synchronizeAllMotionStates
Definition: btDiscreteDynamicsWorld.h:61
btDiscreteDynamicsWorld::setNumTasks
virtual void setNumTasks(int numTasks)
Definition: btDiscreteDynamicsWorld.h:180
BT_DISCRETE_DYNAMICS_WORLD
Definition: btDynamicsWorld.h:34
BT_DECLARE_ALIGNED_ALLOCATOR
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:388
btDynamicsWorldType
btDynamicsWorldType
Definition: btDynamicsWorld.h:31
btDiscreteDynamicsWorld::m_solverIslandCallback
InplaceSolverIslandCallback * m_solverIslandCallback
Definition: btDiscreteDynamicsWorld.h:42
btAlignedObjectArray.h
btDiscreteDynamicsWorld::getSimulationIslandManager
const btSimulationIslandManager * getSimulationIslandManager() const
Definition: btDiscreteDynamicsWorld.h:128
btDiscreteDynamicsWorld::m_applySpeculativeContactRestitution
bool m_applySpeculativeContactRestitution
Definition: btDiscreteDynamicsWorld.h:62
btBroadphaseProxy::AllFilter
Definition: btBroadphaseProxy.h:99
btDiscreteDynamicsWorld::m_constraintSolver
btConstraintSolver * m_constraintSolver
Definition: btDiscreteDynamicsWorld.h:44
btDiscreteDynamicsWorld::m_ownsIslandManager
bool m_ownsIslandManager
Definition: btDiscreteDynamicsWorld.h:59
btDiscreteDynamicsWorld::setApplySpeculativeContactRestitution
void setApplySpeculativeContactRestitution(bool enable)
Definition: btDiscreteDynamicsWorld.h:209
btDiscreteDynamicsWorld::m_profileTimings
int m_profileTimings
Definition: btDiscreteDynamicsWorld.h:66
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:69
btDiscreteDynamicsWorld::getSynchronizeAllMotionStates
bool getSynchronizeAllMotionStates() const
Definition: btDiscreteDynamicsWorld.h:204
btDiscreteDynamicsWorld::setLatencyMotionStateInterpolation
void setLatencyMotionStateInterpolation(bool latencyInterpolation)
Interpolate motion state between previous and current transform, instead of current and next transfor...
Definition: btDiscreteDynamicsWorld.h:224
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btDiscreteDynamicsWorld::m_constraints
btAlignedObjectArray< btTypedConstraint * > m_constraints
Definition: btDiscreteDynamicsWorld.h:48
btConstraintSolver
Definition: btConstraintSolver.h:40