TAPsExtendedOpenGLVolPresPolygonalModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsExtendedOpenGLVolPresPolygonalModel.cpp

Class TAPsExtendedOpenGLVolPresPolygonalModel is for a deformable mesh model with 
volume preservation.
It memorizes its original shape -- original vertex positions

SUKITTI PUNAK   (04/25/2005)
UPDATE          (05/30/2008)
******************************************************************************/
#include "TAPsExtendedOpenGLVolPresPolygonalModel.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>
ExtendedOpenGLVolPresPolygonalModel<T>::ExtendedOpenGLVolPresPolygonalModel()
    : OpenGLVolPresPolygonalModel<T>(), 
      m_prOrigVertexPos( NULL ),
      m_pbFaceFixed( NULL ),
      m_pbVertexFixed( NULL )
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "ExtendedOpenGLVolPresPolygonalModel<" << typeid(T).name() << "> constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
ExtendedOpenGLVolPresPolygonalModel<T>::~ExtendedOpenGLVolPresPolygonalModel()
{
    if ( m_prOrigVertexPos != NULL ) {
        delete [] m_prOrigVertexPos;
        m_prOrigVertexPos = NULL;
    }
    if ( m_pbFaceFixed != NULL ) {
        delete [] m_pbFaceFixed;
        m_pbFaceFixed = NULL;
    }
    if ( m_pbVertexFixed != NULL ) {
        delete [] m_pbVertexFixed;
        m_pbVertexFixed = NULL;
    }

    #ifdef  TAPs_DEBUG_MODE
    std::cout << "ExtendedOpenGLVolPresPolygonalModel<" << typeid(T).name() << "> destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Initialize
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::Initialize ()
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "A Model Initialization\n";
    #endif//TAPs_DEBUG_MODE
    //----------------------------------------------------------------
    // Model Initialization
    VolPresPolygonalModel<T>::Initialize();
    SetOrigVertexPositions();
    SetFacesToUnFixed();
    SetVerticesToUnFixed();

    /*
    DetermineAndSortRings();
    CalAndSetNormals();
    // DetermineAndSortRings();
    ApplyMaterial();
    DetermineEdgeList();
    CalVolume2();
    
    m_pcVertexRings = new VertexRings( m_pviVertexRing1List, m_iNoVertices );
    //PreserveVolume( weight );

    //----------------------------------------------------------------
    // Allocate Fix Status and Deform Vector for each Vertex
    delete [] m_bFlagFixed;
    m_bFlagFixed = new bool[m_iNoVertices];
    for ( int i = 0; i < m_iNoVertices; ++i ) {
        m_bFlagFixed[i] = false;
    }
    //----------------------------------------------------------------
    // Allocate Deform Vector for each Vertex
    delete [] m_pvDeformVector;
    m_pvDeformVector = new Vector3<T>[m_iNoVertices];

    // For Collision Detection
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();
    */
}
//-----------------------------------------------------------------------------
// Set Original Vertex Positions
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::SetOrigVertexPositions ()
{
    if ( !m_prOrigVertexPos )
        m_prOrigVertexPos = new Vector3<T>[ GetNoVertices() ];
    if ( !m_prOrigVertexPos ) {
        return;
    }
    for ( int i = 0; i < GetNoVertices(); ++i ) {
        m_prOrigVertexPos[i] = m_prXVertex[i].GetPosition();
    }
}
//-----------------------------------------------------------------------------
// Set Face Fixed/Unfixed Status
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::SetFacesToUnFixed ()
{
    if ( !m_pbFaceFixed )
        m_pbFaceFixed = new bool[ GetNoFaces() ];
    if ( !m_pbFaceFixed ) {
        std::cerr << "ERROR: Cannot allocate memory for m_pbFaceFixed!" << std::endl;
        return;
    }
    for ( int i = 0; i < GetNoFaces(); ++i ) {
        m_pbFaceFixed[i] = false;
    }
}
//-----------------------------------------------------------------------------
// Set Vertex Fixed/Unfixed Status
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::SetVerticesToUnFixed ()
{
    if ( !m_pbVertexFixed )
        m_pbVertexFixed = new bool[ GetNoVertices() ];
    if ( !m_pbVertexFixed ) {
        std::cerr << "ERROR: Cannot allocate memory for m_pbVertexFixed!" << std::endl;
        return;
    }
    for ( int i = 0; i < GetNoVertices(); ++i ) {
        m_pbVertexFixed[i] = false;
    }
}
//-----------------------------------------------------------------------------

