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
|
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file PHY_IPhysicsEnvironment.h
* \ingroup phys
*/
#ifndef __PHY_IPHYSICSENVIRONMENT_H__
#define __PHY_IPHYSICSENVIRONMENT_H__
#include "PHY_DynamicTypes.h"
#include "MT_Vector2.h"
#include "MT_Vector3.h"
#include "MT_Vector4.h"
#ifdef WITH_CXX_GUARDEDALLOC
#include "MEM_guardedalloc.h"
#endif
class PHY_IVehicle;
class PHY_ICharacter;
class RAS_MeshObject;
class PHY_IPhysicsController;
class RAS_MeshObject;
struct DerivedMesh;
class KX_GameObject;
class KX_Scene;
struct PHY_ShapeProps;
struct PHY_MaterialProps;
class PHY_IMotionState;
struct bRigidBodyJointConstraint;
/**
* pass back information from rayTest
*/
struct PHY_RayCastResult
{
PHY_IPhysicsController* m_controller;
MT_Vector3 m_hitPoint;
MT_Vector3 m_hitNormal;
const RAS_MeshObject* m_meshObject; // !=NULL for mesh object (only for Bullet controllers)
int m_polygon; // index of the polygon hit by the ray,
// only if m_meshObject != NULL
int m_hitUVOK; // !=0 if UV coordinate in m_hitUV is valid
MT_Vector2 m_hitUV; // UV coordinates of hit point
};
/**
* This class replaces the ignoreController parameter of rayTest function.
* It allows more sophisticated filtering on the physics controller before computing the ray intersection to save CPU.
* It is only used to its full extend by the Ccd physics environment (Bullet).
*/
class PHY_IRayCastFilterCallback
{
public:
PHY_IPhysicsController* m_ignoreController;
bool m_faceNormal;
bool m_faceUV;
virtual ~PHY_IRayCastFilterCallback()
{
}
virtual bool needBroadphaseRayCast(PHY_IPhysicsController* controller)
{
return true;
}
virtual void reportHit(PHY_RayCastResult* result) = 0;
PHY_IRayCastFilterCallback(PHY_IPhysicsController* ignoreController, bool faceNormal=false, bool faceUV=false)
:m_ignoreController(ignoreController),
m_faceNormal(faceNormal),
m_faceUV(faceUV)
{
}
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("GE:PHY_IRayCastFilterCallback")
#endif
};
/**
* Physics Environment takes care of stepping the simulation and is a container for physics entities
* (rigidbodies,constraints, materials etc.)
* A derived class may be able to 'construct' entities by loading and/or converting
*/
class PHY_IPhysicsEnvironment
{
public:
virtual ~PHY_IPhysicsEnvironment(){}
virtual void BeginFrame() = 0;
virtual void EndFrame() = 0;
/// Perform an integration step of duration 'timeStep'.
virtual bool ProceedDeltaTime(double curTime,float timeStep,float interval)=0;
///draw debug lines (make sure to call this during the render phase, otherwise lines are not drawn properly)
virtual void DebugDrawWorld() {}
virtual void SetFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)=0;
//returns 0.f if no fixed timestep is used
virtual float GetFixedTimeStep()=0;
///getDebugMode return the actual debug visualization state
virtual int GetDebugMode()const=0;
///setDebugMode is used to support several ways of debug lines, contact point visualization
virtual void SetDebugMode(int debugMode) {}
///setNumIterations set the number of iterations for iterative solvers
virtual void SetNumIterations(int numIter) {}
///setNumTimeSubSteps set the number of divisions of the timestep. Tradeoff quality versus performance.
virtual void SetNumTimeSubSteps(int numTimeSubSteps) {}
virtual int GetNumTimeSubSteps() {return 0; }
///setDeactivationTime sets the minimum time that an objects has to stay within the velocity tresholds until it gets fully deactivated
virtual void SetDeactivationTime(float dTime) {}
///setDeactivationLinearTreshold sets the linear velocity treshold, see setDeactivationTime
virtual void SetDeactivationLinearTreshold(float linTresh) {}
///setDeactivationAngularTreshold sets the angular velocity treshold, see setDeactivationTime
virtual void SetDeactivationAngularTreshold(float angTresh) {}
///setContactBreakingTreshold sets tresholds to do with contact point management
virtual void SetContactBreakingTreshold(float contactBreakingTreshold) {}
///continuous collision detection mode, very experimental for Bullet
virtual void SetCcdMode(int ccdMode) {}
///successive overrelaxation constant, in case PSOR is used, values in between 1 and 2 guarantee converging behavior
virtual void SetSolverSorConstant(float sor) {}
///setSolverType, internal setting, chooses solvertype, PSOR, Dantzig, impulse based, penalty based
virtual void SetSolverType(int solverType) {}
///setTau sets the spring constant of a penalty based solver
virtual void SetSolverTau(float tau) {}
///setDamping sets the damper constant of a penalty based solver
virtual void SetSolverDamping(float damping) {}
///linear air damping for rigidbodies
virtual void SetLinearAirDamping(float damping) {}
/// penetrationdepth setting
virtual void SetUseEpa(bool epa) {}
virtual void SetGravity(float x,float y,float z)=0;
virtual void GetGravity(MT_Vector3& grav) = 0;
virtual int CreateConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
float pivotX,float pivotY,float pivotZ,
float axis0X,float axis0Y,float axis0Z,
float axis1X=0,float axis1Y=0,float axis1Z=0,
float axis2X=0,float axis2Y=0,float axis2Z=0,int flag=0
)=0;
virtual void RemoveConstraintById(int constraintid) = 0;
virtual float GetAppliedImpulse(int constraintid) { return 0.0f; }
//complex constraint for vehicles
virtual PHY_IVehicle* GetVehicleConstraint(int constraintId) =0;
// Character physics wrapper
virtual PHY_ICharacter* GetCharacterController(class KX_GameObject* ob) =0;
virtual PHY_IPhysicsController* RayTest(PHY_IRayCastFilterCallback &filterCallback, float fromX,float fromY,float fromZ, float toX,float toY,float toZ)=0;
//culling based on physical broad phase
// the plane number must be set as follow: near, far, left, right, top, botton
// the near plane must be the first one and must always be present, it is used to get the direction of the view
virtual bool CullingTest(PHY_CullingCallback callback, void *userData, MT_Vector4* planeNormals, int planeNumber, int occlusionRes, const int *viewport, double modelview[16], double projection[16]) = 0;
//Methods for gamelogic collision/physics callbacks
//todo:
virtual void AddSensor(PHY_IPhysicsController* ctrl)=0;
virtual void RemoveSensor(PHY_IPhysicsController* ctrl)=0;
virtual void AddTouchCallback(int response_class, PHY_ResponseCallback callback, void *user)=0;
virtual bool RequestCollisionCallback(PHY_IPhysicsController* ctrl)=0;
virtual bool RemoveCollisionCallback(PHY_IPhysicsController* ctrl)=0;
//These two methods are *solely* used to create controllers for sensor! Don't use for anything else
virtual PHY_IPhysicsController* CreateSphereController(float radius,const MT_Vector3& position) =0;
virtual PHY_IPhysicsController* CreateConeController(float coneradius,float coneheight)=0;
virtual void SetConstraintParam(int constraintId,int param,float value,float value1) = 0;
virtual float GetConstraintParam(int constraintId,int param) = 0;
virtual void ExportFile(const char* filename) {};
virtual void MergeEnvironment(PHY_IPhysicsEnvironment *other_env) = 0;
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) = 0;
/* Set the rigid body joints constraints values for converted objects and replicated group instances. */
virtual void SetupObjectConstraints(KX_GameObject *obj_src, KX_GameObject *obj_dest,
bRigidBodyJointConstraint *dat) {}
#ifdef WITH_CXX_GUARDEDALLOC
MEM_CXX_CLASS_ALLOC_FUNCS("GE:PHY_IPhysicsEnvironment")
#endif
};
#endif /* __PHY_IPHYSICSENVIRONMENT_H__ */
|
