1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
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.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
/** \file CcdPhysicsEnvironment.h
* \ingroup physbullet
* See also \ref bulletdoc
*/
#ifndef __CCDPHYSICSENVIRONMENT_H__
#define __CCDPHYSICSENVIRONMENT_H__
#include "PHY_IPhysicsEnvironment.h"
#include <vector>
#include <set>
#include <map>
class CcdPhysicsController;
class CcdGraphicController;
#include "LinearMath/btVector3.h"
#include "LinearMath/btTransform.h"
class btTypedConstraint;
class btSimulationIslandManager;
class btCollisionDispatcher;
class btDispatcher;
//#include "btBroadphaseInterface.h"
//switch on/off new vehicle support
#define NEW_BULLET_VEHICLE_SUPPORT 1
#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h"
class WrapperVehicle;
class btPersistentManifold;
class btBroadphaseInterface;
struct btDbvtBroadphase;
class btOverlappingPairCache;
class btIDebugDraw;
class PHY_IVehicle;
class CcdOverlapFilterCallBack;
/** CcdPhysicsEnvironment is an experimental mainloop for physics simulation using optional continuous collision detection.
* Physics Environment takes care of stepping the simulation and is a container for physics entities.
* It stores rigidbodies,constraints, materials etc.
* A derived class may be able to 'construct' entities by loading and/or converting
*/
class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
{
friend class CcdOverlapFilterCallBack;
btVector3 m_gravity;
protected:
btIDebugDraw* m_debugDrawer;
class btDefaultCollisionConfiguration* m_collisionConfiguration;
class btBroadphaseInterface* m_broadphase; // broadphase for dynamic world
// for culling only
btOverlappingPairCache* m_cullingCache;
struct btDbvtBroadphase* m_cullingTree; // broadphase for culling
//solver iterations
int m_numIterations;
//timestep subdivisions
int m_numTimeSubSteps;
int m_ccdMode;
int m_solverType;
int m_profileTimings;
bool m_enableSatCollisionDetection;
void ProcessFhSprings(double curTime,float timeStep);
public:
CcdPhysicsEnvironment(bool useDbvtCulling, btDispatcher* dispatcher=0, btOverlappingPairCache* pairCache=0);
virtual ~CcdPhysicsEnvironment();
/////////////////////////////////////
//PHY_IPhysicsEnvironment interface
/////////////////////////////////////
/// Perform an integration step of duration 'timeStep'.
virtual void SetDebugDrawer(btIDebugDraw* debugDrawer);
virtual void SetNumIterations(int numIter);
virtual void SetNumTimeSubSteps(int numTimeSubSteps)
{
m_numTimeSubSteps = numTimeSubSteps;
}
virtual void SetDeactivationTime(float dTime);
virtual void SetDeactivationLinearTreshold(float linTresh);
virtual void SetDeactivationAngularTreshold(float angTresh);
virtual void SetContactBreakingTreshold(float contactBreakingTreshold);
virtual void SetCcdMode(int ccdMode);
virtual void SetSolverType(int solverType);
virtual void SetSolverSorConstant(float sor);
virtual void SetSolverTau(float tau);
virtual void SetSolverDamping(float damping);
virtual void SetLinearAirDamping(float damping);
virtual void SetUseEpa(bool epa);
virtual int GetNumTimeSubSteps()
{
return m_numTimeSubSteps;
}
virtual void BeginFrame();
virtual void EndFrame() {}
/// Perform an integration step of duration 'timeStep'.
virtual bool ProceedDeltaTime(double curTime,float timeStep,float interval);
virtual void DebugDrawWorld();
// virtual bool proceedDeltaTimeOneStep(float timeStep);
virtual void SetFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)
{
//based on DEFAULT_PHYSICS_TIC_RATE of 60 hertz
SetNumTimeSubSteps((int)(fixedTimeStep / 60.f));
}
//returns 0.f if no fixed timestep is used
virtual float GetFixedTimeStep() { return 0.f; }
virtual void SetDebugMode(int debugMode);
virtual void SetGravity(float x,float y,float z);
virtual void GetGravity(MT_Vector3& grav);
virtual int CreateConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
float pivotX,float pivotY,float pivotZ,
float axisX,float axisY,float axisZ,
float axis1X=0,float axis1Y=0,float axis1Z=0,
float axis2X=0,float axis2Y=0,float axis2Z=0,int flag=0
);
//Following the COLLADA physics specification for constraints
virtual int CreateUniversalD6Constraint(
class PHY_IPhysicsController* ctrlRef,class PHY_IPhysicsController* ctrlOther,
btTransform& localAttachmentFrameRef,
btTransform& localAttachmentOther,
const btVector3& linearMinLimits,
const btVector3& linearMaxLimits,
const btVector3& angularMinLimits,
const btVector3& angularMaxLimits,int flags
);
virtual void SetConstraintParam(int constraintId,int param,float value,float value1);
virtual float GetConstraintParam(int constraintId,int param);
virtual void RemoveConstraint(int constraintid);
virtual float getAppliedImpulse(int constraintid);
virtual void CallbackTriggers();
#ifdef NEW_BULLET_VEHICLE_SUPPORT
//complex constraint for vehicles
virtual PHY_IVehicle* GetVehicleConstraint(int constraintId);
#else
virtual class PHY_IVehicle* GetVehicleConstraint(int constraintId)
{
return 0;
}
#endif /* NEW_BULLET_VEHICLE_SUPPORT */
// Character physics wrapper
virtual PHY_ICharacter* GetCharacterController(class KX_GameObject* ob);
btTypedConstraint* GetConstraintById(int constraintId);
virtual PHY_IPhysicsController* RayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ);
virtual bool CullingTest(PHY_CullingCallback callback, void* userData, MT_Vector4* planes, int nplanes, int occlusionRes, const int *viewport, double modelview[16], double projection[16]);
//Methods for gamelogic collision/physics callbacks
virtual void AddSensor(PHY_IPhysicsController* ctrl);
virtual void RemoveSensor(PHY_IPhysicsController* ctrl);
virtual void AddTouchCallback(int response_class, PHY_ResponseCallback callback, void *user);
virtual bool RequestCollisionCallback(PHY_IPhysicsController* ctrl);
virtual bool RemoveCollisionCallback(PHY_IPhysicsController* ctrl);
//These two methods are used *solely* to create controllers for Near/Radar sensor! Don't use for anything else
virtual PHY_IPhysicsController* CreateSphereController(float radius,const MT_Vector3& position);
virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight);
virtual int GetNumContactPoints();
virtual void GetContactPoint(int i,float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ);
//////////////////////
//CcdPhysicsEnvironment interface
////////////////////////
void AddCcdPhysicsController(CcdPhysicsController* ctrl);
bool RemoveCcdPhysicsController(CcdPhysicsController* ctrl);
void UpdateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask);
void DisableCcdPhysicsController(CcdPhysicsController* ctrl);
void EnableCcdPhysicsController(CcdPhysicsController* ctrl);
void RefreshCcdPhysicsController(CcdPhysicsController* ctrl);
void AddCcdGraphicController(CcdGraphicController* ctrl);
void RemoveCcdGraphicController(CcdGraphicController* ctrl);
btBroadphaseInterface* GetBroadphase();
btDbvtBroadphase* GetCullingTree() { return m_cullingTree; }
btDispatcher* GetDispatcher();
bool IsSatCollisionDetectionEnabled() const
{
return m_enableSatCollisionDetection;
}
void EnableSatCollisionDetection(bool enableSat)
{
m_enableSatCollisionDetection = enableSat;
}
const btPersistentManifold* GetManifold(int index) const;
void SyncMotionStates(float timeStep);
class btSoftRigidDynamicsWorld* GetDynamicsWorld()
{
return m_dynamicsWorld;
}
class btConstraintSolver* GetConstraintSolver();
void MergeEnvironment(PHY_IPhysicsEnvironment *other_env);
static CcdPhysicsEnvironment *Create(struct Scene *blenderscene, bool visualizePhysics);
virtual void ConvertObject(KX_GameObject* gameobj,
RAS_MeshObject* meshobj,
DerivedMesh* dm,
KX_Scene* kxscene,
PHY_ShapeProps* shapeprops,
PHY_MaterialProps* smmaterial,
PHY_IMotionState *motionstate,
int activeLayerBitInfo,
bool isCompoundChild,
bool hasCompoundChildren);
protected:
std::set<CcdPhysicsController*> m_controllers;
std::set<CcdPhysicsController*> m_triggerControllers;
PHY_ResponseCallback m_triggerCallbacks[PHY_NUM_RESPONSE];
void* m_triggerCallbacksUserPtrs[PHY_NUM_RESPONSE];
std::vector<WrapperVehicle*> m_wrapperVehicles;
//use explicit btSoftRigidDynamicsWorld/btDiscreteDynamicsWorld* so that we have access to
//btDiscreteDynamicsWorld::addRigidBody(body,filter,group)
//so that we can set the body collision filter/group at the time of creation
//and not afterwards (breaks the collision system for radar/near sensor)
//Ideally we would like to have access to this function from the btDynamicsWorld interface
//class btDynamicsWorld* m_dynamicsWorld;
class btSoftRigidDynamicsWorld* m_dynamicsWorld;
class btConstraintSolver* m_solver;
class btOverlappingPairCache* m_ownPairCache;
class CcdOverlapFilterCallBack* m_filterCallback;
class btGhostPairCallback* m_ghostPairCallback;
class btDispatcher* m_ownDispatcher;
bool m_scalingPropagated;
virtual void ExportFile(const char* filename);
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("GE:CcdPhysicsEnvironment")
#endif
};
#endif /* __CCDPHYSICSENVIRONMENT_H__ */
|