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_H__
  22 #define __CCDPHYSICSENVIRONMENT_H__
  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                 {
 130                         //based on DEFAULT_PHYSICS_TIC_RATE of 60 hertz
 131                         setNumTimeSubSteps((int)(fixedTimeStep / 60.f));
 132                 }
 133                 //returns 0.f if no fixed timestep is used
 134
 135                 virtual float           getFixedTimeStep() { return 0.f; }
 136
 137                 virtual void            setDebugMode(int debugMode);
 138
 139                 virtual void            setGravity(float x,float y,float z);
 140                 virtual void            getGravity(PHY__Vector3& grav);
 141
 142
 143                 virtual int                     createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
 144                         float pivotX,float pivotY,float pivotZ,
 145                         float axisX,float axisY,float axisZ,
 146                         float axis1X=0,float axis1Y=0,float axis1Z=0,
 147                         float axis2X=0,float axis2Y=0,float axis2Z=0,int flag=0
 148                         );
 149
 150
 151                 //Following the COLLADA physics specification for constraints
 152                 virtual int                     createUniversalD6Constraint(
 153                 class PHY_IPhysicsController* ctrlRef,class PHY_IPhysicsController* ctrlOther,
 154                         btTransform& localAttachmentFrameRef,
 155                         btTransform& localAttachmentOther,
 156                         const btVector3& linearMinLimits,
 157                         const btVector3& linearMaxLimits,
 158                         const btVector3& angularMinLimits,
 159                         const btVector3& angularMaxLimits,int flags
 160                         );
 161
 162
 163                 virtual void    setConstraintParam(int constraintId,int param,float value,float value1);
 164
 165                 virtual float   getConstraintParam(int constraintId,int param);
 166
 167                 virtual void            removeConstraint(int    constraintid);
 168
 169                 virtual float           getAppliedImpulse(int   constraintid);
 170
 171
 172                 virtual void    CallbackTriggers();
 173
 174
 175 #ifdef NEW_BULLET_VEHICLE_SUPPORT
 176                 //complex constraint for vehicles
 177                 virtual PHY_IVehicle*   getVehicleConstraint(int constraintId);
 178 #else
 179                 virtual class PHY_IVehicle*     getVehicleConstraint(int constraintId)
 180                 {
 181                         return 0;
 182                 }
 183 #endif //NEW_BULLET_VEHICLE_SUPPORT
 184
 185                 btTypedConstraint*      getConstraintById(int constraintId);
 186
 187                 virtual PHY_IPhysicsController* rayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
 188                 virtual bool cullingTest(PHY_CullingCallback callback, void* userData, PHY__Vector4* planes, int nplanes, int occlusionRes);
 189
 190
 191                 //Methods for gamelogic collision/physics callbacks
 192                 virtual void addSensor(PHY_IPhysicsController* ctrl);
 193                 virtual void removeSensor(PHY_IPhysicsController* ctrl);
 194                 virtual void addTouchCallback(int response_class, PHY_ResponseCallback callback, void *user);
 195                 virtual bool requestCollisionCallback(PHY_IPhysicsController* ctrl);
 196                 virtual bool removeCollisionCallback(PHY_IPhysicsController* ctrl);
 197                 //These two methods are used *solely* to create controllers for Near/Radar sensor! Don't use for anything else
 198                 virtual PHY_IPhysicsController* CreateSphereController(float radius,const PHY__Vector3& position);
 199                 virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight);
 200
 201
 202                 virtual int     getNumContactPoints();
 203
 204                 virtual void getContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ);
 205
 206                 //////////////////////
 207                 //CcdPhysicsEnvironment interface
 208                 ////////////////////////
 209
 210                 void    addCcdPhysicsController(CcdPhysicsController* ctrl);
 211
 212                 bool    removeCcdPhysicsController(CcdPhysicsController* ctrl);
 213
 214                 void    updateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask);
 215
 216                 void    disableCcdPhysicsController(CcdPhysicsController* ctrl);
 217
 218                 void    enableCcdPhysicsController(CcdPhysicsController* ctrl);
 219
 220                 void    refreshCcdPhysicsController(CcdPhysicsController* ctrl);
 221
 222                 void    addCcdGraphicController(CcdGraphicController* ctrl);
 223
 224                 void    removeCcdGraphicController(CcdGraphicController* ctrl);
 225
 226                 btBroadphaseInterface*  getBroadphase();
 227                 btDbvtBroadphase*       getCullingTree() { return m_cullingTree; }
 228
 229                 btDispatcher*   getDispatcher();
 230
 231
 232                 bool    IsSatCollisionDetectionEnabled() const
 233                 {
 234                         return m_enableSatCollisionDetection;
 235                 }
 236
 237                 void    EnableSatCollisionDetection(bool enableSat)
 238                 {
 239                         m_enableSatCollisionDetection = enableSat;
 240                 }
 241
 242
 243                 const btPersistentManifold*     GetManifold(int index) const;
 244
 245
 246                 void    SyncMotionStates(float timeStep);
 247
 248                 class   btSoftRigidDynamicsWorld*       getDynamicsWorld()
 249                 {
 250                         return m_dynamicsWorld;
 251                 }
 252
 253                 class btConstraintSolver*       GetConstraintSolver();
 254
 255                 void MergeEnvironment(CcdPhysicsEnvironment *other);
 256
 257         protected:
 258
 259
 260
 261                 std::set<CcdPhysicsController*> m_controllers;
 262                 std::set<CcdPhysicsController*> m_triggerControllers;
 263
 264                 PHY_ResponseCallback    m_triggerCallbacks[PHY_NUM_RESPONSE];
 265                 void*                   m_triggerCallbacksUserPtrs[PHY_NUM_RESPONSE];
 266
 267                 std::vector<WrapperVehicle*>    m_wrapperVehicles;
 268
 269                 //use explicit btSoftRigidDynamicsWorld/btDiscreteDynamicsWorld* so that we have access to
 270                 //btDiscreteDynamicsWorld::addRigidBody(body,filter,group)
 271                 //so that we can set the body collision filter/group at the time of creation
 272                 //and not afterwards (breaks the collision system for radar/near sensor)
 273                 //Ideally we would like to have access to this function from the btDynamicsWorld interface
 274                 //class btDynamicsWorld*        m_dynamicsWorld;
 275                 class   btSoftRigidDynamicsWorld*       m_dynamicsWorld;
 276
 277                 class btConstraintSolver*       m_solver;
 278
 279                 class btOverlappingPairCache* m_ownPairCache;
 280
 281                 class CcdOverlapFilterCallBack* m_filterCallback;
 282
 283                 class btDispatcher* m_ownDispatcher;
 284
 285                 bool    m_scalingPropagated;
 286
 287                 virtual void    exportFile(const char* filename);
 288
 289
 290 #ifdef WITH_CXX_GUARDEDALLOC
 291 public:
 292         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:CcdPhysicsEnvironment"); }
 293         void operator delete( void *mem ) { MEM_freeN(mem); }
 294 #endif
 295 };
 296
 297 #endif //__CCDPHYSICSENVIRONMENT_H__