Radar/Near sensor performance problem fixed
[blender-staging.git] / source / gameengine / Physics / Bullet / CcdPhysicsController.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
17 #ifndef BULLET2_PHYSICSCONTROLLER_H
18 #define BULLET2_PHYSICSCONTROLLER_H
19
20 #include "PHY_IPhysicsController.h"
21
22 ///     PHY_IPhysicsController is the abstract simplified Interface to a physical object.
23 ///     It contains the IMotionState and IDeformableMesh Interfaces.
24 #include "btBulletDynamicsCommon.h"
25
26 #include "PHY_IMotionState.h"
27
28 extern float gDeactivationTime;
29 extern float gLinearSleepingTreshold;
30 extern float gAngularSleepingTreshold;
31 extern bool gDisableDeactivation;
32 class CcdPhysicsEnvironment;
33 class btMotionState;
34
35
36
37 struct CcdConstructionInfo
38 {
39
40         ///CollisionFilterGroups provides some optional usage of basic collision filtering
41         ///this is done during broadphase, so very early in the pipeline
42         ///more advanced collision filtering should be done in btCollisionDispatcher::NeedsCollision
43         enum CollisionFilterGroups
44         {
45                 DefaultFilter = 1,
46                 StaticFilter = 2,
47                 KinematicFilter = 4,
48                 DebrisFilter = 8,
49                         SensorFilter = 16,
50                 AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorFilter,
51         };
52
53
54         CcdConstructionInfo()
55                 : m_gravity(0,0,0),
56                 m_scaling(1.f,1.f,1.f),
57                 m_mass(0.f),
58                 m_restitution(0.1f),
59                 m_friction(0.5f),
60                 m_linearDamping(0.1f),
61                 m_angularDamping(0.1f),
62                 m_collisionFlags(0),
63                 m_collisionFilterGroup(DefaultFilter),
64                 m_collisionFilterMask(AllFilter),
65                 m_collisionShape(0),
66                 m_MotionState(0),
67                 m_physicsEnv(0),
68                 m_inertiaFactor(1.f)
69         {
70         }
71
72         btVector3       m_localInertiaTensor;
73         btVector3       m_gravity;
74         btVector3       m_scaling;
75         btScalar        m_mass;
76         btScalar        m_restitution;
77         btScalar        m_friction;
78         btScalar        m_linearDamping;
79         btScalar        m_angularDamping;
80         int                     m_collisionFlags;
81
82         ///optional use of collision group/mask:
83         ///only collision with object goups that match the collision mask.
84         ///this is very basic early out. advanced collision filtering should be
85         ///done in the btCollisionDispatcher::NeedsCollision and NeedsResponse
86         ///both values default to 1
87         short int       m_collisionFilterGroup;
88         short int       m_collisionFilterMask;
89
90         class btCollisionShape* m_collisionShape;
91         class PHY_IMotionState* m_MotionState;
92         
93         CcdPhysicsEnvironment*  m_physicsEnv; //needed for self-replication
94         float   m_inertiaFactor;//tweak the inertia (hooked up to Blender 'formfactor'
95 };
96
97
98 class btRigidBody;
99
100
101 ///CcdPhysicsController is a physics object that supports continuous collision detection and time of impact based physics resolution.
102 class CcdPhysicsController : public PHY_IPhysicsController      
103 {
104         btRigidBody* m_body;
105         class PHY_IMotionState*         m_MotionState;
106         btMotionState*  m_bulletMotionState;
107
108
109         void*           m_newClientInfo;
110
111         CcdConstructionInfo     m_cci;//needed for replication
112         void GetWorldOrientation(btMatrix3x3& mat);
113
114         void CreateRigidbody();
115
116         public:
117         
118                 int                             m_collisionDelay;
119         
120
121                 CcdPhysicsController (const CcdConstructionInfo& ci);
122
123                 virtual ~CcdPhysicsController();
124
125
126                 btRigidBody* GetRigidBody() { return m_body;}
127
128                 btCollisionShape*       GetCollisionShape() { 
129                         return m_body->getCollisionShape();
130                 }
131                 ////////////////////////////////////
132                 // PHY_IPhysicsController interface
133                 ////////////////////////////////////
134
135
136                 /**
137                         SynchronizeMotionStates ynchronizes dynas, kinematic and deformable entities (and do 'late binding')
138                 */
139                 virtual bool            SynchronizeMotionStates(float time);
140                 /**
141                         WriteMotionStateToDynamics ynchronizes dynas, kinematic and deformable entities (and do 'late binding')
142                 */
143                 
144                 virtual void            WriteMotionStateToDynamics(bool nondynaonly);
145                 virtual void            WriteDynamicsToMotionState();
146                 // controller replication
147                 virtual void            PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl);
148
149                 // kinematic methods
150                 virtual void            RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local);
151                 virtual void            RelativeRotate(const float drot[9],bool local);
152                 virtual void            getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal);
153                 virtual void            setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal);
154                 virtual void            setPosition(float posX,float posY,float posZ);
155                 virtual void            getPosition(PHY__Vector3&       pos) const;
156
157                 virtual void            setScaling(float scaleX,float scaleY,float scaleZ);
158                 
159                 // physics methods
160                 virtual void            ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local);
161                 virtual void            ApplyForce(float forceX,float forceY,float forceZ,bool local);
162                 virtual void            SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local);
163                 virtual void            SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local);
164                 virtual void            applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ);
165                 virtual void            SetActive(bool active);
166
167                 // reading out information from physics
168                 virtual void            GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
169                 virtual void            GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ);
170                 virtual void            GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
171                 virtual void            getReactionForce(float& forceX,float& forceY,float& forceZ);
172
173                 // dyna's that are rigidbody are free in orientation, dyna's with non-rigidbody are restricted 
174                 virtual void            setRigidBody(bool rigid);
175
176                 
177                 virtual void            resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
178
179                 // clientinfo for raycasts for example
180                 virtual void*                           getNewClientInfo();
181                 virtual void                            setNewClientInfo(void* clientinfo);
182                 virtual PHY_IPhysicsController* GetReplica();
183                 
184                 ///There should be no 'SetCollisionFilterGroup' method, as changing this during run-time is will result in errors
185                 short int       GetCollisionFilterGroup() const
186                 {
187                         return m_cci.m_collisionFilterGroup;
188                 }
189                 ///There should be no 'SetCollisionFilterGroup' method, as changing this during run-time is will result in errors
190                 short int       GetCollisionFilterMask() const
191                 {
192                         return m_cci.m_collisionFilterMask;
193                 }
194
195
196                 virtual void    calcXform() {} ;
197                 virtual void SetMargin(float margin) {};
198                 virtual float GetMargin() const {return 0.f;};
199
200
201                 bool    wantsSleeping();
202
203                 void    UpdateDeactivation(float timeStep);
204
205                 static btTransform      GetTransformFromMotionState(PHY_IMotionState* motionState);
206
207                 void    setAabb(const btVector3& aabbMin,const btVector3& aabbMax);
208
209
210                 class   PHY_IMotionState*                       GetMotionState()
211                 {
212                         return m_MotionState;
213                 }
214
215                 const class     PHY_IMotionState*                       GetMotionState() const
216                 {
217                         return m_MotionState;
218                 }
219
220                 class CcdPhysicsEnvironment* GetPhysicsEnvironment()
221                 {
222                         return m_cci.m_physicsEnv;
223                 }
224                 
225 };
226
227
228
229
230 ///DefaultMotionState implements standard motionstate, using btTransform
231 class   DefaultMotionState : public PHY_IMotionState
232
233 {
234         public:
235                 DefaultMotionState();
236
237                 virtual ~DefaultMotionState();
238
239                 virtual void    getWorldPosition(float& posX,float& posY,float& posZ);
240                 virtual void    getWorldScaling(float& scaleX,float& scaleY,float& scaleZ);
241                 virtual void    getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal);
242                 
243                 virtual void    setWorldPosition(float posX,float posY,float posZ);
244                 virtual void    setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal);
245                 
246                 virtual void    calculateWorldTransformations();
247                 
248                 btTransform     m_worldTransform;
249                 btVector3               m_localScaling;
250
251 };
252
253
254 #endif //BULLET2_PHYSICSCONTROLLER_H