fixed spacing in the headers to get rid of some warnings and some other
[blender.git] / source / gameengine / Physics / Sumo / Fuzzics / include / SM_Object.h
1 #ifndef SM_OBJECT_H
2 #define SM_OBJECT_H
3
4 #include <vector>
5
6 #include "solid.h"
7
8 #include "SM_Callback.h"
9 #include "SM_MotionState.h"
10 #include <stdio.h>
11
12
13 class SM_FhObject;
14
15
16 // Properties of dynamic objects
17 struct SM_ShapeProps {
18         MT_Scalar  m_mass;                  // Total mass
19         MT_Scalar  m_inertia;               // Inertia, should be a tensor some time 
20         MT_Scalar  m_lin_drag;              // Linear drag (air, water) 0 = concrete, 1 = vacuum 
21         MT_Scalar  m_ang_drag;              // Angular drag
22         MT_Scalar  m_friction_scaling[3];   // Scaling for anisotropic friction. Component in range [0, 1]   
23         bool       m_do_anisotropic;        // Should I do anisotropic friction? 
24         bool       m_do_fh;                 // Should the object have a linear Fh spring?
25         bool       m_do_rot_fh;             // Should the object have an angular Fh spring?
26 };
27
28
29 // Properties of collidable objects (non-ghost objects)
30 struct SM_MaterialProps {
31         MT_Scalar m_restitution;           // restitution of energie after a collision 0 = inelastic, 1 = elastic
32         MT_Scalar m_friction;              // Coulomb friction (= ratio between the normal en maximum friction force)
33         MT_Scalar m_fh_spring;             // Spring constant (both linear and angular)
34         MT_Scalar m_fh_damping;            // Damping factor (linear and angular) in range [0, 1]
35         MT_Scalar m_fh_distance;           // The range above the surface where Fh is active.    
36         bool      m_fh_normal;             // Should the object slide off slopes?
37 };
38
39
40 class SM_Object : public SM_MotionState {
41 public:
42     SM_Object() ;
43     SM_Object(
44                 DT_ShapeHandle shape, 
45                 const SM_MaterialProps *materialProps,
46                 const SM_ShapeProps *shapeProps,
47                 SM_Object *dynamicParent
48         );
49         
50     virtual ~SM_Object();
51
52         bool isDynamic() const;  
53
54         /* nzc experimental. There seem to be two places where kinematics
55          * are evaluated: proceedKinematic (called from SM_Scene) and
56          * proceed() in this object. I'll just try and bunge these out for
57          * now.  */
58
59         void suspend(void);
60         void resume(void);
61
62         void suspendDynamics();
63         
64         void restoreDynamics();
65         
66         bool isGhost() const;
67
68         void suspendMaterial();
69         
70         void restoreMaterial();
71         
72         SM_FhObject *getFhObject() const;
73         
74         void registerCallback(SM_Callback& callback);
75
76         void calcXform();
77         void notifyClient();
78     
79         // Save the current state information for use in the 
80         // velocity computation in the next frame.  
81
82         void proceedKinematic(MT_Scalar timeStep);
83
84         void saveReactionForce(MT_Scalar timeStep) ;
85         
86         void clearForce() ;
87
88     void clearMomentum() ;
89
90     void setMargin(MT_Scalar margin) ;
91
92     MT_Scalar getMargin() const ;
93
94     const SM_MaterialProps *getMaterialProps() const ;
95
96         const SM_ShapeProps *getShapeProps() const ;
97
98     void setPosition(const MT_Point3& pos);
99     void setOrientation(const MT_Quaternion& orn);
100     void setScaling(const MT_Vector3& scaling);
101
102
103         /**
104          * set an external velocity. This velocity complements
105          * the physics velocity. So setting it does not override the
106          * physics velocity. It is your responsibility to clear 
107          * this external velocity. This velocity is not subject to 
108          * friction or damping.
109          */
110
111
112     void setExternalLinearVelocity(const MT_Vector3& lin_vel) ;
113         void addExternalLinearVelocity(const MT_Vector3& lin_vel) ;
114
115         /** Override the physics velocity */
116
117     void addLinearVelocity(const MT_Vector3& lin_vel);
118         void setLinearVelocity(const MT_Vector3& lin_vel);
119
120         /**
121          * Set an external angular velocity. This velocity complemetns
122          * the physics angular velocity so does not override it. It is
123          * your responsibility to clear this velocity. This velocity
124          * is not subject to friction or damping.
125          */
126
127     void setExternalAngularVelocity(const MT_Vector3& ang_vel) ;
128     void addExternalAngularVelocity(const MT_Vector3& ang_vel);
129
130         /** Override the physics angular velocity */
131
132         void addAngularVelocity(const MT_Vector3& ang_vel);
133         void setAngularVelocity(const MT_Vector3& ang_vel);
134
135         /** Clear the external velocities */
136
137         void clearCombinedVelocities();
138
139         /** 
140          * Tell the physics system to combine the external velocity
141          * with the physics velocity. 
142          */
143
144         void resolveCombinedVelocities(
145                 const MT_Vector3 & lin_vel,
146                 const MT_Vector3 & ang_vel
147         ) ;
148
149
150
151         MT_Scalar getInvMass() const;
152
153         MT_Scalar getInvInertia() const ;
154
155     void applyForceField(const MT_Vector3& accel) ;
156
157     void applyCenterForce(const MT_Vector3& force) ;
158
159     void applyTorque(const MT_Vector3& torque) ;
160
161     void applyImpulse(const MT_Point3& attach, const MT_Vector3& impulse) ;
162
163     void applyCenterImpulse(const MT_Vector3& impulse);
164
165     void applyAngularImpulse(const MT_Vector3& impulse);
166
167     MT_Point3 getWorldCoord(const MT_Point3& local) const;
168
169         MT_Vector3 getVelocity(const MT_Point3& local) const;
170
171
172         const MT_Vector3& getReactionForce() const ;
173
174         void getMatrix(double *m) const ;
175
176         const double *getMatrix() const ;
177
178         // Still need this???
179         const MT_Transform&  getScaledTransform()  const; 
180
181         DT_ObjectHandle getObjectHandle() const ;
182         DT_ShapeHandle getShapeHandle() const ;
183
184         void  setClientObject(void *clientobj) ;
185         void *getClientObject() ;
186
187         SM_Object *getDynamicParent() ;
188
189         void integrateForces(MT_Scalar timeStep);
190         void integrateMomentum(MT_Scalar timeSteo);
191
192         void setRigidBody(bool is_rigid_body) ;
193
194         bool isRigidBody() const ;
195
196
197         // This is the callback for handling collisions of dynamic objects
198         static 
199                 void 
200         boing(
201                 void *client_data,  
202                 void *object1,
203                 void *object2,
204                 const DT_CollData *coll_data
205         );
206
207 private:
208
209         // return the actual linear_velocity of this object this 
210         // is the addition of m_combined_lin_vel and m_lin_vel.
211
212         const 
213                 MT_Vector3
214         actualLinVelocity(
215         ) const ;
216
217         const 
218                 MT_Vector3
219         actualAngVelocity(
220         ) const ;
221
222         typedef std::vector<SM_Callback *> T_CallbackList;
223
224
225     T_CallbackList          m_callbackList;    // Each object can have multiple callbacks from the client (=game engine)
226         SM_Object              *m_dynamicParent;   // Collisions between parent and children are ignored
227
228     // as the collision callback now has only information
229         // on an SM_Object, there must be a way that the SM_Object client
230         // can identify it's clientdata after a collision
231         void                   *m_client_object;
232
233     DT_ShapeHandle          m_shape;                 // Shape for collision detection
234
235         // Material and shape properties are not owned by this class.
236
237         const SM_MaterialProps *m_materialProps;         
238         const SM_MaterialProps *m_materialPropsBackup;   // Backup in case the object temporarily becomes a ghost.
239         const SM_ShapeProps    *m_shapeProps;           
240         const SM_ShapeProps    *m_shapePropsBackup;      // Backup in case the object's dynamics is temporarily suspended
241     DT_ObjectHandle         m_object;                // A handle to the corresponding object in SOLID.
242         MT_Scalar               m_margin;                // Offset for the object's shape (also for collision detection)
243         MT_Vector3              m_scaling;               // Non-uniform scaling of the object's shape
244
245         double                  m_ogl_matrix[16];        // An OpenGL-type 4x4 matrix      
246         MT_Transform            m_xform;                 // The object's local coordinate system
247         MT_Transform            m_prev_xform;            // The object's local coordinate system in the previous frame
248         SM_MotionState          m_prev_state;            // The object's motion state in the previous frame
249         MT_Scalar               m_timeStep;              // The duration of the last frame 
250
251         MT_Vector3              m_reaction_impulse;      // The accumulated impulse resulting from collisions
252         MT_Vector3              m_reaction_force;        // The reaction force derived from the reaction impulse   
253
254         unsigned int            m_kinematic      : 1;    // Have I been displaced (translated, rotated, scaled) in this frame? 
255         unsigned int            m_prev_kinematic : 1;    // Have I been displaced (translated, rotated, scaled) in the previous frame? 
256         unsigned int            m_is_rigid_body  : 1;    // Should friction give me a change in angular momentum?
257
258         MT_Vector3              m_lin_mom;               // Linear momentum (linear velocity times mass)
259         MT_Vector3              m_ang_mom;               // Angular momentum (angualr velocity times inertia)
260         MT_Vector3              m_force;                 // Force on center of mass (afffects linear momentum)
261         MT_Vector3              m_torque;                // Torque around center of mass (affects angualr momentum)
262
263         // Here are the values of externally set linear and angular
264         // velocity. These are updated from the outside
265         // (actuators and python) each frame and combined with the
266         // physics values. At the end of each frame (at the end of a
267         // call to proceed) they are set to zero. This allows the
268         // outside world to contribute to the velocity of an object
269         // but still have it react to physics. 
270
271         MT_Vector3                              m_combined_lin_vel;
272         MT_Vector3                              m_combined_ang_vel;
273
274         // The force and torque are the accumulated forces and torques applied by the client (game logic, python).
275
276         SM_FhObject            *m_fh_object;             // The ray object used for Fh
277         bool                    m_suspended;             // Is this object frozen?
278 };
279
280 #endif
281