TAPsModelForInstrument.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsModelForInstrument.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (08/06/2008)
UPDATE          (09/03/2010)
******************************************************************************/
#include "TAPsModelForInstrument.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
template <typename T> int ModelForInstrument<T>::m_iTotal = 0;

//-----------------------------------------------------------------------------
template <typename T>
ModelForInstrument<T>::ModelForInstrument (
        std::string data_location,      
        enum ModelType,                 
        T Kpointmass,                   
        T Kstiffness,                   
        T Kdamper,                      
        T HomeKstiffness,               
        T HomeKdamper,                  
        T predefinedTimeStep,           
        int numSimSubSteps              

)
    : m_iId( m_iTotal++ ),
      m_strName( "" ),
      m_strDataLocation( data_location ),
      m_tPtMass( Kpointmass ),
      m_tKStiffness( Kstiffness ),
      m_tKDamper( Kdamper ),
      m_tHomeKStiffness( HomeKstiffness ),
      m_tHomeKDamper( HomeKdamper ),
      m_OperationFlags( SIMULATION_ON | COLLISION_ON | RENDER_ON ),
      m_tPredefinedTimeStep( predefinedTimeStep ),
      m_iNumSimSubSteps( numSimSubSteps )
{}

//-----------------------------------------------------------------------------
template <typename T>
ModelForInstrument<T>::~ModelForInstrument ()
{
    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();
    while ( pos != m_Parts.end() ) {
        delete (*pos);
        ++pos;
    }
    m_Parts.clear();
}

//-----------------------------------------------------------------------------
template <typename T>
std::string ModelForInstrument<T>::StrInfo () const
{
    std::ostringstream ss;
    ss << "ModelForInstrument<" << typeid(T).name() << ">";
    return ss.str();
}

//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::ApplyAndResetTransform ()
{
    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();
    while ( pos != m_Parts.end() ) {
        (*pos)->GetTransform().SetMatrixTransform( GetTransform().GetMatrixTransform() * (*pos)->GetTransform().GetMatrixTransform() );
        (*pos)->ApplyAndResetTransform();
        ++pos;
    }
    // Set Transformation to Identity Matrix
    GetTransform().MakeIdentity();
}

//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::SetOperationFlag ( enum Operation flag )
{
    m_OperationFlags.SetFlag( flag );
    //if ( flag & SIMULATION_ON ) {}
    if ( flag & COLLISION_ON ) {
    }
    //if ( flag & RENDER_ON ) {}
}

//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::ClearOperationFlag ( enum Operation flag )
{
    m_OperationFlags.ClearFlag( flag );
    //if ( flag & SIMULATION_ON ) {}
    //if ( flag & COLLISION_ON ) {
    //  for ( int i = 0; i < static_cast<int>( m_Parts.size() ); ++i ) {
    //      for ( int p = 0; p < static_cast<int>( m_Parts[i].GetListOfParts().size() ); ++p ) {
    //          m_Parts[i].GetListOfParts()[p];
    //      }
    //  }
    //}
    //if ( flag & RENDER_ON ) {}
}


//=============================================================================
// For Simulation
//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::AdvanceSimulation ( T tCurrent, T tNext )
{
    if ( CheckOperationFlag( SIMULATION_ON ) == false ) return;
    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();
    while ( pos != m_Parts.end() ) {
        (*pos)->AdvanceSimulation( tCurrent, tNext );
        ++pos;
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::AdvanceSimulation ( T tCurrent )
{
    if ( CheckOperationFlag( SIMULATION_ON ) == false ) return;
    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();
    while ( pos != m_Parts.end() ) {
        (*pos)->AdvanceSimulation( tCurrent );
        ++pos;
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::AdvanceSimulation ( Simulation::SimClock<T> & simClock )
{
    if ( CheckOperationFlag( SIMULATION_ON ) == false ) return;
    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();
    while ( pos != m_Parts.end() ) {
        (*pos)->AdvanceSimulation( simClock );
        ++pos;
    }
}
//-----------------------------------------------------------------------------


//=============================================================================
// For Collision Detection
//-----------------------------------------------------------------------------
template <typename T>
bool ModelForInstrument<T>::CDR ( 
        TAPs::BoundingVolume<T> const * const pBVObj    
        , TAPs::Vector3<T> * totalForce = NULL          
        , T gain = 1.0                                  
)
{
    if ( CheckOperationFlag( COLLISION_ON ) == false )  return false;

    TAPs::Vector3<T> force( 0, 0, 0 );
    bool result = false;

    std::cout << "ModelForInstrument<T>::CDR with an BV object -- NOT TESTED YET!\n";

    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();

    while ( pos != m_Parts.end() ) {
        // Store the transformation of the part
        TransformationSupport<T> trx( (*pos)->GetTransform() );
        // Apply the model's transformation on the part
        (*pos)->GetTransform().SetMatrixTransform( m_Transform.GetMatrixTransform() * trx.GetMatrixTransform() );
        // Collision Detection and Response
        if ( TAPs::CD::Fn::CDR_PolygonalMesh_vs_BV<T>( *pos, pBVObj, &force, gain ) ) {
            if ( totalForce )   *totalForce += force;
            result = true;
        }
        // Restore the transformation of the part
        (*pos)->SetTransform( trx );
        ++pos;
    }

    return result;
}
//-----------------------------------------------------------------------------
template <typename T>
bool ModelForInstrument<T>::CDR ( 
        TAPs::MultiBoundingVolume<T> const * const pMBVObj  
        , TAPs::Vector3<T> * totalForce = NULL              
        , T gain = 1.0                                      
)
{
    if ( CheckOperationFlag( COLLISION_ON ) == false )  return false;

    TAPs::Vector3<T> force( 0, 0, 0 );
    bool result = false;

    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();

    while ( pos != m_Parts.end() ) {
        // Store the transformation of the part
        TransformationSupport<T> trx( (*pos)->GetTransform() );
        // Apply the model's transformation on the part
        (*pos)->GetTransform().SetMatrixTransform( m_Transform.GetMatrixTransform() * trx.GetMatrixTransform() );
        // Collision Detection and Response
        if ( TAPs::CD::Fn::CDR_PolygonalMesh_vs_MBV<T>( *pos, pMBVObj, &force, gain ) ) {
            if ( totalForce )   *totalForce += force;
            result = true;
        }
        // Restore the transformation of the part
        (*pos)->SetTransform( trx );
        ++pos;
    }
    *totalForce = (m_Transform.GetMatrixTransform().GetInverse() * Vector4<T>( *totalForce )).GetVector3();
    totalForce->SetXYZ( 0, 0, 0 );

    return result;
}
//-----------------------------------------------------------------------------
template <typename T>
bool ModelForInstrument<T>::CDR ( 
        ModelForInstrument<T> * const pModel,   
        T deformRatio = 0.5                 
)
{
    std::cout << __FILE__ << " " << __LINE__ << " Fn: CDR(...) -- NOT IMPLEMENTED YET!\n";
    return false;
}
//-----------------------------------------------------------------------------

#if defined(__gl_h_) || defined(__GL_H__)
//-----------------------------------------------------------------------------
template <typename T>
void ModelForInstrument<T>::DisplayGL ( OpenGL::Enum::DrawMode DM )
{
    if ( CheckOperationFlag( RENDER_ON ) == false ) return;

    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * >::iterator pos = m_Parts.begin();

    glPushMatrix();
    GetTransform().TransformByOpenGLForDrawing();
    while ( pos != m_Parts.end() ) {
        (*pos)->DisplayGL( DM );
        ++pos;
    }
    glPopMatrix();
}

#else   // OpenGL
#endif  // OpenGL
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----