I'll break this commit into two sections in the moto files
[blender-staging.git] / source / gameengine / Physics / Sumo / SumoPhysicsController.h
1 /**
2  * @file $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  *      Sumo uses the SOLID library for collision detection.
46  */
47 class SumoPhysicsController : public PHY_IPhysicsController , public SM_Callback
48
49                                                          
50 {
51
52
53 public:
54         SumoPhysicsController(
55                                 class SM_Scene* sumoScene,
56                                 class SM_Object* sumoObj,
57                                 class PHY_IMotionState* motionstate,
58                                 bool dyna); 
59
60         virtual ~SumoPhysicsController();
61         
62         /** 
63          * @name Kinematic Methods.
64          */
65         /*@{*/
66         virtual void            RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local);
67         /**
68          * @param drot a 3x4 matrix.  This will treated as a 3x3 rotation matrix.
69          * @warning RelativeRotate expects a 3x4 matrix.  The fourth column is padding.
70          */
71         virtual void            RelativeRotate(const float drot[12],bool local);
72         virtual void            getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal);
73         virtual void            setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal);
74         virtual void            setPosition(float posX,float posY,float posZ);
75         virtual void            getPosition(PHY__Vector3&       pos) const;
76
77         virtual void            setScaling(float scaleX,float scaleY,float scaleZ);
78         /*@}*/
79         
80         /**
81          * @name Physics Methods
82          */
83         /*@{*/
84         virtual void            ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local);
85         virtual void            ApplyForce(float forceX,float forceY,float forceZ,bool local);
86         virtual void            SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local);
87         virtual void            SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local);
88         virtual void            resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
89         virtual void            applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ);
90         virtual void            SetActive(bool active){};
91         virtual void            SuspendDynamics();
92         virtual void            RestoreDynamics();
93         /*@}*/
94
95
96         /**  
97          *      reading out information from physics
98          */
99         virtual void            GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
100         /** 
101          *      GetVelocity parameters are in geometric coordinates (Origin is not center of mass!).
102          */
103         virtual void            GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
104         virtual float           getMass();
105         virtual void            getReactionForce(float& forceX,float& forceY,float& forceZ);
106         virtual void            setRigidBody(bool rigid);
107                 
108         
109         virtual void            PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl);
110         
111         // TODO: remove next line !
112         virtual void                    SetSimulatedTime(float time);
113         
114         virtual void            WriteDynamicsToMotionState() {};
115         virtual void    WriteMotionStateToDynamics(bool nondynaonly);
116
117         /** 
118          *      call from Scene Graph Node to 'update'.
119          */
120         virtual bool    SynchronizeMotionStates(float time);
121
122         virtual void    calcXform();
123         virtual void SetMargin(float margin) ;
124         virtual float GetMargin() const;
125         virtual float GetRadius() const ;
126
127
128         // clientinfo for raycasts for example
129         virtual void*                           getNewClientInfo();
130         virtual void                            setNewClientInfo(void* clientinfo);
131         
132         float   getFriction() { return m_friction;}
133         float   getRestitution() { return m_restitution;}
134
135         /**
136          * Sumo callback
137          */
138         virtual void do_me();
139
140         class SM_Object*        GetSumoObject ()
141         {
142                 return m_sumoObj;
143         };
144
145         void GetWorldOrientation(class MT_Matrix3x3& mat);
146         void GetWorldPosition(MT_Point3& pos);
147         void GetWorldScaling(MT_Vector3& scale);
148
149
150 //      void    SetSumoObject(class SM_Object* sumoObj) {
151 //              m_sumoObj = sumoObj;
152 //      }
153 //      void    SetSumoScene(class SM_Scene* sumoScene) {
154 //              m_sumoScene = sumoScene;
155 //      }
156
157         void    setSumoTransform(bool nondynaonly);
158
159
160 private:
161         class SM_Object*                m_sumoObj;
162         class SM_Scene*                 m_sumoScene; // needed for replication
163         bool                            m_bFirstTime;
164         bool                            m_bDyna;
165
166         float                           m_friction;
167         float                           m_restitution;
168
169
170         bool                            m_suspendDynamics;
171
172         bool                            m_firstTime;
173         bool                            m_bFullRigidBody;
174         bool                            m_bPhantom;                             // special flag for objects that are not affected by physics 'resolver'
175
176         // data to calculate fake velocities for kinematic objects (non-dynas)
177         bool                            m_bKinematic;
178         bool                            m_bPrevKinematic;
179         
180         float                           m_lastTime;
181
182         class   PHY_IMotionState*       m_MotionState;
183         
184         
185 };
186
187 #endif //__SUMO_PHYSICSCONTROLLER_H
188