Reverted incorrect merge (missing files)
[blender.git] / source / gameengine / Physics / Sumo / Fuzzics / include / SM_Object.h
index 53a791b781f0fa09f4304ecbfe918740d9f6f18b..2d748a0f251f7f014b10767af3c10d2711fcb3d9 100644 (file)
@@ -1,56 +1,94 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
 #ifndef SM_OBJECT_H
 #define SM_OBJECT_H
 
 #include <vector>
 
-#include "solid.h"
+#include <SOLID/SOLID.h>
 
 #include "SM_Callback.h"
 #include "SM_MotionState.h"
 #include <stdio.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 class SM_FhObject;
 
-
-// Properties of dynamic objects
+/** Properties of dynamic objects */
 struct SM_ShapeProps {
-       MT_Scalar  m_mass;                  // Total mass
-       MT_Scalar  m_inertia;               // Inertia, should be a tensor some time 
-       MT_Scalar  m_lin_drag;              // Linear drag (air, water) 0 = concrete, 1 = vacuum 
-       MT_Scalar  m_ang_drag;              // Angular drag
-       MT_Scalar  m_friction_scaling[3];   // Scaling for anisotropic friction. Component in range [0, 1]   
-       bool       m_do_anisotropic;        // Should I do anisotropic friction? 
-       bool       m_do_fh;                 // Should the object have a linear Fh spring?
-       bool       m_do_rot_fh;             // Should the object have an angular Fh spring?
+       MT_Scalar  m_mass;                  ///< Total mass
+       MT_Scalar  m_radius;                ///< Bound sphere size
+       MT_Vector3 m_inertia;               ///< Inertia, should be a tensor some time 
+       MT_Scalar  m_lin_drag;              ///< Linear drag (air, water) 0 = concrete, 1 = vacuum 
+       MT_Scalar  m_ang_drag;              ///< Angular drag
+       MT_Scalar  m_friction_scaling[3];   ///< Scaling for anisotropic friction. Component in range [0, 1]   
+       bool       m_do_anisotropic;        ///< Should I do anisotropic friction? 
+       bool       m_do_fh;                 ///< Should the object have a linear Fh spring?
+       bool       m_do_rot_fh;             ///< Should the object have an angular Fh spring?
 };
 
 
-// Properties of collidable objects (non-ghost objects)
+/** Properties of collidable objects (non-ghost objects) */
 struct SM_MaterialProps {
-       MT_Scalar m_restitution;           // restitution of energie after a collision 0 = inelastic, 1 = elastic
-       MT_Scalar m_friction;              // Coulomb friction (= ratio between the normal en maximum friction force)
-       MT_Scalar m_fh_spring;             // Spring constant (both linear and angular)
-       MT_Scalar m_fh_damping;            // Damping factor (linear and angular) in range [0, 1]
-       MT_Scalar m_fh_distance;           // The range above the surface where Fh is active.    
-       bool      m_fh_normal;             // Should the object slide off slopes?
+       MT_Scalar m_restitution;           ///< restitution of energy after a collision 0 = inelastic, 1 = elastic
+       MT_Scalar m_friction;              ///< Coulomb friction (= ratio between the normal en maximum friction force)
+       MT_Scalar m_fh_spring;             ///< Spring constant (both linear and angular)
+       MT_Scalar m_fh_damping;            ///< Damping factor (linear and angular) in range [0, 1]
+       MT_Scalar m_fh_distance;           ///< The range above the surface where Fh is active.    
+       bool      m_fh_normal;             ///< Should the object slide off slopes?
 };
 
+class SM_ClientObject
+{
+public:
+       SM_ClientObject() {}
+       virtual ~SM_ClientObject() {}
+       
+       virtual bool hasCollisionCallback() = 0;
+};
 