// START: a function for bouncing //
//-----------------------------------------------------------------------------
template <typename T>
T ExtendedOpenGLVolPresPolygonalModel<T>::FlatCollisionDetectionWithElasticity( T groundHeight )
{
    bool isChanged = true;
    T volForce = 0;
    T centerY = GetTransform().GetTranslation()[1];
    //T distance = Center[1] + m_paBoundingAABB[0][1] - groundHeight;
    T distance = centerY + m_paBoundingAABB[0][1] - groundHeight;
    //----------------------------------------------------------------
    // No collision
    if ( distance >= 0.0 ) {
        return 0;
    }
    //----------------------------------------------------------------
    // Handle Collision
    for ( int i = 0; i < GetNoVertices(); ++i ) {
        m_bFlagFixed[i] = m_pbVertexFixed[i];
        T newHeight = groundHeight - centerY;
        if ( groundHeight > centerY + m_prOrigVertexPos[i][1] ) {
            isChanged = true;
            m_prXVertex[i][1] = newHeight;
            m_bFlagFixed[i] = true;
        }
        else if ( m_prXVertex[i][1] != m_prOrigVertexPos[i][1] ) {
            isChanged = true;
            m_prXVertex[i][0] = m_prOrigVertexPos[i][0];
            m_prXVertex[i][1] = m_prOrigVertexPos[i][1];
            m_prXVertex[i][2] = m_prOrigVertexPos[i][2];
        }
        else {

        }
    }
    //----------------------------------------------------------------
    if ( m_bFlagVolPresMode && isChanged ) {
        //PreserveVolume( weight );
        PreserveVolumeByVertexNormals( m_weight );
        //---------------------------------------
        // Recalculate Normals (Already included in PreserveVolumeByVertexNormals() )
        //CalAndSetFaceNormalsNotNormalized();
        //CalAndSetVertexNormals();
        //NormalizeFaceNormals();
        //---------------------------------------
        //volForce = m_tVolume - totalVolume;
    }
    return volForce;
}
//-----------------------------------------------------------------------------
// END: a function for bouncing //

