doxygen: bge scenegraph and videotexture
[blender-staging.git] / source / gameengine / Physics / Bullet / CcdPhysicsEnvironment.h
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
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 /** \file CcdPhysicsEnvironment.h
17  *  \ingroup physbullet
18  *  See also \ref bulletdoc
19  */
20
21 #ifndef CCDPHYSICSENVIRONMENT
22 #define CCDPHYSICSENVIRONMENT
23
24 #include "PHY_IPhysicsEnvironment.h"
25 #include <vector>
26 #include <set>
27 class CcdPhysicsController;
28 class CcdGraphicController;
29 #include "LinearMath/btVector3.h"
30 #include "LinearMath/btTransform.h"
31
32
33
34
35 class btTypedConstraint;
36 class btSimulationIslandManager;
37 class btCollisionDispatcher;
38 class btDispatcher;
39 //#include "btBroadphaseInterface.h"
40
41 //switch on/off new vehicle support
42 #define NEW_BULLET_VEHICLE_SUPPORT 1
43
44 #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h"
45
46 class WrapperVehicle;
47 class btPersistentManifold;
48 class btBroadphaseInterface;
49 struct btDbvtBroadphase;
50 class btOverlappingPairCache;
51 class btIDebugDraw;
52 class PHY_IVehicle;
53 class CcdOverlapFilterCallBack;
54
55 /** CcdPhysicsEnvironment is an experimental mainloop for physics simulation using optional continuous collision detection.
56  * Physics Environment takes care of stepping the simulation and is a container for physics entities.
57  * It stores rigidbodies,constraints, materials etc.
58  * A derived class may be able to 'construct' entities by loading and/or converting
59  */
60 class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
61 {
62         friend class CcdOverlapFilterCallBack;
63         btVector3 m_gravity;
64
65 protected:
66         btIDebugDraw*   m_debugDrawer;
67         
68         class btDefaultCollisionConfiguration* m_collisionConfiguration;
69     class btBroadphaseInterface*                m_broadphase;   // broadphase for dynamic world
70         // for culling only
71         btOverlappingPairCache*                         m_cullingCache;
72         struct btDbvtBroadphase*                        m_cullingTree;  // broadphase for culling
73
74         //solver iterations
75         int     m_numIterations;
76         
77         //timestep subdivisions
78         int     m_numTimeSubSteps;
79
80
81         int     m_ccdMode;
82         int     m_solverType;
83         int     m_profileTimings;
84         bool m_enableSatCollisionDetection;
85
86         btContactSolverInfo     m_solverInfo;
87         
88         void    processFhSprings(double curTime,float timeStep);
89
90         public:
91                 CcdPhysicsEnvironment(bool useDbvtCulling, btDispatcher* dispatcher=0, btOverlappingPairCache* pairCache=0);
92
93                 virtual         ~CcdPhysicsEnvironment();
94
95                 /////////////////////////////////////
96                 //PHY_IPhysicsEnvironment interface
97                 /////////////////////////////////////
98
99                 /// Perform an integration step of duration 'timeStep'.
100
101                 virtual void setDebugDrawer(btIDebugDraw* debugDrawer);
102
103                 virtual void            setNumIterations(int numIter);
104                 virtual void            setNumTimeSubSteps(int numTimeSubSteps)
105                 {
106                         m_numTimeSubSteps = numTimeSubSteps;
107                 }
108                 virtual void            setDeactivationTime(float dTime);
109                 virtual void            setDeactivationLinearTreshold(float linTresh) ;
110                 virtual void            setDeactivationAngularTreshold(float angTresh) ;
111                 virtual void            setContactBreakingTreshold(float contactBreakingTreshold) ;
112                 virtual void            setCcdMode(int ccdMode);
113                 virtual void            setSolverType(int solverType);
114                 virtual void            setSolverSorConstant(float sor);
115                 virtual void            setSolverTau(float tau);
116                 virtual void            setSolverDamping(float damping);
117                 virtual void            setLinearAirDamping(float damping);
118                 virtual void            setUseEpa(bool epa) ;
119
120                 virtual void            beginFrame();
121                 virtual void            endFrame() {};
122                 /// Perform an integration step of duration 'timeStep'.
123                 virtual bool            proceedDeltaTime(double curTime,float timeStep,float interval);
124                 
125                 virtual void            debugDrawWorld();
126 //              virtual bool            proceedDeltaTimeOneStep(float timeStep);
127
128                 virtual void            setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep){};
129                 //returns 0.f if no fixed timestep is used
130
131                 virtual float           getFixedTimeStep(){ return 0.f;};
132
133                 virtual void            setDebugMode(int debugMode);
134
135                 virtual void            setGravity(float x,float y,float z);
136                 virtual void            getGravity(PHY__Vector3& grav);
137
138
139                 virtual int                     createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
140                         float pivotX,float pivotY,float pivotZ,
141                         float axisX,float axisY,float axisZ,
142                         float axis1X=0,float axis1Y=0,float axis1Z=0,
143                         float axis2X=0,float axis2Y=0,float axis2Z=0,int flag=0
144                         );
145
146
147                 //Following the COLLADA physics specification for constraints
148                 virtual int                     createUniversalD6Constraint(
149                 class PHY_IPhysicsController* ctrlRef,class PHY_IPhysicsController* ctrlOther,
150                         btTransform& localAttachmentFrameRef,
151                         btTransform& localAttachmentOther,
152                         const btVector3& linearMinLimits,
153                         const btVector3& linearMaxLimits,
154                         const btVector3& angularMinLimits,
155                         const btVector3& angularMaxLimits,int flags
156                         );
157
158                 
159                 virtual void    setConstraintParam(int constraintId,int param,float value,float value1);
160                 
161                 virtual float   getConstraintParam(int constraintId,int param);
162
163             virtual void                removeConstraint(int    constraintid);
164
165                 virtual float           getAppliedImpulse(int   constraintid);
166
167
168                 virtual void    CallbackTriggers();
169
170
171 #ifdef NEW_BULLET_VEHICLE_SUPPORT
172                 //complex constraint for vehicles
173                 virtual PHY_IVehicle*   getVehicleConstraint(int constraintId);
174 #else
175                 virtual class PHY_IVehicle*     getVehicleConstraint(int constraintId)
176                 {
177                         return 0;
178                 }
179 #endif //NEW_BULLET_VEHICLE_SUPPORT
180
181                 btTypedConstraint*      getConstraintById(int constraintId);
182
183                 virtual PHY_IPhysicsController* rayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
184                 virtual bool cullingTest(PHY_CullingCallback callback, void* userData, PHY__Vector4* planes, int nplanes, int occlusionRes);
185
186
187                 //Methods for gamelogic collision/physics callbacks
188                 virtual void addSensor(PHY_IPhysicsController* ctrl);
189                 virtual void removeSensor(PHY_IPhysicsController* ctrl);
190                 virtual void addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user);
191                 virtual bool requestCollisionCallback(PHY_IPhysicsController* ctrl);
192                 virtual bool removeCollisionCallback(PHY_IPhysicsController* ctrl);
193                 //These two methods are used *solely* to create controllers for Near/Radar sensor! Don't use for anything else
194                 virtual PHY_IPhysicsController* CreateSphereController(float radius,const PHY__Vector3& position);
195                 virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight);
196         
197
198                 virtual int     getNumContactPoints();
199
200                 virtual void getContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ);
201
202                 //////////////////////
203                 //CcdPhysicsEnvironment interface
204                 ////////////////////////
205         
206                 void    addCcdPhysicsController(CcdPhysicsController* ctrl);
207
208                 bool    removeCcdPhysicsController(CcdPhysicsController* ctrl);
209
210                 void    updateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask);
211
212                 void    disableCcdPhysicsController(CcdPhysicsController* ctrl);
213
214                 void    enableCcdPhysicsController(CcdPhysicsController* ctrl);
215
216                 void    refreshCcdPhysicsController(CcdPhysicsController* ctrl);
217
218                 void    addCcdGraphicController(CcdGraphicController* ctrl);
219
220                 void    removeCcdGraphicController(CcdGraphicController* ctrl);
221
222                 btBroadphaseInterface*  getBroadphase();
223                 btDbvtBroadphase*       getCullingTree() { return m_cullingTree; }
224
225                 btDispatcher*   getDispatcher();
226                 
227
228                 bool    IsSatCollisionDetectionEnabled() const
229                 {
230                         return m_enableSatCollisionDetection;
231                 }
232
233                 void    EnableSatCollisionDetection(bool enableSat)
234                 {
235                         m_enableSatCollisionDetection = enableSat;
236                 }
237
238         
239                 const btPersistentManifold*     GetManifold(int index) const;
240
241         
242                 void    SyncMotionStates(float timeStep);
243
244                 class   btSoftRigidDynamicsWorld*       getDynamicsWorld()
245                 {
246                         return m_dynamicsWorld;
247                 }
248         
249                 class btConstraintSolver*       GetConstraintSolver();
250
251                 void MergeEnvironment(CcdPhysicsEnvironment *other);
252
253         protected:
254                 
255                 
256
257                 std::set<CcdPhysicsController*> m_controllers;
258                 std::set<CcdPhysicsController*> m_triggerControllers;
259
260                 PHY_ResponseCallback    m_triggerCallbacks[PHY_NUM_RESPONSE];
261                 void*                   m_triggerCallbacksUserPtrs[PHY_NUM_RESPONSE];
262                 
263                 std::vector<WrapperVehicle*>    m_wrapperVehicles;
264
265                 //use explicit btSoftRigidDynamicsWorld/btDiscreteDynamicsWorld* so that we have access to 
266                 //btDiscreteDynamicsWorld::addRigidBody(body,filter,group) 
267                 //so that we can set the body collision filter/group at the time of creation 
268                 //and not afterwards (breaks the collision system for radar/near sensor)
269                 //Ideally we would like to have access to this function from the btDynamicsWorld interface
270                 //class btDynamicsWorld*        m_dynamicsWorld;
271                 class   btSoftRigidDynamicsWorld*       m_dynamicsWorld;
272                 
273                 class btConstraintSolver*       m_solver;
274
275                 class btOverlappingPairCache* m_ownPairCache;
276
277                 class CcdOverlapFilterCallBack* m_filterCallback;
278
279                 class btDispatcher* m_ownDispatcher;
280
281                 bool    m_scalingPropagated;
282
283                 
284 #ifdef WITH_CXX_GUARDEDALLOC
285 public:
286         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:CcdPhysicsEnvironment"); }
287         void operator delete( void *mem ) { MEM_freeN(mem); }
288 #endif
289 };
290
291 #endif //CCDPHYSICSENVIRONMENT