Added resolveCombinedVelocities()
[blender.git] / source / gameengine / Physics / Sumo / SumoPhysicsController.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32 #ifndef __SUMO_PHYSICSCONTROLLER_H
33 #define __SUMO_PHYSICSCONTROLLER_H
34
35 #include "PHY_IPhysicsController.h"
36 #include "SM_Scene.h"
37 #include "SM_Callback.h"
38
39 /**
40         Sumo Physics Controller, a special kind of a PhysicsController.
41         A Physics Controller is a special kind of Scene Graph Transformation Controller.
42         Each time the scene graph get's updated, the controller get's a chance
43         in the 'Update' method to reflect changes.
44 */
45
46 class SumoPhysicsController : public PHY_IPhysicsController , public SM_Callback
47
48                                                          
49 {
50
51
52 public:
53         SumoPhysicsController(
54                                 class SM_Scene* sumoScene,
55                                 DT_SceneHandle solidscene,
56                                 class SM_Object* sumoObj,
57                                 class PHY_IMotionState* motionstate,
58                                 bool dyna); 
59
60         virtual ~SumoPhysicsController();
61         
62                 // kinematic methods
63         virtual void            RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local);
64         virtual void            RelativeRotate(const float drot[12],bool local);
65         virtual void            getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal);
66         virtual void            setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal);
67         virtual void            setPosition(float posX,float posY,float posZ);
68         virtual void            setScaling(float scaleX,float scaleY,float scaleZ);
69         
70         // physics methods
71         virtual void            ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local);
72         virtual void            ApplyForce(float forceX,float forceY,float forceZ,bool local);
73         virtual void            SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local);
74         virtual void            SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local);
75         virtual void            resolveCombinedVelocities(const MT_Vector3 & lin_vel, const MT_Vector3 & ang_vel );
76         virtual void            applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ);
77         virtual void            SetActive(bool active){};
78         virtual void            SuspendDynamics();
79         virtual void            RestoreDynamics();
80
81
82         /**  
83                 reading out information from physics
84         */
85         virtual void            GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
86         /** 
87                 GetVelocity parameters are in geometric coordinates (Origin is not center of mass!).
88         */
89         virtual void            GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
90         virtual float           getMass();
91         virtual void            getReactionForce(float& forceX,float& forceY,float& forceZ);
92         virtual void            setRigidBody(bool rigid);
93                 
94         
95         virtual void            PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl);
96         
97         // todo: remove next line !
98         virtual void                    SetSimulatedTime(float time);
99         
100
101         virtual void            WriteDynamicsToMotionState() {};
102         virtual void    WriteMotionStateToDynamics(bool nondynaonly);
103
104         /** 
105                 call from Scene Graph Node to 'update'.
106         */
107         virtual bool    SynchronizeMotionStates(float time);
108
109                 // clientinfo for raycasts for example
110         virtual void*                           getClientInfo() { return m_clientInfo;}
111         virtual void                            setClientInfo(void* clientinfo) {m_clientInfo = clientinfo;};
112         void*                                           m_clientInfo;
113
114
115         float   getFriction() { return m_friction;}
116         float   getRestitution() { return m_restitution;}
117
118         // sumo callback
119         virtual void do_me();
120
121         class SM_Object*        GetSumoObject ()
122         {
123                 return m_sumoObj;
124         };
125
126         void GetWorldOrientation(class MT_Matrix3x3& mat);
127         void GetWorldPosition(MT_Point3& pos);
128         void GetWorldScaling(MT_Vector3& scale);
129
130
131 //      void    SetSumoObject(class SM_Object* sumoObj) {
132 //              m_sumoObj = sumoObj;
133 //      }
134 //      void    SetSumoScene(class SM_Scene* sumoScene) {
135 //              m_sumoScene = sumoScene;
136 //      }
137
138         void    setSumoTransform(bool nondynaonly);
139
140
141 private:
142         class SM_Object*        m_sumoObj;
143         class SM_Scene*         m_sumoScene; // needed for replication
144         DT_SceneHandle          m_solidscene;
145         bool                            m_bFirstTime;
146         bool                            m_bDyna;
147
148         float                                           m_friction;
149         float                                           m_restitution;
150
151
152         bool                                            m_suspendDynamics;
153
154         bool                                            m_firstTime;
155         bool                                            m_bFullRigidBody;
156         bool                                            m_bPhantom;                             // special flag for objects that are not affected by physics 'resolver'
157
158         // data to calculate fake velocities for kinematic objects (non-dynas)
159         bool                                            m_bKinematic;
160         bool                                            m_bPrevKinematic;
161         
162         float                                           m_lastTime;
163
164         class   PHY_IMotionState*                       m_MotionState;
165         
166 };
167
168 #endif //__SUMO_PHYSICSCONTROLLER_H
169