TAPsPhysicsSupport.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsPhysicsSupport.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (04/25/2005)
UPDATE          (12/03/2010)
******************************************************************************/
#ifndef TAPs_PHYSICS_SUPPORT_HPP
#define TAPs_PHYSICS_SUPPORT_HPP

#include "../Core/TAPsLib.hpp"
//#include "../Math/TAPsListOfODESolvers.hpp"   // For ODE Solvers

BEGIN_NAMESPACE_TAPs
//=============================================================================
template <typename T>
class PhysicsSupport {

    // Friend Function
    friend std::ostream & operator<< ( std::ostream &output, PhysicsSupport<T> const &P )
    {
        return output << P.StrInfo();
    }

// Member Functions -----------------------------------------------------------
public:

    PhysicsSupport ();

    PhysicsSupport ( const PhysicsSupport<T> & orig );

    virtual ~PhysicsSupport ();

    virtual std::string StrInfo () const;

    inline PhysicsSupport<T> & operator= ( PhysicsSupport<T> const & orig );

    //=========================================================================
    // Get/Set Fns for (Dynamics) Physical Properties
    //-------------------------------------------------------------------------

    virtual T GetPhyPropElasticity () const { return mPhyProp_tElasticity; }
    virtual void SetPhyPropElasticity ( T elasticValue )    { mPhyProp_tElasticity = elasticValue; }

    virtual T GetPhyPropMass () const   { return mPhyProp_tMass; }
    virtual void SetPhyPropMass ( T massValue ) { mPhyProp_tMass = massValue; }

    virtual T GetPhyPropVolume () const { return mPhyProp_tVolume; }
    virtual void SetPhyPropVolume ( T volumeValue ) { mPhyProp_tVolume = volumeValue; }

    virtual Vector3<T> const &  GetPhyPropCenterOfMass () const { return mPhyProp_vCenterOfMass; }
    virtual void SetPhyPropCenterOfMass ( Vector3<T> const & COM )  { mPhyProp_vCenterOfMass = COM; }
    virtual void SetPhyPropCenterOfMass ( T x, T y, T z )   { mPhyProp_vCenterOfMass.SetXYZ(x,y,z); }

    virtual Quaternion<T> const &   GetPhyPropOrientation () const  { return mPhyProp_qOrientation; }
    virtual void SetPhyPropOrientation ( Quaternion<T> const & orientation )    { mPhyProp_qOrientation = orientation; }
    virtual void SetPhyPropOrientation ( T r, T i, T j, T k )   { mPhyProp_qOrientation.SetRIJK(r,i,j,k); }

    virtual Matrix3x3<T> const &    GetPhyPropMomentOfInertiaTensor () const    { return mPhyProp_mMomentOfInertiaTensor; }
    virtual T GetPhyPropMomentOfInertiaTensor ( int row, int col ) const    { return mPhyProp_mMomentOfInertiaTensor(row,col); }
    virtual void SetPhyPropMomentOfInertiaTensor ( int row, int col, T value )  { mPhyProp_mMomentOfInertiaTensor(row,col) = value; }
    virtual void SetPhyPropMomentOfInertiaTensor ( Matrix3x3<T> const & MOI )   { mPhyProp_mMomentOfInertiaTensor = MOI; }

    virtual Matrix3x3<T> const &    GetPhyPropInvMomentOfInertiaTensor () const { return mPhyProp_mInvMomentOfInertiaTensor; }
    virtual T GetPhyPropInvMomentOfInertiaTensor ( int row, int col ) const { return mPhyProp_mInvMomentOfInertiaTensor(row,col); }
    virtual void SetPhyPropInvMomentOfInertiaTensor ( int row, int col, T value )   { mPhyProp_mInvMomentOfInertiaTensor(row,col) = value; }
    virtual void SetPhyPropInvMomentOfInertiaTensor ( Matrix3x3<T> const & InvMOI ) { mPhyProp_mInvMomentOfInertiaTensor = InvMOI; }
    
    //const Vector3<T> &    GetPhyPropLinearMomentum () const   { return mPhyProp_vLinearMomentum; }
    //void SetPhyPropLinearMomentum ( Vector3<T> const & linearMomentum )   { mPhyProp_vLinearMomentum = linearMomentum; }
    //void SetPhyPropLinearMomentum ( T x, T y, T z )   { mPhyProp_vLinearMomentum.SetXYZ(x,y,z); }