//-----------------------------------------------------------------------------
// Reset Fn inherited from Model class
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::Reset ()
{
    for ( int i = 0; i < GetNoVertices(); ++i ) {
        m_prXVertex[i].SetPosition( m_prOrigVertexPos[i] );
    }
    GetTransform().SetTranslation( 0, 0, 0 );
    CalAndSetNormals();
    //Center[0] = Center[1] = Center[2] = 0;
    //Initialize();
}
/*
//-----------------------------------------------------------------------------
//void DisplayGL()
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<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 );
        glColor3ub( 255, 200, 0 );
        DrawGL( GL_LINE_LOOP );
        glEnable( GL_LIGHTING );
        break;
    }
}
//*/
//-----------------------------------------------------------------------------
//void DisplayGLText()
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::DisplayGLText( T x, T y, T z )
{
    char str[128] = "";
    int count = 0;
    T volume = CalVolume(); // for calculating centroid
    sprintf( str, "Centroid: (%10.4f, %10.4f, %10.4f)", m_vtCentroid[0], m_vtCentroid[1], m_vtCentroid[2] );
    DrawText( str, x, y-count++, z );
    sprintf( str, "New Volume:  %g", volume );
    DrawText( str, x, y-count++, z );
    sprintf( str, "Orig Volume: %g", m_tVolume );
    DrawText( str, x, y-count++, z );

//  sprintf( str, "weight0: %g", weight[0] );
//  DrawText( str, x, y-count++, z );
    
//  sprintf( str, "weight1: %g", weight[1] );
//  DrawText( str, x, y-2*count++, z );
//  sprintf( str, "weight2: %g", weight[2] );
//  DrawText( str, x, y-2*count++, z );
//  sprintf( str, "weight3: %g", weight[3] );
//  DrawText( str, x, y-2*count++, z );

    /*
    if ( m_bFlagSpringForceMode ) {
        sprintf( str, "Spring Force: ON" );
    }
    else {
        sprintf( str, "Spring Force: OFF" );
    }
    DrawText( str, x, y-count++, z );
    if ( m_bFlagVolPresMode ) {
        sprintf( str, "VolPres: ON" );
    }
    else {
        sprintf( str, "VolPres: OFF" );
    }
    DrawText( str, x, y-count++, z );
    //*/
}
//-----------------------------------------------------------------------------
// Helper Fn
// void DrawGL()
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::DrawGL ( GLenum drawMode )
{
    glPushMatrix();

    
    glTranslatef(   static_cast<float>( GetTransform().GetTranslation()[0] ), 
                    static_cast<float>( GetTransform().GetTranslation()[1] ), 
                    static_cast<float>( GetTransform().GetTranslation()[2] )    );
    /*glRotatef(        static_cast<float>( Rotation[0] ), 
                    static_cast<float>( 1 ), 
                    static_cast<float>( 0 ), 
                    static_cast<float>( 0 ) );
    glRotatef(      static_cast<float>( Rotation[1] ), 
                    static_cast<float>( 0 ), 
                    static_cast<float>( 1 ), 
                    static_cast<float>( 0 ) );
    glRotatef(      static_cast<float>( Rotation[2] ), 
                    static_cast<float>( 0 ), 
                    static_cast<float>( 0 ), 
                    static_cast<float>( 1 ) );
    glScalef(       static_cast<float>( Scale[0]/2 ), 
                    static_cast<float>( Scale[1]/2 ), 
                    static_cast<float>( Scale[2] )  );
    */
    //ModelTransformationByTranslationRatationAndScale();

    //-------------------------------------------------------------------------
    // StepSimulation
    int count;
    if ( bRunSimulation ) {
        for ( count = 0; count < 5; count++ ) {
            StepSimulation( 0.01 );
        }
        //*/
        
        /*
        for ( int i = 0; i < 5; ++i ) {
            for ( int j = 0; j < m_prFace[i].GetNoVertices(); ++j ) {
                m_prXVertex[ m_prFace[i].GetVertexNo(j) ].SetPosition( 
                    m_prXVertex[ m_prFace[i].GetVertexNo(j) ].GetPosition() * 1.001
                );
                //m_prXVertex[ 0].SetPosition( m_prXVertex[ 0].GetPosition() * 1.001 );
                //m_prXVertex[12].SetPosition( m_prXVertex[12].GetPosition() * 1.001 );
                //m_prXVertex[13].SetPosition( m_prXVertex[13].GetPosition() * 1.001 );
            }
        }
        */
    }

    if ( isFacetShading ) {
        // Draw the object
        //glEnable( GL_TEXTURE_2D );
        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();
        }
        //glDisable( GL_TEXTURE_2D );
    }
    else {
        // Draw the object
        //glEnable( GL_TEXTURE_2D );
        for ( int i = 0; i < m_iNoFaces; i++ )
        {
            GLfloat ambient[4];
            // Change ambient color
            if ( m_pbFaceFixed[i] ) {
                bool isFixed = true;
                for ( int k = 0; k < m_prFace[i].GetNoVertices(); ++k ) {
                    if ( m_pbVertexFixed[ m_prFace[i].GetVertexNo(k) ] == false ) {
                        isFixed = false;
                        break;
                    }
                }
                if ( isFixed ) {
                    material.GetAmbient( ambient );
                    material.SetAmbient( 0, ambient[0]+0.5 );
                    material.ApplyAmbient();
                }
            }

            // Draw all faces
            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();

            // Restore ambient color
            if ( m_pbFaceFixed[i] ) {
                material.SetAmbient( ambient );
                material.ApplyAmbient();
            }

        }
        //glDisable( GL_TEXTURE_2D );
    }

    // Display vertex normals
    if ( bFlagShowVertexNormals ) {
        DisplayGL_ParticleNormals();
    }
    // Display vertex rings
    if ( bFlagShowVertexRings ) {
        DisplayGL_VertexRings();
    }
    // Display the deformed face
    if ( bFlagShowDeformedFace ) {
        DisplayGL_DeformedFaceNo();
    }

    // Display Volume and Centroid
    glDisable( GL_LIGHTING );
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glColor3ub( 200, 185, 0 );

    // Draw Bounding Volume(s)
    //DrawBoundingAABB();
    //DrawBoundingSphere();

    glPopAttrib();
    glEnable( GL_LIGHTING );

    glPopMatrix();
}
//-----------------------------------------------------------------------------
// Picking Fns
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::SelectATriangle ( 
    bool isSelect,  // true --> select; false --> deselect the hit triangle
    GLuint BUFSIZE, GLuint selectBuf[], GLint &hits, 
    GLdouble x, GLdouble y, 
    GLdouble dLeft,     GLdouble dRight, 
    GLdouble dBottom,   GLdouble dTop, 
    GLdouble dNear,     GLdouble dFar, 
    GLdouble pickSize, 
    const GLdouble * const worldRotation, 
    const GLdouble * const modelRotation 
)
{
//  GLuint BUFSIZE = 512;
//  GLint selectBuf[ BUFSIZE ];
//  GLint hits;
    GLint viewport[4];
    glGetIntegerv( GL_VIEWPORT, viewport );
    glSelectBuffer( BUFSIZE, selectBuf );
    (void) glRenderMode( GL_SELECT );
    glInitNames();
    glPushName( 0 );
    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadIdentity();
    // Create 5x5 pixel picking region near cursor location
    gluPickMatrix( x, viewport[3] - y, pickSize, pickSize, viewport );
    glOrtho( dLeft, dRight, dBottom, dTop, dNear, dFar );
    glMatrixMode( GL_MODELVIEW );
    glPushMatrix();
    glLoadIdentity();
    if ( worldRotation != NULL ) {
        glMultMatrixd( worldRotation );
    }
    if ( modelRotation != NULL ) {
        glMultMatrixd( modelRotation );
    }
    // Draw All Faces
    for ( int i = 0; i < m_iNoFaces; i++ )
    {
        glLoadName(i);
        glBegin( OpenGL::Enum::POLYGON );
        for ( int j = 0; j < m_prFace[i].GetNoVertices(); ++j )
        {
            // 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();
    }
    glPopMatrix();
    glMatrixMode( GL_PROJECTION );
    glPopMatrix();
    glMatrixMode( GL_MODELVIEW );

    hits = glRenderMode( GL_RENDER );
    ProcessHits( hits, selectBuf, isSelect );
    glutPostRedisplay();
}
//-----------------------------------------------------------------------------
// Process Hits
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::ProcessHits ( 
    GLint hits, GLuint buffer[], bool isSelect ) 
{
    GLuint names, *ptr;
    ptr = (GLuint *) buffer;
    for ( int i = 0; i < hits; ++i ) {
        names = *ptr;
        ++ptr;
        ++ptr;
        ++ptr;
        for ( int j = 0; j < static_cast<int>(names); ++j ) {
            m_pbFaceFixed[*ptr] = isSelect;
            for ( int k = 0; k < m_prFace[*ptr].GetNoVertices(); ++k ) {
                m_pbVertexFixed[ m_prFace[*ptr].GetVertexNo(k) ] = isSelect;
            }
            ++ptr;
        }
    }
}
//-----------------------------------------------------------------------------
// Fix of Unfix vertices contained in a box
template <typename T>
void ExtendedOpenGLVolPresPolygonalModel<T>::FixUnFixVerticesInABox ( 
            bool isToFix, T minX, T maxX, T minY, T maxY, T minZ, T maxZ )
{
    for ( int i = 0; i < GetNoVertices(); ++i ) {
        if ( minX <= m_prXVertex[i][0] && m_prXVertex[i][0] <= maxX ) {
            if ( minY <= m_prXVertex[i][1] && m_prXVertex[i][1] <= maxY ) {
                if ( minZ <= m_prXVertex[i][2] && m_prXVertex[i][2] <= maxZ ) {
                    m_pbVertexFixed[i] = isToFix;
                }
            }
        }
    }
    for ( int j = 0; j < GetNoFaces(); ++j ) {
        m_pbFaceFixed[j] = isToFix;
        for ( int k = 0; k < m_prFace[j].GetNoVertices(); ++k ) {
            if ( m_pbVertexFixed[ m_prFace[j].GetVertexNo(k) ] != isToFix ) {
                m_pbFaceFixed[j] = !isToFix;
            }
        }
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8