TAPsOpenGLHalfEdgeTrigonalModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLHalfEdgeTrigonalModel.cpp

Class OpenGLHalfEdgeTrigonalModel is for creating an OpenGL Trigonal Model 
using half-edge data structure.

See class HalfEdgeModel (in "../OpenGLModel/TAPsHalfEdgeTrigonalModel.hpp") and
class OpenGLSupport ("../OpenGL/TAPsOpenGLSupport.hpp") for details.

SUKITTI PUNAK   (06/15/2006)
UPDATE          (06/15/2006)
******************************************************************************/
#include "TAPsOpenGLHalfEdgeTrigonalModel.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>
OpenGLHalfEdgeTrigonalModel<T>::OpenGLHalfEdgeTrigonalModel()
    : HalfEdgeTrigonalModel<T>(), bIsDisplayVertexNormals( false )
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "OpenGLHalfEdgeTrigonalModel<" << typeid(T).name() << "> constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
OpenGLHalfEdgeTrigonalModel<T>::~OpenGLHalfEdgeTrigonalModel()
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "OpenGLHalfEdgeTrigonalModel<" << typeid(T).name() << "> destructor\n";
    #endif//TAPs_DEBUG_MODE
}
/*
//-----------------------------------------------------------------------------
//void DisplayGL()
template <typename T>
void OpenGLHalfEdgeTrigonalModel<T>::DisplayGL( OpenGL::Enum::DrawMode DM )
{
    switch (DM) {
    case OpenGL::Enum::POLYGON:
        DrawGL( GL_POLYGON );
        break;
    case OpenGL::Enum::WIRE_FRAME:
        DrawGL( GL_LINE_LOOP );
        break;
    case OpenGL::Enum::POINT:
        DrawGL( GL_POINTS );
        break;
    case OpenGL::Enum:: POLYGON_WITH_WIRE_FRAME:
        // Draw the object with GL_POLYGON_OFFSET enabled
        glEnable( GL_POLYGON_OFFSET_FILL );
        glPolygonOffset( 1.0, 1.0 );
        DrawGL( GL_POLYGON );
        glDisable( GL_POLYGON_OFFSET_FILL );
        // Draw the wire frame of the object
        glDisable( GL_LIGHTING );
        //glDisable( GL_DEPTH_TEST );
        glColor3ub( 255, 200, 0 );
        DrawGL( GL_LINE_LOOP );
        glEnable( GL_LIGHTING );
        //glEnable( GL_DEPTH_TEST );
        break;
    }
}
//*/
//-----------------------------------------------------------------------------
// Helper Fn
// void DrawGL()
template <typename T>
void OpenGLHalfEdgeTrigonalModel<T>::DrawGL( GLenum drawMode )
{
    //----------------------------------------------------------------
    if ( drawMode == OpenGL::Enum::POINT ) {
        HEVertex<T> *ptr = m_listVertex->Head();
        glBegin( drawMode );
        while ( ptr != NULL ) {
            // Draw the vertex
            glVertex3f ( 
                static_cast<float>( (*ptr)[0] ), 
                static_cast<float>( (*ptr)[1] ), 
                static_cast<float>( (*ptr)[2] ) );
            ptr = ptr->Next();
        }
        glEnd();
    }
    else if ( isFacetShading ) {
        // Draw the object
        //glEnable( GL_TEXTURE_2D );
        HEFace<T> *facePtr = m_listFace->Head();
        HEHalfEdge<T> *halfEdgePtr;
        //for ( int f = 0; f < GetNoFaces(); ++f ) {
        while ( facePtr != NULL ) {
            halfEdgePtr = facePtr->IncidentHalfEdge();
            glBegin( drawMode );
            //for ( int i = 0; i < 3; ++i ) {
            do {
                //if ( m_prFace[i].GetNoTexCoords() != 0 ) {
                //  glTexCoord2f( static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2 ) ), 
                //                static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2+1 ) ) );
                //}
                // Normal of the face
                glNormal3f (
                    static_cast<float>( facePtr->GetNormal()[0] ),
                    static_cast<float>( facePtr->GetNormal()[1] ),
                    static_cast<float>( facePtr->GetNormal()[2] )
                );
                // Normal of the vertex
                // Draw the vertex
                glVertex3f ( 
                    static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[0] ),
                    static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[1] ),
                    static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[2] )
                );
                // DEBUG:
                //std::cout << halfEdgePtr->Vertex()->GetPosition()[0];
                //std::cout << halfEdgePtr->Vertex()->GetPosition()[1];
                //std::cout << halfEdgePtr->Vertex()->GetPosition()[2];
                //std::cout << "\n";
                halfEdgePtr = halfEdgePtr->Next();
            } while ( halfEdgePtr != facePtr->IncidentHalfEdge() );
            //std::cout << "\n";
            //}
            glEnd();
            facePtr = facePtr->Next();
        }

        // Draw the object
        //for ( int i = 0; i < m_iNoFaces; i++ )
        //{
        //  glBegin( drawMode );
        //  for ( int j = 0; j < m_prFace[i].GetNoVertices(); ++j )
        //  {
        //      // Draw texture
        //      if ( m_prFace[i].GetNoTexCoords() != 0 ) {
        //          glTexCoord2f( static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2 ) ), 
        //                        static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2+1 ) ) );
        //      }
        //      // Normal of the face
        //      //glNormal3f ( static_cast<float>( m_prFace[i].GetNormal()[0] ), 
        //      //           static_cast<float>( m_prFace[i].GetNormal()[1] ), 
        //      //           static_cast<float>( m_prFace[i].GetNormal()[2] ) );
        //      // Draw the vertex
        //      glVertex3f ( 
        //          static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ][0] ), 
        //          static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ][1] ), 
        //          static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ][2] ) );
        //  }
        //  glEnd();
        //}
    }
    else {
        // Draw the object
        //glEnable( GL_TEXTURE_2D );
        HEFace<T> *facePtr = m_listFace->Head();
        HEHalfEdge<T> *halfEdgePtr;
        //for ( int f = 0; f < GetNoFaces(); ++f ) {
        while ( facePtr != NULL ) {
            halfEdgePtr = facePtr->IncidentHalfEdge();
            glBegin( drawMode );
            //for ( int i = 0; i < 3; ++i ) {
            do {
                //if ( m_prFace[i].GetNoTexCoords() != 0 ) {
                //  glTexCoord2f( static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2 ) ), 
                //                static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2+1 ) ) );
                //}
                glNormal3f ( 
                    static_cast<float>( halfEdgePtr->Vertex()->GetNormal()[0] ),
                    static_cast<float>( halfEdgePtr->Vertex()->GetNormal()[1] ),
                    static_cast<float>( halfEdgePtr->Vertex()->GetNormal()[2] )
                );
                // Normal of the vertex
                // Draw the vertex
                glVertex3f ( 
                    static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[0] ),
                    static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[1] ),
                    static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[2] )
                );
                // DEBUG:
                //std::cout << halfEdgePtr->Vertex()->GetPosition()[0];
                //std::cout << halfEdgePtr->Vertex()->GetPosition()[1];
                //std::cout << halfEdgePtr->Vertex()->GetPosition()[2];
                //std::cout << "\n";
                halfEdgePtr = halfEdgePtr->Next();
            } while ( halfEdgePtr != facePtr->IncidentHalfEdge() );
            //std::cout << "\n";
            //}
            glEnd();
            facePtr = facePtr->Next();
        }

        //for ( int i = 0; i < m_iNoFaces; i++ )
        //{
        //  glBegin( drawMode );
        //  for ( int j = 0; j < m_prFace[i].GetNoVertices(); ++j )
        //  {
        //      // Draw texture
        //      if ( m_prFace[i].GetNoTexCoords() != 0 ) {
        //          glTexCoord2f( static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2 ) ), 
        //                        static_cast<float>( m_prFace[i].GetTexCoordHalfNo( j*2+1 ) ) );
        //      }
        //      // Normal of the vertex
        //      glNormal3f ( static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ].GetNormal()[0] ), 
        //                   static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ].GetNormal()[1] ), 
        //                   static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ].GetNormal()[2] ) ); 
        //      // Draw the vertex
        //      glVertex3f ( 
        //          static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ][0] ), 
        //          static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ][1] ), 
        //          static_cast<float>( m_prXVertex[ m_prFace[i].GetVertexNo( j ) ][2] ) );
        //  }
        //  glEnd();
        //}
    }

    // Draw Boundary
    //if ( drawMode == OpenGL::Enum::POLYGON_WITH_WIRE_FRAME ) {
    //if ( true ) {
    //  glColor3f( 1.0f, 0.0f, 0.0f );
    //  glDisable( GL_LIGHTING );
    //  glBegin( GL_LINES );
    //  HEFace<T> *facePtr = m_listFace->Head();
    //  HEHalfEdge<T> *halfEdgePtr;
    //  while ( facePtr != NULL ) {
    //      halfEdgePtr = facePtr->IncidentHalfEdge();
    //      do {
    //          if ( !halfEdgePtr->Pair() ) {
    //              // Draw the vertex
    //              glVertex3f ( 
    //                  static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[0] ),
    //                  static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[1] ),
    //                  static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[2] )
    //              );
    //              glVertex3f ( 
    //                  static_cast<float>( halfEdgePtr->Next()->Vertex()->GetPosition()[0] ),
    //                  static_cast<float>( halfEdgePtr->Next()->Vertex()->GetPosition()[1] ),
    //                  static_cast<float>( halfEdgePtr->Next()->Vertex()->GetPosition()[2] )
    //              );
    //          }
    //          halfEdgePtr = halfEdgePtr->Next();
    //      } while ( halfEdgePtr != facePtr->IncidentHalfEdge() );
    //      facePtr = facePtr->Next();
    //  }
    //  glEnd();
    //  glEnable( GL_LIGHTING );
    //}

    // Draw Boundary
    if ( true ) {
        glColor3f( 1.0f, 0.0f, 0.0f );
        glPushAttrib( GL_LIGHTING_BIT );
        glDisable( GL_LIGHTING );
        glBegin( GL_LINES );
        if ( m_listHoleFace != NULL ) {
            HEFace<T> *facePtr = m_listHoleFace->Head();
            HEHalfEdge<T> *halfEdgePtr;
            while ( facePtr != NULL ) {
                halfEdgePtr = facePtr->IncidentHalfEdge();
                do {
                    //if ( halfEdgePtr && halfEdgePtr->Next() ) {
                        // Draw the vertex
                        glVertex3f ( 
                            static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[0] ),
                            static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[1] ),
                            static_cast<float>( halfEdgePtr->Vertex()->GetPosition()[2] )
                        );
                        glVertex3f ( 
                            static_cast<float>( halfEdgePtr->Next()->Vertex()->GetPosition()[0] ),
                            static_cast<float>( halfEdgePtr->Next()->Vertex()->GetPosition()[1] ),
                            static_cast<float>( halfEdgePtr->Next()->Vertex()->GetPosition()[2] )
                        );
                    //}
                    halfEdgePtr = halfEdgePtr->Next();
                } while ( halfEdgePtr && halfEdgePtr != facePtr->IncidentHalfEdge() );
                facePtr = facePtr->Next();
            }
        }
        glEnd();
        //glEnable( GL_LIGHTING );
        glPopAttrib();
    }

    static HEFace<T> * g_pFace = m_listFace->Head();
    static int gCount = 0;
    //static int gCount2 = 0;

    if ( bIsDisplayVertexNormals ) {
        ++gCount;
        glPushAttrib( GL_LIGHTING_BIT | GL_ENABLE_BIT );
        glDisable( GL_LIGHTING );
        glEnable( GL_COLOR_MATERIAL );
        
        //glColor3ub( 175, 50, 70 );
        //DrawVertexNormals();

        /*
        glColor3ub( 75, 50, 175 );
        DrawHalfEdgeByPrevPtrs();

        glColor3ub( 175, 150, 70 );
        DrawHalfEdgeByNextPtrs();
        //*/

//      while ( g_pFace ) {
        if ( g_pFace ) {
            HEHalfEdge<T> * pHalfEdge = g_pFace->IncidentHalfEdge();
            HEHalfEdge<T> * pStartHalfEdge = pHalfEdge;
            Vector3<T> color[6];

            color[0] = Vector3<T>( 0.5, 0.0, 0.0 );
            color[1] = Vector3<T>( 1.0, 0.5, 0.5 );

            color[2] = Vector3<T>( 0.0, 0.5, 0.0 );
            color[3] = Vector3<T>( 0.5, 1.0, 0.5 );

            color[4] = Vector3<T>( 0.0, 0.0, 0.5 );
            color[5] = Vector3<T>( 0.5, 0.5, 1.0 );

            int count = 0;
            do {
                //std::cout << ++count << "\n";
                DrawHalfEdgePairs( pHalfEdge, color[count], color[count+1] );
                count += 2;
                pHalfEdge = pHalfEdge->Next();
            } while ( pHalfEdge != pStartHalfEdge );
            if ( gCount % 25 == 0 ) {
                g_pFace = g_pFace->Next();
                gCount = 0;
            }
        }
        else {
            g_pFace = m_listFace->Head();
        }

        glPopAttrib();
    }

    // Draw AABB Bounding Box
    //DrawBoundingAABB();
    //DrawBoundingEllipsoid();
    //DrawBoundingSphere();
    //----------------------------------------------------------------
}
//=============================================================================
// Draw by OpenGL
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLHalfEdgeTrigonalModel<T>::DrawVertexNormals ()
{
    HEVertex<T> * pVertex = m_listVertex->Head();
    while ( pVertex ) {
        OpenGLUsefulObj<T>::DrawOneHeadArrow( pVertex->GetPosition(), pVertex->GetPosition() + pVertex->GetNormal() );
        pVertex = pVertex->Next();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLHalfEdgeTrigonalModel<T>::DrawHalfEdgeByNextPtrs ()
{
    HEFace<T> * pFace = m_listFace->Head();
    while ( pFace ) {
        HEHalfEdge<T> * pHalfEdge = pFace->IncidentHalfEdge();
        HEHalfEdge<T> * pNextHalfEdge = pHalfEdge->Next();
        HEHalfEdge<T> * pStartHalfEdge = pHalfEdge;
        do {
            OpenGLUsefulObj<T>::DrawOneHeadArrow( 
                    pHalfEdge->Vertex()->GetPosition()     + pFace->GetNormal()/5, 
                    pNextHalfEdge->Vertex()->GetPosition() + pFace->GetNormal()/5 );
            pHalfEdge     = pHalfEdge->Next();
            pNextHalfEdge = pNextHalfEdge->Next();
        } while ( pHalfEdge != pStartHalfEdge );
        pFace = pFace->Next();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLHalfEdgeTrigonalModel<T>::DrawHalfEdgeByPrevPtrs ()
{
    HEFace<T> * pFace = m_listFace->Head();
    while ( pFace ) {
        HEHalfEdge<T> * pHalfEdge = pFace->IncidentHalfEdge();
        HEHalfEdge<T> * pPrevHalfEdge = pHalfEdge->Prev();
        HEHalfEdge<T> * pStartHalfEdge = pHalfEdge;
        do {
            OpenGLUsefulObj<T>::DrawOneHeadArrow( 
                    pHalfEdge->Vertex()->GetPosition()     + pFace->GetNormal()/10, 
                    pPrevHalfEdge->Vertex()->GetPosition() + pFace->GetNormal()/10 );
            pHalfEdge     = pHalfEdge->Next();
            pPrevHalfEdge = pPrevHalfEdge->Next();
        } while ( pHalfEdge != pStartHalfEdge );
        pFace = pFace->Next();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLHalfEdgeTrigonalModel<T>::DrawHalfEdgePairs ( const HEHalfEdge<T> * pHalfEdge, Vector3<T> & color1, Vector3<T> & color2 )
{
    glPushAttrib( GL_LIGHTING_BIT | GL_ENABLE_BIT );
    glDisable( GL_LIGHTING );
    glEnable( GL_COLOR_MATERIAL );
    
    glColor3f( color1[0], color1[1], color1[2] );
    OpenGLUsefulObj<T>::DrawOneHeadArrow( 
            pHalfEdge->Vertex()->GetPosition()     + pHalfEdge->Face()->GetNormal()/2, 
            pHalfEdge->Next()->Vertex()->GetPosition() + pHalfEdge->Face()->GetNormal()/2 );
    
    HEHalfEdge<T> * pPair = pHalfEdge->Pair();
    glColor3f( color2[0], color2[1], color2[2] );
    OpenGLUsefulObj<T>::DrawOneHeadArrow( 
            pPair->Vertex()->GetPosition()     + pHalfEdge->Face()->GetNormal()/4, 
            pPair->Next()->Vertex()->GetPosition() + pHalfEdge->Face()->GetNormal()/4 );

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