TAPsPolygonalModel.cpp

Go to the documentation of this file.

/******************************************************************************
PolygonalModel.cpp

A (Generic) Polygonal Model

SUKITTI PUNAK   (10/31/2004)
UPDATE          (02/12/2006)
******************************************************************************/
#include "TAPsPolygonalModel.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
//=============================================================================
//-----------------------------------------------------------------------------
// default constructor
template <typename T>
PolygonalModel<T>::PolygonalModel ()
    : OpenGLMeshModel<T>(), m_prVertex( NULL ), m_prFace( NULL )
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "PolygonalModel<" << typeid(T).name() << "> Constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
PolygonalModel<T>::~PolygonalModel ()
{
    if ( m_prVertex != NULL ) {
        delete [] m_prVertex;
        m_prVertex = NULL;
    }
    if ( m_prFace != NULL ) {
        delete [] m_prFace;
        m_prFace = NULL;
    }

    #ifdef  TAPs_DEBUG_MODE
    std::cout << "PolygonalModel<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Initialize
template <typename T>
void PolygonalModel<T>::Initialize ()
{
    // Model Initialization
    CalAndSetNormals();
    ApplyMaterial();
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();
}
//-----------------------------------------------------------------------------
// New/Delete Fn
template <typename T>
void PolygonalModel<T>::NewVertexListByNoVertices ()
{
    if ( m_prVertex != NULL ) {
        delete [] m_prVertex;
    }
    m_prVertex = new Vertex<T>[m_iNoVertices];
}
//-----------------------------------------------------------------------------
// New/Delete Fn
template <typename T>
void PolygonalModel<T>::NewFaceListByNoFaces ()
{
    if ( m_prFace != NULL ) {
        delete [] m_prFace;
    }
    m_prFace = new Face<T>[m_iNoFaces];
}
//-----------------------------------------------------------------------------
// Get Half Length
template <typename T>
T PolygonalModel<T>::GetMaxHalfLength () const
{
    T maxHalfSize = 0.0;
    for ( int i = 0; i < m_iNoVertices; ++i )
    {
        if ( fabs( m_prVertex[i][0] ) > maxHalfSize )
            maxHalfSize = fabs( m_prVertex[i][0] );
        if ( fabs( m_prVertex[i][1] ) > maxHalfSize )
            maxHalfSize = fabs( m_prVertex[i][1] );
        if ( fabs( m_prVertex[i][2] ) > maxHalfSize )
            maxHalfSize = fabs( m_prVertex[i][2] );
    }
    return maxHalfSize;
}
//-----------------------------------------------------------------------------
// Calculate and set the normals
template <typename T>
void PolygonalModel<T>::CalAndSetNormals ()
{
    CalAndSetFaceNormalsNotNormalized();
    NormalizeFaceNormals();
}
//-----------------------------------------------------------------------------
// Calculate and set the face normals (without normalized)
template <typename T>
inline void PolygonalModel<T>::CalAndSetFaceNormalsNotNormalized ()
{
    // Calculate and set the normal of each face
    for ( int i = 0; i < m_iNoFaces; ++i ) {
        m_prFace[i].SetNormal(
              (   m_prVertex[ m_prFace[i].GetVertexNo( 1 ) ].GetPosition() 
                - m_prVertex[ m_prFace[i].GetVertexNo( 0 ) ].GetPosition() )
            ^ (   m_prVertex[ m_prFace[i].GetVertexNo( 2 ) ].GetPosition() 
                - m_prVertex[ m_prFace[i].GetVertexNo( 1 ) ].GetPosition() )
        );
    }
}
//-----------------------------------------------------------------------------
// Normalize the face normals
template <typename T>
inline void PolygonalModel<T>::NormalizeFaceNormals ()
{
    for ( int i = 0; i < m_iNoFaces; ++i ) {
        const_cast< Vector3<T> * >( &m_prFace[i].GetNormal() )->Normalized();
        //m_prFace[i].GetNormal().Normalized();
    }
}
//-----------------------------------------------------------------------------

//******************************************************************************
// ApplyAndResetTransform
//******************************************************************************
//-----------------------------------------------------------------------------
template <typename T>
void PolygonalModel<T>::ApplyAndResetTransform ()
{
    for ( int i = 0; i < m_iNoVertices; ++i ) {
        m_prVertex[i].SetPosition( 
            (     GetTransform().RefToMatrixTransform() 
                * Vector4<T>( m_prVertex[i].GetPosition() )
            ).GetVector3()
        );
    }


    /*
    int i;
    //--------------------------------------------------------------------
    Vector3<T> vTransform = GetTransform().GetTranslation();
    if ( vTransform[0] != Math<T>::ZERO ) {
        for ( i = 0; i < m_iNoVertices; ++i )
            m_prVertex[i][0] += vTransform[0];
        GetTransform().SetTranslation( 0, Math<T>::ZERO );
    }
    if ( vTransform[1] != Math<T>::ZERO ) {
        for ( i = 0; i < m_iNoVertices; ++i )
            m_prVertex[i][1] += vTransform[1];
        GetTransform().SetTranslation( 1, Math<T>::ZERO );
    }
    if ( vTransform[2] != Math<T>::ZERO ) {
        for ( i = 0; i < m_iNoVertices; ++i )
            m_prVertex[i][2] += vTransform[2];
        GetTransform().SetTranslation( 2, Math<T>::ZERO );
    }
    //--------------------------------------------------------------------
    vTransform = GetTransform().GetRotationAngles();
    T tmpX;
    if ( vTransform[0] != Math<T>::ZERO ) {
        T deg = static_cast<T>( vTransform[0] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        for ( i = 0; i < m_iNoVertices; ++i ) {
            tmpX = m_prVertex[i][1]*c - m_prVertex[i][2]*s;
            m_prVertex[i][2] = m_prVertex[i][1]*s + m_prVertex[i][2]*c;
            m_prVertex[i][1] = tmpX;
        }
        GetTransform().SetRotationAxisAngle( 0, Math<T>::ZERO );
    }
    if ( vTransform[1] != Math<T>::ZERO ) {
        T deg = static_cast<T>( vTransform[1] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        for ( i = 0; i < m_iNoVertices; ++i ) {
            tmpX = m_prVertex[i][0]*c + m_prVertex[i][2]*s;
            m_prVertex[i][2] = -(m_prVertex[i][0]*s) + m_prVertex[i][2]*c;
            m_prVertex[i][0] = tmpX;
        }
        GetTransform().SetRotationAxisAngle( 1, Math<T>::ZERO );
    }
    if ( vTransform[2] != Math<T>::ZERO ) {
        T deg = static_cast<T>( vTransform[2] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        for ( i = 0; i < m_iNoVertices; ++i ) {
            tmpX = m_prVertex[i][0]*c - m_prVertex[i][1]*s;
            m_prVertex[i][1] = m_prVertex[i][0]*s + m_prVertex[i][1]*c;
            m_prVertex[i][0] = tmpX;
        }
        GetTransform().SetRotationAxisAngle( 2, Math<T>::ZERO );
    }
    //--------------------------------------------------------------------
    vTransform = GetTransform().GetScale();
    for ( int d = 0; d < 3; ++d ) {
        if ( vTransform[d] > Math<T>::ZERO ) {
            for ( i = 0; i < m_iNoVertices; ++i )
                m_prVertex[i][d] *= vTransform[d];
            GetTransform().SetScale( d, Math<T>::ONE );
        }
    }
    //--------------------------------------------------------------------
    //*/



    //--------------------------------------------------------------------
    // Set Transformation to Identity Matrix
    GetTransform().MakeIdentity();
    //--------------------------------------------------------------------
    // Recalculate Bounding Volume(s)
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();
}
//-----------------------------------------------------------------------------
//******************************************************************************

//******************************************************************************
// Virtual Fns from Collision Detection from ColDetSupport class
//******************************************************************************
//-----------------------------------------------------------------------------
template <typename T>
void PolygonalModel<T>::CalBoundingAABB ()
{
    m_paBoundingAABB[0][0] = m_paBoundingAABB[1][0] = m_prVertex[0][0];
    m_paBoundingAABB[0][1] = m_paBoundingAABB[1][1] = m_prVertex[0][1];
    m_paBoundingAABB[0][2] = m_paBoundingAABB[1][2] = m_prVertex[0][2];
    for ( int i = 1; i < m_iNoVertices; ++i )
    {
        // Find lowest x, y, and z
        if ( m_paBoundingAABB[0][0] > m_prVertex[i][0] )
             m_paBoundingAABB[0][0] = m_prVertex[i][0];
        if ( m_paBoundingAABB[0][1] > m_prVertex[i][1] )
             m_paBoundingAABB[0][1] = m_prVertex[i][1];
        if ( m_paBoundingAABB[0][2] > m_prVertex[i][2] )
             m_paBoundingAABB[0][2] = m_prVertex[i][2];
        // Find highest x, y, and z
        if ( m_paBoundingAABB[1][0] < m_prVertex[i][0] )
             m_paBoundingAABB[1][0] = m_prVertex[i][0];
        if ( m_paBoundingAABB[1][1] < m_prVertex[i][1] )
             m_paBoundingAABB[1][1] = m_prVertex[i][1];
        if ( m_paBoundingAABB[1][2] < m_prVertex[i][2] )
             m_paBoundingAABB[1][2] = m_prVertex[i][2];
    }
    // Find the bounding volume center
    m_pBoundingCenter[0] = ( m_paBoundingAABB[0][0] + m_paBoundingAABB[1][0] ) / 2.0;
    m_pBoundingCenter[1] = ( m_paBoundingAABB[0][1] + m_paBoundingAABB[1][1] ) / 2.0;
    m_pBoundingCenter[2] = ( m_paBoundingAABB[0][2] + m_paBoundingAABB[1][2] ) / 2.0;
}
//-----------------------------------------------------------------------------
template <typename T>
void PolygonalModel<T>::CalBoundingEllipsoid ()
{
    T x = m_paBoundingAABB[1][0] - m_pBoundingCenter[0];
    x *= x;
    T y = m_paBoundingAABB[1][1] - m_pBoundingCenter[1];
    y *= y;
    T z = m_paBoundingAABB[1][2] - m_pBoundingCenter[2];
    z *= z;
    m_pBoundingEllipsoid[1] = sqrt( y + z );
    m_pBoundingEllipsoid[2] = sqrt( z + x );
    m_pBoundingEllipsoid[0] = sqrt( x + y );
}
//-----------------------------------------------------------------------------
template <typename T>
void PolygonalModel<T>::CalBoundingSphere ()
{
    T squaredLength;
    m_pBoundingSphere = 0;
    for ( int i = 0; i < m_iNoVertices; ++i ) {
        squaredLength = (m_prVertex[i].GetPosition() - m_pBoundingCenter).SquaredLength();
        if ( squaredLength > m_pBoundingSphere )
            m_pBoundingSphere = squaredLength;
    }
    m_pBoundingSphere = sqrt( m_pBoundingSphere );
}
//-----------------------------------------------------------------------------
//******************************************************************************

//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8