TAPsElasticRodCD.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsElasticRodCD.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (08/21/2009)
UPDATE          (01/04/2011)
******************************************************************************/
#ifndef TAPs_ELASTIC_ROD__CD_HPP
#define TAPs_ELASTIC_ROD__CD_HPP

#include "TAPsElasticRodParameters.hpp"
#include "TAPsElasticRodNode.hpp"

// For collision detection
#include "../../CD/TAPsBVHTree.hpp"
#include "../../CD/TAPsMultiBoundingVolume.hpp" // for collision detection by bounding volumes
#include "../../CD/TAPsBVHNodeLeafElasticRodNode.hpp"
#include "../../Support/TAPsTransformationSupport.hpp"      // Has A
#include "../../OpenGLModel/TAPsHETriMeshOneModelMultiParts.hpp"
//#include "../../OpenGLModel/TAPsHalfEdgeModel.hpp"
//#include "ModelDefBasedOnFEMSupport/TAPsModelDefBasedOnFEM.hpp"

//#define   TAPs_ADD_IMPLICIT_OBJECTS

#ifdef  TAPs_ADD_IMPLICIT_OBJECTS
#include "../TAPsListOfImplicitObjects.hpp"
#endif//TAPs_ADD_IMPLICIT_OBJECTS

// For drawing by OpenGL
#if defined(__gl_h_) || defined(__GL_H__)
    #include "../../OpenGL/TAPsOpenGLObj.hpp"
#endif

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

    typedef std::vector< ElasticRodNode<T> >    SetOfElasticRodNodes;

    // Member Functions -------------------------------------------------------
    friend std::ostream & operator<< ( std::ostream &output, ElasticRodCD<T> const &obj )
    {
        output << obj.StrInfo();
        return output;
    }

public:


    // For Debugging
    Vector3<T> d_ShaftSPt, d_ShaftEPt;
    int d_NumOfWrappingLoops;
    std::vector< Vector3<T> > d_NodePositions;


    class Loop {
        Loop ( int startPt, int endpt ) : StartPt(startPt), EndPt(endPt) {}

        void CalLoopCenter ( Vector3<T> & center ) const
        {
            center = m_pNodeList[EndPt];
            for ( int i = StartPt; i < EndPt; ++i ) {
                center += m_pNodeList[i];
            }
            center /= EndPt - StartPt + 1;
        }

        int StartPt;    
        int EndPt;      
    };

public:
    //-------------------------------------------------------------------------
    ElasticRodCD ();

    //ElasticRodCD ( ElasticRodCD<T> const &obj );

    virtual ~ElasticRodCD ();

    void CreateCD (
        int *                       pIdxCurr,       
        int *                       pIdxNext,       
        ElasticRodParameters<T> *   pParameters,    
        SetOfElasticRodNodes *      pNodeList       
    );

    void DeleteCD ();

    void Reset ();

    void BuildBVHTree ();

    void UpdateBVHTree ();

    bool CDRwith (
        MultiBoundingVolume<T> * const pMBVObj,     
        TransformationSupport<T> * const pTransform 
    );

    bool CDRbySegmentsWith (
        std::vector<unsigned int> const * pSegments,    
        MultiBoundingVolume<T> * const pMBVObj,         
        TransformationSupport<T> * const pTransform     
    );


    bool CDRwithMBVforShaftLikeObject_wCheckWrappingLoops (
        MultiBoundingVolume<T> * const pMBVObj,         
        Vector3<T> * const pShaftStartPt,               
        Vector3<T> * const pShaftEndPt,                 
        T const *   pShaftRadiusOfInfluence,            
        TransformationSupport<T> * const pTransform,    
        T * pNumOfWrappingLoops,                        
        bool *  isCCW                                   
        //, std::vector<Loop> * pWrappingLoops  //!< list of formed wrapping loops
    );

    bool CDRbySegmentsWithMBVforShaftLikeObject_wCheckWrappingLoops (
        std::vector<unsigned int> const * pSegments,    
        MultiBoundingVolume<T> * const pMBVObj,         
        Vector3<T> * const pShaftStartPt,               
        Vector3<T> * const pShaftEndPt,                 
        T const *   pShaftRadiusOfInfluence,            
        TransformationSupport<T> * const pTransform,    
        T * pNumOfWrappingLoops,                        
        bool *  isCCW                                   
        //, std::vector<Loop> * pWrappingLoops  //!< list of formed wrapping loops
    );

    inline virtual bool CDRwith (
        TAPs::OpenGL::HETriMeshOneModelMultiParts<T> * pObj,    
        TransformationSupport<T> * const pTransform = NULL      
    );

    #ifdef  TAPs_ADD_IMPLICIT_OBJECTS

    bool CDRwithImplicitObject (
        ImplicitObject<T> * const pImpObj   
    );
    #endif//TAPs_ADD_IMPLICIT_OBJECTS

    inline void CDRforSelfIntersections ();

    //-------------------------------------------------------------------------
    virtual std::string StrInfo () const;

    //-------------------------------------------------------------------------
    // Operations

    BVHTree<T> * GetBVHTree ()  { return m_BVHTree; }

    // Data Members -----------------------------------------------------------
