TAPsVolPresPolygonalModel.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsVolPresPolygonalModel.hpp

A Polygonal Model that is deformable with volume preservation.

SUKITTI PUNAK   (11/11/2004)
UPDATE          (11/15/2004)
******************************************************************************/
#ifndef TAPs_VOL_PRES_POLYGONAL_MODEL_HPP
#define TAPs_VOL_PRES_POLYGONAL_MODEL_HPP

#include <ctime>
#include "TAPsXPolygonalModel.hpp"
#include "../GeometricDataStructure/TAPsEdge.hpp"
#include "../GeometricDataStructure/TAPsVertexRings.hpp"

// Physics
#include "../Physics/TAPsSpringVertex.hpp"
#include "../Physics/TAPsPhysics.hpp"   // for gravitational constant

// For finding cubic root
#include "../External/SP_Mathematics.h"

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
template <typename T>
class VolPresPolygonalModel : public /*virtual*/ XPolygonalModel<T> {
    //-------------------------------------------------------------------------
    // (Friend Fn) put it through ostream
    friend std::ostream & operator<< ( std::ostream &output, VolPresPolygonalModel<T> const &o )
    {
        output  << "\n======================\n"
                <<   "TAPs::VolPresPolygonalModel<"
                << typeid(T).name() << "> Class:\n"
                <<   "======================\n";
        //----------------------------------------------------------------
        // Vertices Node
        output  << "\n\nVertices " << o.m_iNoVertices << "\n{";
        for ( int i = 0; i < o.m_iNoVertices; ++i ) {
            output << "\n  #" << i << "\t" << o.m_prVertex[i];
        }
        output  << "\n}";
        //----------------------------------------------------------------
        // Neighbor vertex ring#1
        if ( o.m_pviVertexRing1List ) {
            std::vector<int>::const_iterator iterator;
            output  << "\n\nVertexRing1 " << o.m_iNoVertices << "\n{";
            for ( int i = 0; i < o.m_iNoVertices; ++i ) {
                output << "\n  #" << i;
                for (   iterator = o.m_pviVertexRing1List[i].begin(); 
                        iterator != o.m_pviVertexRing1List[i].end();
                        ++iterator )
                {
                    output << "\t" << *iterator;
                }
            }
            output  << "\n}";
        }
        //----------------------------------------------------------------
        // Faces Node
        output  << "\n\nFaces " << o.m_iNoFaces  << "\n{";
        for ( int i = 0; i < o.m_iNoFaces; ++i ) {
            output << "\n  #" << i << "\t" << o.m_prFace[i];
        }
        output  << "\n}";
        return output;
    }
//-----------------------------------------------------------------------------
// Member Functions ------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    // default constructor
    VolPresPolygonalModel ();
    //-------------------------------------------------------------------------
    // destructor
    virtual ~VolPresPolygonalModel ();
    //-------------------------------------------------------------------------
    // Virtual Fns from XPolygonalModel class which from Model class
    virtual void Initialize ();
    virtual void ApplyAndResetTransform ();
    //-------------------------------------------------------------------------
    // Get/Set Fn(s)
    inline int  GetDeformedFaceNo () const  
    {
        std::cout << "Deformed Face#: " << m_iDeformedFaceNo << "\n";
        return m_iDeformedFaceNo;
    }
    inline void SetDeformedFaceNo ( int faceNo )
    {
        m_iDeformedFaceNo = faceNo;
        std::cout << "Deformed Face#: " << m_iDeformedFaceNo << "\n";
    }
    inline int  GetNoEdges () const { return m_iNoEdges; }
    inline void SetNoEdges ( int n )    { m_iNoEdges = n; }
    inline T GetVolume() { return m_tVolume; }
    inline Vector3<T> GetCentroid() { return m_vtCentroid; }
    //-------------------------------------------------------------------------
    // Toggle Modes
    inline void ToggleVolumePreservationMode () { m_bFlagVolPresMode = !m_bFlagVolPresMode; }
    inline void ToggleSpringForceMode () { m_bFlagSpringForceMode = !m_bFlagSpringForceMode; }
protected:
    inline Edge const * const GetEdgeList() const { return m_prEdge; }
    inline void SetEdgeList( Edge *p )      { m_prEdge = p; }
protected:
    //-------------------------------------------------------------------------
    // Find Edge List
    void DetermineEdgeList ();
    //-------------------------------------------------------------------------
    // Particles and Springs
    void CreateParticleVerticesFromVertices ();
    void CreateSpringVerticesFromEdges ();
    //-------------------------------------------------------------------------
    // Volume Preservation Fn(s)
    T m_weight[4];
    virtual T CalVolume ();
    virtual T CalVolume2 ();
    virtual void PreserveVolumeByVertexNormals( T weight[4] );
    virtual void PreserveVolume ( T weight[4] );
    inline void d3mom0 ( T v[][3], T dv[][3], T wgt[4] );
    inline void DeformVertex ( int v, Vector3<T> & deformVector );
    inline void DeformVertices ( int vList[], int size, Vector3<T> & deformVector );
    //-------------------------------------------------------------------------
    // For Simulation
    void StepSimulation( T dt );
    //-------------------------------------------------------------------------
    // Calculate Forces
    /*
    void ClearForce();                      // clear force of particles to zeros
    void ForceDueToGravity( T g = SP_Physics::g );  // calculate (weight) force due to (acceleration of) gravity
    void ForceDueToViscousDamping();        // calculate (a loss) force due to viscous damping
    void ForceDueToViscousFluidMoving();    // calculate (wind)   force due to viscous fluid moving
    */
    // Calculate All Forces Acting on Particles
    void CalForces( Vector3<T> vWind = Vector3<T>(0,0,0), T g = Physics_SI::K::g );
    void AddSpringForces();     // calculate and add spring forces to particle forces
    //-------------------------------------------------------------------------
protected:
    // Volume
    T           m_tVolume;      // Volume of this object
    Vector3<T>  m_vtCentroid;   // Centroid of this object
    int         m_iNoEdges;     // Number of Edges
    Edge *      m_prEdge;       // Edge pointers
    bool *      m_bFlagFixed;   // Status: Fixed/Unfixed status for each vertex
    Vector3<T> *    m_pvDeformVector;   // Deform Vector for each vertex
    int         m_iDeformedFaceNo;      // Deformed Face #
    VertexRings *   m_pcVertexRings;    // vertex rings (make ptr in case of needed more than one)

    // Calculation Modes
    bool    m_bFlagVolPresMode;         // true --> Volume is preserved
    bool    m_bFlagSpringForceMode;     // true --> Spring forces are activated

    // Spring Part
    //Particle<T>   ** m_pprParticle;   // particles to mirror the vertices
    //Spring<T> ** m_pprSpring;     // number of string is the same as number of edges
    ParticleVertex<T> ** m_pprParticleVertex;   // adding particle properties to the vertices
    SpringVertex<T> **   m_pprSpringVertex;     // number of springs is the same as number of edges
};
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsVolPresPolygonalModel.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8