TAPsMultiMeshModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsMultiMeshModel.cpp

A collection of mesh models - 
can be any mixing of Polygonal, XPolygonal, and Halfedge Models.

SUKITTI PUNAK   (08/08/2006)
UPDATE          (08/09/2006)
******************************************************************************/
#include "TAPsMultiMeshModel.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__OpenGL
//=============================================================================
//-----------------------------------------------------------------------------
// static initialization
template <typename T> int MultiMeshModel<T>::m_iTotal = 0;
//-----------------------------------------------------------------------------
// Default Constructor
template <typename T>
MultiMeshModel<T>::MultiMeshModel ()
    : ColDetSupport<T>(), 
      PhysicsSupport<T>(), 
      m_iId( m_iTotal++ ), m_pcName( NULL )
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout   << "MultiMeshModel<" << typeid(T).name() << "> #" << m_iId << " constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Constructor
template <typename T>
MultiMeshModel<T>::MultiMeshModel (char *name)
    : //TransformationSupport<T>(), 
      m_iId( m_iTotal++ ), m_pcName( NULL )
{
    SetName( name );

    #ifdef  TAPs_DEBUG_MODE
    std::cout   << "MultiMeshModel<" << typeid(T).name() << "> #" << m_iId << " constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Destructor
template <typename T>
MultiMeshModel<T>::~MultiMeshModel ()
{
    if ( m_pcName ) {
        delete [] m_pcName;
        m_pcName = NULL;
    }
    --m_iTotal;

    #ifdef  TAPs_DEBUG_MODE
    std::cout   << "MultiMeshModel<" << typeid(T).name() << "> #" << m_iId << " destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Get/Set Fns
template <typename T>
int MultiMeshModel<T>::GetID () const
{
    return m_iId;
}
//-----------------------------------------------------------------------------
template <typename T>
void MultiMeshModel<T>::SetID ( int id )
{
    m_iId = id;
}
//-----------------------------------------------------------------------------
template <typename T>
char const * const MultiMeshModel<T>::GetName () const
{
    return m_pcName;
}
//-----------------------------------------------------------------------------
template <typename T>
void MultiMeshModel<T>::SetName ( char * name )
{
    if ( m_pcName ) {
        delete [] m_pcName;
        m_pcName = NULL;
    }
    m_pcName = new char[ strlen(name) + 1 ];
    strcpy( m_pcName, name );
}
//-----------------------------------------------------------------------------
// Initailize
template <typename T>
void MultiMeshModel<T>::Initialize ()
{
    std::vector< MeshModel<T> * >::iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->Initialize();
        ++pos;
    }
}
//******************************************************************************
// ApplyAndResetTransform
//******************************************************************************
//-----------------------------------------------------------------------------
template <typename T>
void MultiMeshModel<T>::ApplyAndResetTransform ()
{
    std::vector< MeshModel<T> * >::iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->GetTransform().SetTranslation( GetTransform().GetTranslation() );
//      (*pos)->GetTransform().SetRotationAngles( GetTransform().GetRotationAngles() );
//      (*pos)->GetTransform().SetScale( GetTransform().GetScale() );
        (*pos)->GetTransform().SetMatrixTransform( GetTransform().GetMatrixTransform() );
        (*pos)->ApplyAndResetTransform();
        ++pos;
    }
    GetTransform().MakeIdentity();
}
//-----------------------------------------------------------------------------

//******************************************************************************
// Virtual Fns from Collision Detection from ColDetSupport class
//******************************************************************************
//-----------------------------------------------------------------------------
/*
template <typename T>
void MultiMeshModel<T>::CalBoundingAABB ()
{
}
//-----------------------------------------------------------------------------
template <typename T>
void MultiMeshModel<T>::CalBoundingEllipsoid ()
{
}
//-----------------------------------------------------------------------------
template <typename T>
void MultiMeshModel<T>::CalBoundingSphere ()
{
}
//*/
//-----------------------------------------------------------------------------
// Create BVHTree
template <typename T>
void MultiMeshModel<T>::BuildBVHTree ( TAPs::Enum::CD treeType )
{
    //-----------------------------------------------------
    // Check Model Type
    for ( int i = 0; i < static_cast<int>( m_vModelPtrList.size() ); ++i ) {
        m_vModelPtrList[i]->BuildBVHTree( treeType );
    }
    //-----------------------------------------------------
}
//-----------------------------------------------------------------------------