-class SM_Object : public SM_MotionState {
+/**
+ * SM_Object is an internal part of the Sumo physics engine.
+ *
+ * It encapsulates an object in the physics scene, and is responsible
+ * for calculating the collision response of objects.
+ */
+class SM_Object 
+{
 public:
-    SM_Object() ;
-    SM_Object(
+       SM_Object() ;
+       SM_Object(
                DT_ShapeHandle shape, 
                const SM_MaterialProps *materialProps,
                const SM_ShapeProps *shapeProps,
                SM_Object *dynamicParent
        );
-       
-    virtual ~SM_Object();
+       virtual ~SM_Object();
 
        bool isDynamic() const;  
 
@@ -78,6 +116,8 @@ public:
 
        void calcXform();
        void notifyClient();
+       void updateInvInertiaTensor();
+
     
        // Save the current state information for use in the 
        // velocity computation in the next frame.  
@@ -88,21 +128,20 @@ public:
        
        void clearForce() ;
 
-    void clearMomentum() ;
-
-    void setMargin(MT_Scalar margin) ;
-
-    MT_Scalar getMargin() const ;
-
-    const SM_MaterialProps *getMaterialProps() const ;
-
+       void clearMomentum() ;
+       
+       void setMargin(MT_Scalar margin) ;
+       
+       MT_Scalar getMargin() const ;
+       
+       const SM_MaterialProps *getMaterialProps() const ;
+       
        const SM_ShapeProps *getShapeProps() const ;
-
-    void setPosition(const MT_Point3& pos);
-    void setOrientation(const MT_Quaternion& orn);
-    void setScaling(const MT_Vector3& scaling);
-
-
+       
+       void setPosition(const MT_Point3& pos);
+       void setOrientation(const MT_Quaternion& orn);
+       void setScaling(const MT_Vector3& scaling);
+       
        /**
         * set an external velocity. This velocity complements
         * the physics velocity. So setting it does not override the
@@ -110,14 +149,11 @@ public:
         * this external velocity. This velocity is not subject to 
         * friction or damping.
         */
-
-
-    void setExternalLinearVelocity(const MT_Vector3& lin_vel) ;
+       void setExternalLinearVelocity(const MT_Vector3& lin_vel) ;
        void addExternalLinearVelocity(const MT_Vector3& lin_vel) ;
 
        /** Override the physics velocity */
-
-    void addLinearVelocity(const MT_Vector3& lin_vel);
+       void addLinearVelocity(const MT_Vector3& lin_vel);
        void setLinearVelocity(const MT_Vector3& lin_vel);
 
        /**
@@ -126,24 +162,20 @@ public:
         * your responsibility to clear this velocity. This velocity
         * is not subject to friction or damping.
         */
-
-    void setExternalAngularVelocity(const MT_Vector3& ang_vel) ;
-    void addExternalAngularVelocity(const MT_Vector3& ang_vel);
+       void setExternalAngularVelocity(const MT_Vector3& ang_vel) ;
+       void addExternalAngularVelocity(const MT_Vector3& ang_vel);
 
        /** Override the physics angular velocity */
-
        void addAngularVelocity(const MT_Vector3& ang_vel);
        void setAngularVelocity(const MT_Vector3& ang_vel);
 
        /** Clear the external velocities */
-
        void clearCombinedVelocities();
 
        /** 
         * Tell the physics system to combine the external velocity
         * with the physics velocity. 
         */
-
        void resolveCombinedVelocities(
                const MT_Vector3 & lin_vel,
                const MT_Vector3 & ang_vel
@@ -153,22 +185,36 @@ public:
 
        MT_Scalar getInvMass() const;
 
-       MT_Scalar getInvInertia() const ;
-
-    void applyForceField(const MT_Vector3& accel) ;
-
-    void applyCenterForce(const MT_Vector3& force) ;
-
-    void applyTorque(const MT_Vector3& torque) ;
-
-    void applyImpulse(const MT_Point3& attach, const MT_Vector3& impulse) ;
-
-    void applyCenterImpulse(const MT_Vector3& impulse);
-
-    void applyAngularImpulse(const MT_Vector3& impulse);
-
-    MT_Point3 getWorldCoord(const MT_Point3& local) const;
+       const MT_Vector3& getInvInertia() const ;
+       
+       const MT_Matrix3x3& getInvInertiaTensor() const;
 
+       void applyForceField(const MT_Vector3& accel) ;
+       
+       void applyCenterForce(const MT_Vector3& force) ;
+       
+       void applyTorque(const MT_Vector3& torque) ;
+       
+       /**
+        * Apply an impulse to the object.  The impulse will be split into
+        * angular and linear components.
+        * @param attach point to apply the impulse to (in world coordinates)
+        */
+       void applyImpulse(const MT_Point3& attach, const MT_Vector3& impulse) ;
+       
+       /**
+        * Applies an impulse through the center of this object. (ie the angular
+        * velocity will not change.
+        */
+       void applyCenterImpulse(const MT_Vector3& impulse);
+       /**
+        * Applies an angular impulse.
+        */
+       void applyAngularImpulse(const MT_Vector3& impulse);
+       
+       MT_Point3 getWorldCoord(const MT_Point3& local) const;
+       MT_Point3 getLocalCoord(const MT_Point3& world) const;
+    
        MT_Vector3 getVelocity(const MT_Point3& local) const;
 
 
@@ -184,9 +230,6 @@ public:
        DT_ObjectHandle getObjectHandle() const ;
        DT_ShapeHandle getShapeHandle() const ;
 
-       void  setClientObject(void *clientobj) ;
-       void *getClientObject() ;
-
        SM_Object *getDynamicParent() ;
 
        void integrateForces(MT_Scalar timeStep);
@@ -196,10 +239,9 @@ public:
 
        bool isRigidBody() const ;
 
-
        // This is the callback for handling collisions of dynamic objects
        static 
-               void 
+               DT_Bool 
        boing(
                void *client_data,  
                void *object1,
@@ -207,7 +249,52 @@ public:
                const DT_CollData *coll_data
        );
 
+       static 
+               DT_Bool 
+       fix(
+               void *client_data,  
+               void *object1,
+               void *object2,
+               const DT_CollData *coll_data
+       );
+       
+       
+       SM_ClientObject *getClientObject() { return m_client_object; }
+       void setClientObject(SM_ClientObject *client_object) { m_client_object = client_object; }
+       void    setPhysicsClientObject(void* physicsClientObject)
+       {
+               m_physicsClientObject = physicsClientObject;
+       }
+       void*   getPhysicsClientObject() {
+               return m_physicsClientObject;
+       }
+       void relax();
+       
+       SM_MotionState &getCurrentFrame();
+       SM_MotionState &getPreviousFrame();
+       SM_MotionState &getNextFrame();
+       
+       const SM_MotionState &getCurrentFrame()   const;
+       const SM_MotionState &getPreviousFrame()  const;
+       const SM_MotionState &getNextFrame()      const;
+
+       // Motion state functions       
+       const MT_Point3&     getPosition()        const;
+       const MT_Quaternion& getOrientation()     const;
+       const MT_Vector3&    getLinearVelocity()  const;
+       const MT_Vector3&    getAngularVelocity() const;
+       
+       MT_Scalar            getTime()            const;
+       
+       void setTime(MT_Scalar time);
+       
+       void interpolate(MT_Scalar timeStep);
+       void endFrame();
+       
 private:
+       friend class Contact;
+       // Tweak parameters
+       static MT_Scalar ImpulseThreshold;
 
        // return the actual linear_velocity of this object this 
        // is the addition of m_combined_lin_vel and m_lin_vel.
@@ -221,19 +308,30 @@ private:
                MT_Vector3
        actualAngVelocity(
        ) const ;
+       
+       void dynamicCollision(const MT_Point3 &local2, 
+               const MT_Vector3 &normal, 
+               MT_Scalar dist, 
+               const MT_Vector3 &rel_vel,
+               MT_Scalar restitution,
+               MT_Scalar friction_factor,
+               MT_Scalar invMass
+       );
 
        typedef std::vector<SM_Callback *> T_CallbackList;
 
 
-    T_CallbackList          m_callbackList;    // Each object can have multiple callbacks from the client (=game engine)
+       T_CallbackList          m_callbackList;    // Each object can have multiple callbacks from the client (=game engine)
        SM_Object              *m_dynamicParent;   // Collisions between parent and children are ignored
 
     // as the collision callback now has only information
        // on an SM_Object, there must be a way that the SM_Object client
        // can identify it's clientdata after a collision
-       void                   *m_client_object;
+       SM_ClientObject        *m_client_object;
+       
+       void*                                   m_physicsClientObject;
 
-    DT_ShapeHandle          m_shape;                 // Shape for collision detection
+       DT_ShapeHandle          m_shape;                 // Shape for collision detection
 
        // Material and shape properties are not owned by this class.
 
@@ -241,7 +339,7 @@ private:
        const SM_MaterialProps *m_materialPropsBackup;   // Backup in case the object temporarily becomes a ghost.
        const SM_ShapeProps    *m_shapeProps;           
        const SM_ShapeProps    *m_shapePropsBackup;      // Backup in case the object's dynamics is temporarily suspended
-    DT_ObjectHandle         m_object;                // A handle to the corresponding object in SOLID.
+       DT_ObjectHandle         m_object;                // A handle to the corresponding object in SOLID.
        MT_Scalar               m_margin;                // Offset for the object's shape (also for collision detection)
        MT_Vector3              m_scaling;               // Non-uniform scaling of the object's shape
 
@@ -254,14 +352,14 @@ private:
        MT_Vector3              m_reaction_impulse;      // The accumulated impulse resulting from collisions
        MT_Vector3              m_reaction_force;        // The reaction force derived from the reaction impulse   
 
-       unsigned int            m_kinematic      : 1;    // Have I been displaced (translated, rotated, scaled) in this frame? 
-       unsigned int            m_prev_kinematic : 1;    // Have I been displaced (translated, rotated, scaled) in the previous frame? 
-       unsigned int            m_is_rigid_body  : 1;    // Should friction give me a change in angular momentum?
-
        MT_Vector3              m_lin_mom;               // Linear momentum (linear velocity times mass)
        MT_Vector3              m_ang_mom;               // Angular momentum (angualr velocity times inertia)
        MT_Vector3              m_force;                 // Force on center of mass (afffects linear momentum)
-       MT_Vector3              m_torque;                // Torque around center of mass (affects angualr momentum)
+       MT_Vector3              m_torque;                // Torque around center of mass (affects angular momentum)
+       
+       SM_MotionState          m_frames[3];             
+       
+       MT_Vector3              m_error;                 // Error in position:- amount object must be moved to prevent intersection with scene
 
        // Here are the values of externally set linear and angular
        // velocity. These are updated from the outside
@@ -278,6 +376,17 @@ private:
 
        SM_FhObject            *m_fh_object;             // The ray object used for Fh
        bool                    m_suspended;             // Is this object frozen?
+       
+       // Mass properties
+       MT_Scalar               m_inv_mass;              // 1/mass
+       MT_Vector3              m_inv_inertia;           // [1/inertia_x, 1/inertia_y, 1/inertia_z]
+       MT_Matrix3x3            m_inv_inertia_tensor;    // Inverse Inertia Tensor
+       
+       bool                    m_kinematic;             // Have I been displaced (translated, rotated, scaled) in this frame? 
+       bool                    m_prev_kinematic;        // Have I been displaced (translated, rotated, scaled) in the previous frame? 
+       bool                    m_is_rigid_body;         // Should friction give me a change in angular momentum?
+       int                     m_static;                // temporarily static.
+
 };
 
 #endif