soc-2008-mxcurioni: merged changes to revision 15705
[blender.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_bRigid(false),
64                 m_collisionFilterGroup(DefaultFilter),
65                 m_collisionFilterMask(AllFilter),
66                 m_collisionShape(0),
67                 m_MotionState(0),
68                 m_physicsEnv(0),
69                 m_inertiaFactor(1.f)
70         {
71         }
72
73         btVector3       m_localInertiaTensor;
74         btVector3       m_gravity;
75         btVector3       m_scaling;
76         btScalar        m_mass;
77         btScalar        m_restitution;
78         btScalar        m_friction;
79         btScalar        m_linearDamping;
80         btScalar        m_angularDamping;
81         int                     m_collisionFlags;
82         bool            m_bRigid;
83
84         ///optional use of collision group/mask:
85         ///only collision with object goups that match the collision mask.
86         ///this is very basic early out. advanced collision filtering should be
87         ///done in the btCollisionDispatcher::NeedsCollision and NeedsResponse
88         ///both values default to 1
89         short int       m_collisionFilterGroup;
90         short int       m_collisionFilterMask;
91
92         class btCollisionShape* m_collisionShape;
93         class PHY_IMotionState* m_MotionState;
94         
95         CcdPhysicsEnvironment*  m_physicsEnv; //needed for self-replication
96         float   m_inertiaFactor;//tweak the inertia (hooked up to Blender 'formfactor'
97 };
98
99
100 class btRigidBody;
101
102
103 ///CcdPhysicsController is a physics object that supports continuous collision detection and time of impact based physics resolution.
104 class CcdPhysicsController : public PHY_IPhysicsController      
105 {
106         btRigidBody* m_body;
107         class PHY_IMotionState*         m_MotionState;
108         btMotionState*  m_bulletMotionState;
109         friend class CcdPhysicsEnvironment;     // needed when updating the controller
110
111
112         void*           m_newClientInfo;
113
114         CcdConstructionInfo     m_cci;//needed for replication
115         void GetWorldOrientation(btMatrix3x3& mat);
116
117         void CreateRigidbody();
118
119         protected:
120                 void setWorldOrientation(const btMatrix3x3& mat);
121
122         public:
123         
124                 int                             m_collisionDelay;
125         
126
127                 CcdPhysicsController (const CcdConstructionInfo& ci);
128
129                 virtual ~CcdPhysicsController();
130
131
132                 btRigidBody* GetRigidBody() { return m_body;}
133
134                 btCollisionShape*       GetCollisionShape() { 
135                         return m_body->getCollisionShape();
136                 }
137                 ////////////////////////////////////
138                 // PHY_IPhysicsController interface
139                 ////////////////////////////////////
140
141
142                 /**
143                         SynchronizeMotionStates ynchronizes dynas, kinematic and deformable entities (and do 'late binding')
144                 */
145                 virtual bool            SynchronizeMotionStates(float time);
146                 /**
147                         WriteMotionStateToDynamics ynchronizes dynas, kinematic and deformable entities (and do 'late binding')
148                 */
149                 
150                 virtual void            WriteMotionStateToDynamics(bool nondynaonly);
151                 virtual void            WriteDynamicsToMotionState();
152                 // controller replication
153                 virtual void            PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl);
154
155                 // kinematic methods
156                 virtual void            RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local);
157                 virtual void            RelativeRotate(const float drot[9],bool local);
158                 virtual void            getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal);
159                 virtual void            setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal);
160                 virtual void            setPosition(float posX,float posY,float posZ);
161                 virtual void            getPosition(PHY__Vector3&       pos) const;
162
163                 virtual void            setScaling(float scaleX,float scaleY,float scaleZ);
164                 
165                 // physics methods
166                 virtual void            ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local);
167                 virtual void            ApplyForce(float forceX,float forceY,float forceZ,bool local);
168                 virtual void            SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local);
169                 virtual void            SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local);
170                 virtual void            applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ);
171                 virtual void            SetActive(bool active);
172
173                 // reading out information from physics
174                 virtual void            GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
175                 virtual void            GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ);
176                 virtual void            GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
177                 virtual void            getReactionForce(float& forceX,float& forceY,float& forceZ);
178
179                 // dyna's that are rigidbody are free in orientation, dyna's with non-rigidbody are restricted 
180                 virtual void            setRigidBody(bool rigid);
181
182                 
183                 virtual void            resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
184
185                 // clientinfo for raycasts for example
186                 virtual void*                           getNewClientInfo();
187                 virtual void                            setNewClientInfo(void* clientinfo);
188                 virtual PHY_IPhysicsController* GetReplica();
189                 
190                 ///There should be no 'SetCollisionFilterGroup' method, as changing this during run-time is will result in errors
191                 short int       GetCollisionFilterGroup() const
192                 {
193                         return m_cci.m_collisionFilterGroup;
194                 }
195                 ///There should be no 'SetCollisionFilterGroup' method, as changing this during run-time is will result in errors
196                 short int       GetCollisionFilterMask() const
197                 {
198                         return m_cci.m_collisionFilterMask;
199                 }
200
201                 virtual void    calcXform() {} ;
202                 virtual void SetMargin(float margin) {};
203                 virtual float GetMargin() const {return 0.f;};
204
205
206                 bool    wantsSleeping();
207
208                 void    UpdateDeactivation(float timeStep);
209
210                 static btTransform      GetTransformFromMotionState(PHY_IMotionState* motionState);
211
212                 void    setAabb(const btVector3& aabbMin,const btVector3& aabbMax);
213
214
215                 class   PHY_IMotionState*                       GetMotionState()
216                 {
217                         return m_MotionState;
218                 }
219
220                 const class     PHY_IMotionState*                       GetMotionState() const
221                 {
222                         return m_MotionState;
223                 }
224
225                 class CcdPhysicsEnvironment* GetPhysicsEnvironment()
226                 {
227                         return m_cci.m_physicsEnv;
228                 }
229                 
230 };
231
232
233
234
235 ///DefaultMotionState implements standard motionstate, using btTransform
236 class   DefaultMotionState : public PHY_IMotionState
237
238 {
239         public:
240                 DefaultMotionState();
241
242                 virtual ~DefaultMotionState();
243
244                 virtual void    getWorldPosition(float& posX,float& posY,float& posZ);
245                 virtual void    getWorldScaling(float& scaleX,float& scaleY,float& scaleZ);
246                 virtual void    getWorldOrientation(float& quatIma0,float& quatIma1,float& quatIma2,float& quatReal);
247                 
248                 virtual void    setWorldPosition(float posX,float posY,float posZ);
249                 virtual void    setWorldOrientation(float quatIma0,float quatIma1,float quatIma2,float quatReal);
250                 
251                 virtual void    calculateWorldTransformations();
252                 
253                 btTransform     m_worldTransform;
254                 btVector3               m_localScaling;
255
256 };
257
258
259 #endif //BULLET2_PHYSICSCONTROLLER_H