//******************************************************************************
//-----------------------------------------------------------------------------
// Display By OpenGL
template <typename T>
void MultiMeshModel<T>::DisplayGL ( OpenGL::Enum::DrawMode DM )
{
    glPushMatrix();
    GetTransform().TransformByOpenGLForDrawing();

    std::vector< MeshModel<T> * >::iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->DisplayGL( DM );
        ++pos;
    }
    glPopMatrix();
}
//-----------------------------------------------------------------------------
// Display By OpenGL
template <typename T>
void MultiMeshModel<T>::DisplayGLUsingColorMaterial ( 
        OpenGL::Enum::DrawMode  DM, 
        OpenGL::Enum::Face      F )
{
    glPushMatrix();
    GetTransform().TransformByOpenGLForDrawing();

    glPushAttrib( GL_CURRENT_BIT | GL_LIGHTING_BIT );
    //---------------------------------------------------------------
    glEnable( GL_COLOR_MATERIAL );

    //glColorMaterial( F, GL_AMBIENT_AND_DIFFUSE );
    //glColorMaterial( F, GL_AMBIENT );
    //glColorMaterial( F, GL_DIFFUSE );
    //glColorMaterial( F, GL_SPECULAR );
    //glColorMaterial( F, GL_EMISSION );

    //static GLfloat specular[4] = { 1, 1, 1, 1 };      //<--------- Hack for Specular Highlight
    //static GLfloat diffuse[4] = { 1, 1, 1, 1 };           //<--------- Hack for Diffuse Color
    //glMaterialfv( GL_FRONT, GL_SPECULAR, specular );  //<--------- Hack for Specular Highlight
    //glMaterialfv( GL_FRONT, GL_DIFFUSE, diffuse );        //<--------- Hack for Diffuse Color
    //glMaterialfv( GL_FRONT, GL_AMBIENT, diffuse );        //<--------- Hack for Diffuse Color

    std::vector< MeshModel<T> * >::iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->GetMaterial()->ApplyRGBAColor();
        (*pos)->DisplayGL( DM );
        //(*pos)->DrawBVH();
        ++pos;
    }
    //---------------------------------------------------------------
    glPopAttrib();
    glPopMatrix();
}
//-----------------------------------------------------------------------------
// Display By OpenGL
template <typename T>
void MultiMeshModel<T>::DrawBVHOfEachMesh () const
{
    glPushMatrix();
    GetTransform().TransformByOpenGLForDrawing();

    std::vector< MeshModel<T> * >::const_iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->DrawBVH();
        ++pos;
    }

    glPopMatrix();
}
//-----------------------------------------------------------------------------
// Display By OpenGL
template <typename T>
void MultiMeshModel<T>::DrawBVHOfEachMesh ( int startLevel, int endLevel ) const
{
    glPushMatrix();
    GetTransform().TransformByOpenGLForDrawing();

    std::vector< MeshModel<T> * >::const_iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->DrawBVH( startLevel, endLevel );
        ++pos;
    }

    glPopMatrix();
}
//-----------------------------------------------------------------------------
// Display By OpenGL
template <typename T>
void MultiMeshModel<T>::DrawBVHOfEachMeshOnlyEndLevel () const
{
    glPushMatrix();
    GetTransform().TransformByOpenGLForDrawing();

    std::vector< MeshModel<T> * >::const_iterator pos = m_vModelPtrList.begin();
    while ( pos != m_vModelPtrList.end() ) {
        assert( *pos != NULL );
        (*pos)->DrawBVHOnlyEndLevel();
        ++pos;
    }

    glPopMatrix();
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8