//=============================================================================
protected:
    // Member Functions -------------------------------------------------------

    BVHTree<T> * BuildBVHTreeRecursively ( 
        int startID,                    
        BVHNode<T> ** childNodeList,    
        int numOfChildNodes             
    );

    void UpdateBVHNodeRecursively ( BVHNode<T> * node );
    void CheckSelfIntersectionsNextLevelRecursively ( BVHNode<T> * node1, BVHNode<T> * node2 );
    T    CheckSelfIntersectionsRecursively ( BVHNode<T> * node1, BVHNode<T> * node2 );

    #ifdef  TAPs_ADD_IMPLICIT_OBJECTS

    void CollisionResponseWithImplicitObject_Sphere ( ImplicitObject_Sphere<T> * const pImpObj );
    void CollisionResponseWithImplicitObject_Torus ( ImplicitObject_Torus<T> * const pImpObj );
    #endif//TAPs_ADD_IMPLICIT_OBJECTS

    // Data Members -----------------------------------------------------------

    BVHTree<T> *    m_BVHTree;  

    TransformationSupport<T>    m_DummyTransform;   

    int *                       m_pIdxCurr;     
    int *                       m_pIdxNext;     
    ElasticRodParameters<T> *   m_pParameters;  
    SetOfElasticRodNodes *      m_pNodeList;    



//=============================================================================
#ifdef  TAPs_SIM_WITH_POSITION_BASED_DYNAMICS
//-----------------------------------------------------------------------------
public:
    void UpdateBVHTree_PBD ();
    inline void CDRforSelfIntersections_PBD ();
protected:
    void UpdateBVHNodeRecursively_PBD ( BVHNode<T> * node );
    void CheckSelfIntersectionsNextLevelRecursively_PBD ( BVHNode<T> * node1, BVHNode<T> * node2 );
    T    CheckSelfIntersectionsRecursively_PBD ( BVHNode<T> * node1, BVHNode<T> * node2 );
    void CollisionResponseByUpdatingGeometric_PBD (
        Vector3<T> & displacementVector,        
        BVHNodeLeafElasticRodNode<T> * Node1,   
        BVHNodeLeafElasticRodNode<T> * Node2    
    );
//-----------------------------------------------------------------------------
#endif//TAPs_SIM_WITH_POSITION_BASED_DYNAMICS
//=============================================================================



