TAPsTetrahedron.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsTetrahedron.cpp

Tetrahedron class is a class for a tetrahedron.

SUKITTI PUNAK   (09/13/2005)
UPDATE          (09/25/2005)
******************************************************************************/
#include "TAPsTetrahedron.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
//=============================================================================
// Static Variables
//-----------------------------------------------------------------------------
//*
template <typename T>
bool    Tetrahedron<T>::m_gbHasBeenSet = false;
template <typename T>
std::vector< std::vector<int> > Tetrahedron<T>::m_vVertexValence;
template <typename T>
std::vector< std::vector<int> > Tetrahedron<T>::m_vVertexFace;
template <typename T>
std::vector< std::vector<int> > Tetrahedron<T>::m_vFace(4);
template <typename T>
std::vector< std::vector<int> >::const_iterator Tetrahedron<T>::m_itor;
//*/
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
template <typename T>
Tetrahedron<T>::Tetrahedron ()
    : AbstractPolyhedron<T>( 4, 4 )
{
    //----------------------------------------------------------------
    m_vVertex[0] = Vector3<T>( 0, 0, 0 );   // origin
    m_vVertex[1] = Vector3<T>( 1, 0, 0 );   // x
    m_vVertex[2] = Vector3<T>( 0, 1, 0 );   // y
    m_vVertex[3] = Vector3<T>( 0, 0, 1 );   // z
    Setup();
}
//-----------------------------------------------------------------------------
template <typename T>
Tetrahedron<T>::Tetrahedron ( Vector3<T> const p[4] )
    : AbstractPolyhedron<T>( 4, 4 )
{
    m_vVertex[0] = p[0];    // origin
    m_vVertex[1] = p[1];    // x
    m_vVertex[2] = p[2];    // y
    m_vVertex[3] = p[3];    // z
    Setup();
}
//-----------------------------------------------------------------------------
template <typename T>
Tetrahedron<T>::~Tetrahedron ()
{}
//-----------------------------------------------------------------------------
//=============================================================================
// Helper Function(s)
//-----------------------------------------------------------------------------
// SetupStaticMembers Fn
template <typename T>
void Tetrahedron<T>::SetupStaticMembers ()
{
    //----------------------------------------------------------------
    m_vVertexValence.resize(4);
    m_vVertexFace.resize(4);
    m_vFace.resize(4);
    //----------------------------------------------------------------
    // Initialize Vertex Valence
    //----------------------------------------------------------------
    // Vertex#0: 1 2 3 ----------------
    m_vVertexValence[0].push_back( 1 );
    m_vVertexValence[0].push_back( 2 );
    m_vVertexValence[0].push_back( 3 );
    // Vertex#1: 0 2 3 ----------------
    m_vVertexValence[1].push_back( 0 );
    m_vVertexValence[1].push_back( 2 );
    m_vVertexValence[1].push_back( 3 );
    // Vertex#2: 0 1 3 ----------------
    m_vVertexValence[2].push_back( 0 );
    m_vVertexValence[2].push_back( 1 );
    m_vVertexValence[2].push_back( 3 );
    // Vertex#3: 0 1 2 ----------------
    m_vVertexValence[3].push_back( 0 );
    m_vVertexValence[3].push_back( 1 );
    m_vVertexValence[3].push_back( 2 );
    //----------------------------------------------------------------
    // Initialize Face List
    //----------------------------------------------------------------
    // Face#0: 0 2 1 ---------
    m_vFace[0].push_back( 0 );
    m_vFace[0].push_back( 2 );
    m_vFace[0].push_back( 1 );
    // Face#1: 0 3 2 ---------
    m_vFace[1].push_back( 0 );
    m_vFace[1].push_back( 3 );
    m_vFace[1].push_back( 2 );
    // Face#2: 0 1 3 ---------
    m_vFace[2].push_back( 0 );
    m_vFace[2].push_back( 1 );
    m_vFace[2].push_back( 3 );
    // Face#3: 1 2 3 ---------
    m_vFace[3].push_back( 1 );
    m_vFace[3].push_back( 2 );
    m_vFace[3].push_back( 3 );
    //----------------------------------------------------------------
    // Initialize Vertex Face List (face that has this vertex)
    //----------------------------------------------------------------
    // Vertex#0: 0 1 2 ---------
    m_vVertexFace[0].push_back( 0 );
    m_vVertexFace[0].push_back( 1 );
    m_vVertexFace[0].push_back( 2 );
    // Vertex#1: 0 2 3 ---------
    m_vVertexFace[1].push_back( 0 );
    m_vVertexFace[1].push_back( 2 );
    m_vVertexFace[1].push_back( 3 );
    // Vertex#2: 0 1 3 ---------
    m_vVertexFace[2].push_back( 0 );
    m_vVertexFace[2].push_back( 1 );
    m_vVertexFace[2].push_back( 3 );
    // Vertex#3: 1 2 3 ---------
    m_vVertexFace[3].push_back( 1 );
    m_vVertexFace[3].push_back( 2 );
    m_vVertexFace[3].push_back( 3 );
}
//-----------------------------------------------------------------------------
// Setup Fn
template <typename T>
void Tetrahedron<T>::Setup ()
{
    // REMARK:
    // =======
    // In theory, we should be able to set m_gbHasBeenSet to true.
    // However, calling DrawByOpenGL fn will have static member size equals zero.
    // Therefore, we will set it to true in DrawByOpenGL fn.
    // See DrawByOpenGL source code below.
    // I believe this must be an effect from DrawByOpenGL is passed as an 
    // argument to a function.
    if ( !m_gbHasBeenSet ) {
        std::cout << "Call Tetrahedron<T>::SetupStaticMembers()\n";
        //m_gbHasBeenSet = true;
        SetupStaticMembers();
    }
    //----------------------------------------------------------------
    CalNormals();
}
//-----------------------------------------------------------------------------
// CalNormals Fn
template <typename T>
void Tetrahedron<T>::CalNormals ()
{
    // Assume all faces are planer which works perfectly for triangular faces
    //----------------------------------------------------------------
    // Calculate Face Normals (Unnormalized)
    int p = 0;
    for ( m_itor = m_vFace.begin(); m_itor != m_vFace.end(); ++m_itor, ++p ) {
        m_vFaceNormal[p] = ( m_vVertex[(*m_itor)[1]] - m_vVertex[(*m_itor)[0]] )
                         ^ ( m_vVertex[(*m_itor)[2]] - m_vVertex[(*m_itor)[0]] );
    }
    //----------------------------------------------------------------
    // Calculate Vertex Normals
    for ( p = 0; p < 4; ++p ) {
        m_vVertexNormal[p].SetXYZ( 0, 0, 0);
        for ( int i = 0; i < static_cast<int>( m_vVertexFace[p].size() ); ++i ) {
            m_vVertexNormal[p] += m_vFaceNormal[ m_vVertexFace[p][i] ];
        }
        m_vVertexNormal[p].Normalized();
        std::cout << m_vVertexNormal[p] << std::endl;
    }
    //----------------------------------------------------------------
    // Normalize Face Normals
    for ( p = 0; p < static_cast<int>(m_vFaceNormal.size()); ++p ) {
        m_vFaceNormal[p].Normalized();
        //std::cout << m_vFaceNormal[p] << std::endl;
        //m_vVertexNormal[p] = m_vFaceNormal[p];
    }
}
//-----------------------------------------------------------------------------
#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
// DrawByOpenGL
//-----------------------------------------------------------------------------
template <typename T>
void Tetrahedron<T>::DrawByOpenGL ()
{
    if ( !m_gbHasBeenSet ) {
        std::cout << "Tetrahedron<T>::DrawByOpenGL() ==> ";
        std::cout << "Call Tetrahedron<T>::SetupStaticMembers()\n";
        m_gbHasBeenSet = true;
        SetupStaticMembers();
    }
    //----------------------------------------------------------------
    int p;
    //int count = 0;
    //----------------------------------------------------------------
    glPushMatrix();
    for ( m_itor = m_vFace.begin(); m_itor != m_vFace.end(); ++m_itor ) {
        //std::cout << "\n(*m_itor).size() = " << (*m_itor).size();
        //std::cout << "\nFace# " << ++count;
        glBegin( GL_POLYGON );
        for ( int i = 0; i < static_cast<int>( (*m_itor).size() ); ++i ) {
            p = (*m_itor)[i];
            glNormal3f( m_vVertexNormal[p][0], m_vVertexNormal[p][1], m_vVertexNormal[p][2] );
            glVertex3f( m_vVertex[p][0], m_vVertex[p][1], m_vVertex[p][2] );
        }
        glEnd();

        // Draw boundary of face
        glColor3f( 0, 1, 1 );
        glDisable( GL_LIGHTING );
        glBegin( GL_LINE_LOOP );
        for ( int i = 0; i < static_cast<int>( (*m_itor).size() ); ++i ) {
            p = (*m_itor)[i];
            glNormal3f( m_vVertexNormal[p][0], m_vVertexNormal[p][1], m_vVertexNormal[p][2] );
            glVertex3f( m_vVertex[p][0], m_vVertex[p][1], m_vVertex[p][2] );
        }
        glEnd();
        glEnable( GL_LIGHTING );

    }
    glPopMatrix();
    //*/

    /*
    glPushMatrix();
        glBegin( GL_TRIANGLE_FAN ); // Face#: 0, 1, and 2
            glNormal3f( m_vVertexNormal[0][0], m_vVertexNormal[0][1], m_vVertexNormal[0][2] );
            glVertex3f( m_vVertex[0][0], m_vVertex[0][1], m_vVertex[0][2] );
            glNormal3f( m_vVertexNormal[2][0], m_vVertexNormal[2][1], m_vVertexNormal[2][2] );
            glVertex3f( m_vVertex[2][0], m_vVertex[2][1], m_vVertex[2][2] );
            glNormal3f( m_vVertexNormal[1][0], m_vVertexNormal[1][1], m_vVertexNormal[1][2] );
            glVertex3f( m_vVertex[1][0], m_vVertex[1][1], m_vVertex[1][2] );
            glNormal3f( m_vVertexNormal[3][0], m_vVertexNormal[3][1], m_vVertexNormal[3][2] );
            glVertex3f( m_vVertex[3][0], m_vVertex[3][1], m_vVertex[3][2] );
            glNormal3f( m_vVertexNormal[2][0], m_vVertexNormal[2][1], m_vVertexNormal[2][2] );
            glVertex3f( m_vVertex[2][0], m_vVertex[2][1], m_vVertex[2][2] );
        glEnd();
        glBegin( GL_TRIANGLES );    // Face#: 3
            glNormal3f( m_vVertexNormal[1][0], m_vVertexNormal[1][1], m_vVertexNormal[1][2] );
            glVertex3f( m_vVertex[1][0], m_vVertex[1][1], m_vVertex[1][2] );
            glNormal3f( m_vVertexNormal[2][0], m_vVertexNormal[2][1], m_vVertexNormal[2][2] );
            glVertex3f( m_vVertex[2][0], m_vVertex[2][1], m_vVertex[2][2] );
            glNormal3f( m_vVertexNormal[3][0], m_vVertexNormal[3][1], m_vVertexNormal[3][2] );
            glVertex3f( m_vVertex[3][0], m_vVertex[3][1], m_vVertex[3][2] );
        glEnd();
    glPopMatrix();
    //*/
    //----------------------------------------------------------------
    DrawVertexNormals();
    DrawFaceNormals();
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8