    //Vector3<T> const &    GetPhyPropAngularMomentum () const  { return mPhyProp_vAngularMomentum; }
    //void SetPhyPropAngularMomentum ( Vector3<T> const & angularMomentum )     { mPhyProp_vAngularMomentum = angularMomentum; }
    //void SetPhyPropAngularMomentum ( T x, T y, T z )  { mPhyProp_vAngularMomentum.SetXYZ(x,y,z); }
    
    virtual Vector3<T> const &  GetPhyPropLinearVelocity () const   { return mPhyProp_vLinearVelocity; }
    virtual void SetPhyPropLinearVelocity ( Vector3<T> const & linearVelocity ) { mPhyProp_vLinearVelocity = linearVelocity; }
    virtual void SetPhyPropLinearVelocity ( T x, T y, T z ) { mPhyProp_vLinearVelocity.SetXYZ(x,y,z); }
    
    virtual Vector3<T> const &  GetPhyPropAngularVelocity () const  { return mPhyProp_vAngularVelocity; }
    virtual void SetPhyPropAngularVelocity ( Vector3<T> const & angularVelocity )   { mPhyProp_vAngularVelocity = angularVelocity; }
    virtual void SetPhyPropAngularVelocity ( T x, T y, T z )    { mPhyProp_vAngularVelocity.SetXYZ(x,y,z); }

    virtual Vector3<T> const &  GetPhyPropLinearAcceleration () const   { return mPhyProp_vLinearAcceleration; }
    virtual void SetPhyPropLinearAcceleration ( Vector3<T> const & linearAcceleration ) { mPhyProp_vLinearAcceleration = linearAcceleration; }
    virtual void SetPhyPropLinearAcceleration ( T x, T y, T z ) { mPhyProp_vLinearAcceleration.SetXYZ(x,y,z); }

    virtual Vector3<T> const &  GetPhyPropAngularAcceleration () const  { return mPhyProp_vAngularAcceleration; }
    virtual void SetPhyPropAngularAcceleration ( Vector3<T> const & angularAcceleration )   { mPhyProp_vAngularAcceleration = angularAcceleration; }
    virtual void SetPhyPropAngularAcceleration ( T x, T y, T z) { mPhyProp_vAngularAcceleration.SetXYZ(x,y,z); }

    virtual Vector3<T> const &  GetPhyPropTotalForce () const { return mPhyProp_vTotalForce; }
    virtual void SetPhyPropTotalForce ( Vector3<T> const & totalForce ) { mPhyProp_vTotalForce = totalForce; }
    virtual void SetPhyPropTotalForce ( T x, T y, T z ) { mPhyProp_vTotalForce.SetXYZ(x,y,z); }

    virtual Vector3<T> const &  GetPhyPropTotalTorque () const { return mPhyProp_vTotalTorque; }
    virtual void SetPhyPropTotalTorque ( Vector3<T> const & totalTorque )   { mPhyProp_vTotalTorque = totalTorque; }
    virtual void SetPhyPropTotalTorque ( T x, T y, T z )    { mPhyProp_vTotalTorque.SetXYZ( x, y, z ); }

    virtual Vector3<T> const &  GetPhyPropDampingLinearVelocity () const    { return mPhyProp_vDampingLinearVelocity; }
    virtual void SetPhyPropDampingLinearVelocity ( Vector3<T> const & dampingLinearVelocity )   { mPhyProp_vDampingLinearVelocity = dampingLinearVelocity; }
    virtual void SetPhyPropDampingLinearVelocity ( T x, T y, T z )  { mPhyProp_vDampingLinearVelocity.SetXYZ(x,y,z); }

    virtual Vector3<T> const &  GetPhyPropDampingAngularVelocity () const   { return mPhyProp_vDampingAngularVelocity; }
    virtual void SetPhyPropDampingAngularVelocity ( Vector3<T> const & dampingAngularVelocity ) { mPhyProp_vDampingAngularVelocity = dampingAngularVelocity; }
    virtual void SetPhyPropDampingAngularVelocity ( T x, T y, T z ) { mPhyProp_vDampingAngularVelocity.SetXYZ(x,y,z); }
    
    virtual T GetPhyPropGravitationalConstant () const  { return mPhyProp_tGravitationalConstant; }
    virtual void SetPhyPropGravitationalConstant ( T g )    { mPhyProp_tGravitationalConstant = g; }
#ifdef  TAPs_ADD_RESTING_LEVEL_Y

    virtual T GetPhyPropRestingLevel () const   { return mPhyProp_tRestingLevel; }
    virtual void SetPhyPropRestingLevel ( T y ) { mPhyProp_tRestingLevel = y; }
#endif//TAPs_ADD_RESTING_LEVEL_Y
    