//=============================================================================
#ifdef  TAPs_ADVANCED_SELF_COLLISION_DETECTION
//-----------------------------------------------------------------------------
private:
    template <typename T>
    class SelfCDExtraData {
    public:
        SelfCDExtraData ( unsigned int linkID_A, unsigned int linkID_B, T average_radius ) 
            : LinkID_A( linkID_A ), LinkID_B( linkID_B ), AverageRadius( average_radius )
        {}

        //Vector3<T>    CalLinkCenter_A ()
        //{
        //  return ( (*m_pNodeList)[LinkID_A+1].Centerline[IdxCurr] + (*m_pNodeList)[LinkID_A].Centerline[IdxCurr] ) * T(0.5);
        //}

        //Vector3<T>    CalLinkCenter_B ()
        //{
        //  return ( (*m_pNodeList)[LinkID_B+1].Centerline[IdxCurr] + (*m_pNodeList)[LinkID_B].Centerline[IdxCurr] ) * T(0.5);
        //}

        //Vector3<T>    CalAverageLinkCenter ()
        //{
        //  return ( LinkCenter_A + LinkCenter_B ) * T(0.5);
        //}

        #if defined(__gl_h_) || defined(__GL_H__)
        void Draw () const
        {
            glPushAttrib( GL_ALL_ATTRIB_BITS );
            glDisable( GL_LIGHTING );
            glPointSize( 2 );
            glBegin( GL_POINTS );
                glColor3f( 1, 0, 0 );
                glVertex3fv( LinkCenter_A.GetDataFloat() );
                glColor3f( 0, 1, 0 );
                glVertex3fv( AverageCenter.GetDataFloat() );
                glColor3f( 0, 0, 10 );
                glVertex3fv( LinkCenter_B.GetDataFloat() );
            glEnd();
            glLineWidth( 1 );
            glBegin( GL_LINE_STRIP );
                glColor3f( 1, 0, 0 );
                glVertex3fv( LinkCenter_A.GetDataFloat() );
                glColor3f( 0, 1, 0 );
                glVertex3fv( AverageCenter.GetDataFloat() );
                glColor3f( 0, 0, 1 );
                glVertex3fv( LinkCenter_B.GetDataFloat() );
            glEnd();
            glPopAttrib();
        }
        #endif//defined(__gl_h_) || defined(__GL_H__)

        unsigned int    LinkID_A;       
        unsigned int    LinkID_B;       

        Vector3<T>  LinkCenter_A;       
        Vector3<T>  LinkCenter_B;       
        Vector3<T>  AverageCenter;      
        T           AverageRadius;      
    };

public:

    std::list< SelfCDExtraData<T> > ListOfSelfCDExtraData;  
    bool ** SelfCDExtraDataTrackStatus; 

    inline void UpdateSelfCDExtraData ();

    //inline void PreventMissedCDWithSelfCDExtraData ();

    inline void CheckAndRestoreWithSelfCDExtraData ( unsigned int nodeID );

    //int StartLinkIDofCurrentTrackedKnot;  //! start link id of the current tracked knot for adjusting self CD
    //int EndLinkIDofCurrentTrackedKnot;        //! start link id of the current tracked knot for adjusting self CD

protected:
    inline void ResetSelfCDExtraData ();

    inline bool InitSelfCDExtraData ();

    inline void DeleteSelfCDExtraData ();

    inline void AddSelfCDExtraDataForALinkPair ( unsigned int nodeID_1, unsigned int nodeID_2 );

//-----------------------------------------------------------------------------
#endif//TAPs_ADVANCED_SELF_COLLISION_DETECTION
//=============================================================================


//=============================================================================
private:
    // Member Functions -------------------------------------------------------
//=============================================================================

//OpenGL
//-----------------------------------------------------------------------------
//#define __GL_H__
//#define   TAPs_USE_GLSL
//-----------------------------------------------------------------------------
#if defined(__gl_h_) || defined(__GL_H__)
public:
    inline virtual void Draw () const;
    
    #ifdef  TAPs_ADVANCED_SELF_COLLISION_DETECTION
    inline virtual void DrawExtraSelfCDData () const;
    #else //TAPs_ADVANCED_SELF_COLLISION_DETECTION
    inline virtual void DrawExtraSelfCDData () const {};
    #endif//TAPs_ADVANCED_SELF_COLLISION_DETECTION

    //OpenGL::OpenGLObj Rendering;  //!< OpenGL Object has material color properties
#endif//defined(__gl_h_) || defined(__GL_H__)
//-----------------------------------------------------------------------------
//=============================================================================
}; // CLASS END: ElasticRodCD
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
#include "TAPsElasticRodCD.cpp"
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----