    //-------------------------------------------------------------------------
    // Get/Set Fns for (Dynamics) Physical Properties
    //=========================================================================


    //=========================================================================
    // Update Physical Properties_
    //-------------------------------------------------------------------------

    void ClearForce ()  { mPhyProp_vTotalForce.Clear(); }
    void ClearTorque () { mPhyProp_vTotalTorque.Clear(); }
    void ClearForceAndTorque () { mPhyProp_vTotalForce.Clear(); mPhyProp_vTotalTorque.Clear(); }
    void ClearLinearVelocity ()     { mPhyProp_vLinearVelocity.Clear(); }
    void ClearAngularVelocity ()    { mPhyProp_vAngularVelocity.Clear(); }
    void ClearLinearAcceleration ()     { mPhyProp_vLinearAcceleration.Clear(); }
    void ClearAngularAcceleration ()    { mPhyProp_vAngularAcceleration.Clear(); }

    inline virtual void AddForce ( Vector3<T> const & Force );

    inline virtual void AddTorque ( Vector3<T> const & Torque );

    inline virtual void ScaleForce ( Vector3<T> const & Scale );

    inline virtual void ScaleTorque ( Vector3<T> const & Scale );

    inline virtual void AddForceWithLocation (
        Vector3<T> const & Force,           
        Vector3<T> const & AppliedLocation  
    );

    //-------------------------------------------------------------------------
    // Update Physical Properties
    //=========================================================================


    //-------------------------------------------------------------------------
protected:
    /*
    //-------------------------------------------------------------------------
    // REMARK:  DxDt has to be static so that we can pass it to 
    // ODESolver Fn.
    // But we don't want StateToArray and ArrayToState be static.
    // Therefore, we need to pass userData, i.e. this pointer
    // as a void pointer.
    static bool DxDt (  
        T dt,                           // i/p: time step
        Simulation::VectorSet<T> &x,    // i/p: array  x = {pos, vel}
        Simulation::VectorSet<T> &xdot, // o/p: array xdot = {vel, accel}
        void *userData                  // o/p: array of user data
    );
    //-------------------------------------------------------------------------
    void StateToArray ( T *dst );       // copy Strand states to dst array
    void ArrayToState ( T *src );       // copy src array to Strand states
    void DdtStateToArray ( T *xdot, T dt ); // copy d/dt Strand states to dst 
                                            // (xdot) array
    //void ClearForces ();  // clear (all) forces (and maybe velocities too)
    //*/
//-----------------------------------------------------------------------------
// Data Members  --------------------------------------------------------------
    /*
    //=========================================================================
    // For simulation
    //-------------------------------------------------------------------------
    Simulation::ODESolver<T> *  m_prODESolver;  // ODE solver
    Simulation::VectorSet<T>    x0;             // #m_iStateSize
    Simulation::VectorSet<T>    xEnd;           // #m_iStateSize
    int                     m_iStateSize;   // #particles (or #primitives) * 6
                            // where 6 = 3 positions + 3 velocities (for x,y,z)
    int                     m_iLimitStepCount;
    //*/
    //-------------------------------------------------------------------------
    // (Dynamics) Physics Properties
    T               mPhyProp_tElasticity;       
    T               mPhyProp_tMass;             
    T               mPhyProp_tVolume;           
    Vector3<T>      mPhyProp_vCenterOfMass;     
    Quaternion<T>   mPhyProp_qOrientation;      

    Matrix3x3<T>    mPhyProp_mMomentOfInertiaTensor;    
    Matrix3x3<T>    mPhyProp_mInvMomentOfInertiaTensor; 

    //Vector3<T>        mPhyProp_vLinearMomentum;       //!< linear momentum
    //Vector3<T>        mPhyProp_vAngularMomentum;      //!< angular momentum
    Vector3<T>      mPhyProp_vLinearVelocity;       
    Vector3<T>      mPhyProp_vAngularVelocity;      
    Vector3<T>      mPhyProp_vLinearAcceleration;   
    Vector3<T>      mPhyProp_vAngularAcceleration;  

    Vector3<T>      mPhyProp_vTotalForce;       
    Vector3<T>      mPhyProp_vTotalTorque;      

    Vector3<T>      mPhyProp_vDampingLinearVelocity;    
    Vector3<T>      mPhyProp_vDampingAngularVelocity;   

    T               mPhyProp_tGravitationalConstant;    
#ifdef  TAPs_ADD_RESTING_LEVEL_Y
    T               mPhyProp_tRestingLevel;             
#endif//TAPs_ADD_RESTING_LEVEL_Y
};
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsPhysicsSupport.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----