TAPsOpenGLModelStrand.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLModelStrand.cpp

Class OpenGLModelStrand is for creating an OpenGL Strand Model.

See class ModelStrand (in "../Model/TAPsModelStrand.hpp") and
class OpenGLSupport ("../OpenGL/TAPsOpenGLSupport.hpp") for detail.

SUKITTI PUNAK   (07/10/2005)
UPDATE          (06/15/2006)
******************************************************************************/
#include "TAPsOpenGLModelStrand.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>
OpenGLModelStrand<T>::OpenGLModelStrand ()
    : ModelStrand<T>(),
      m_iNumSlices( 12 ),
      m_iNumStacks( 3 ) 
      , m_uiDisplayList( 0 )
{
    SetUpOpenGLDisplayList();
    SetMaterial( Enum::BLUE_NAVY );

    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "OpenGLModelStrand<" << typeid(T).name() << "> Default Constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Non-Default Constructor
template <typename T>
OpenGLModelStrand<T>::OpenGLModelStrand (   int iNoLinks, T tLength, T tWeight, 
                                            Vector3<T> & posOfVertex0,
                                            T radius, int numSlices, int numStacks )

    : ModelStrand<T>( iNoLinks, tLength, tWeight, posOfVertex0, radius ),
      m_iNumSlices( numSlices ),
      m_iNumStacks( numStacks )
      , m_uiDisplayList( 0 )
{
    SetUpOpenGLDisplayList();
    SetMaterial( Enum::BLUE_NAVY );

    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "OpenGLModelStrand<" << typeid(T).name() << "> Non-Default Constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Destructor
template <typename T>
OpenGLModelStrand<T>::~OpenGLModelStrand ()
{
    #ifdef  TAPs_ENABLE_DEBUG
    std::cout << "OpenGLModelStrand<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Helper Fn
// void DrawGL ()
template <typename T>
void OpenGLModelStrand<T>::DrawGL ( GLenum drawMode )
{
    glPushAttrib( GL_LIGHTING_BIT );
    //----------------------------------------------------------------
    //glPushAttrib( GL_ALL_ATTRIB_BITS );
    //ApplyMaterial( Enum::FRONT );
//  Math<T>::PI;    // Initialize Math<T>::PI
    Vector3<T> unitZ( 0, 0, 1 );
    Vector3<T> direction;
    T currentLinkLength;
    Vector3<T> rotDir;
    T angle;
    //*
    if ( drawMode == OpenGL::Enum::WIRE_FRAME ) {
        //----------------------------------------------------------------
        // Draw Original Line with Cylinder
        SetMaterial( Enum::METAL_SILVER );
        ApplyMaterial( Enum::FRONT );
        for ( int i = 0; i < m_iNoLinks; ++i ) {
            direction = m_prVertex[i+1] - m_prVertex[i];
            currentLinkLength = direction.Length();
            direction.Normalized();
            angle  = acos( unitZ * direction ) * Math<T>::RAD_TO_DEG;
            rotDir = unitZ ^ direction;
            glPushMatrix();
                glTranslatef( 
                    static_cast<float>( m_prVertex[i][0] ),
                    static_cast<float>( m_prVertex[i][1] ),
                    static_cast<float>( m_prVertex[i][2] )
                );
                glRotatef(
                    angle,
                    static_cast<float>( rotDir[0] ),
                    static_cast<float>( rotDir[1] ),
                    static_cast<float>( rotDir[2] )
                );
                if ( !m_prIsFixed[i] ) {
                    SetMaterial( Enum::METAL_GOLD );
                    ApplyMaterial( Enum::FRONT );
                    glCallList( m_uiDisplayList );
                    SetMaterial( Enum::METAL_SILVER );
                    ApplyMaterial( Enum::FRONT );
                    glScalef( 1, 1, currentLinkLength );
                    glCallList( m_uiDisplayList+1 );
                }
                else {
                    SetMaterial( Enum::METAL_GOLD );
                    ApplyMaterial( Enum::FRONT );
                    glScalef( 4, 4, 4 );
                    glCallList( m_uiDisplayList );
                    SetMaterial( Enum::METAL_SILVER );
                    ApplyMaterial( Enum::FRONT );
                    glScalef( 0.25, 0.25, currentLinkLength*0.25 );
                    //glScalef( 1, 1, currentLinkLength );
                    glCallList( m_uiDisplayList+1 );
                }
            glPopMatrix();
        }
//      DrawTorsions();
    }
    //*/
    if ( true ) {
    //else {
        //----------------------------------------------------------------
        // Draw Subdivision Line with Cylinder
        SetMaterial( Enum::BLUE_NAVY );
        ApplyMaterial( Enum::FRONT );
        if ( drawMode == OpenGL::Enum::POINT ) {
            #ifdef  TAPs_STRAND_LOCK_SEGMENTS
            for ( unsigned int s = 0; s < m_Segments.size(); ++s ) {
                if ( !m_Segments[s].isLocked ) {
                    for ( unsigned int i = m_Segments[s].start*2; i < 2*m_Segments[s].end; ++i )
            #else //TAPs_STRAND_LOCK_SEGMENTS
            {
                {
                    for ( int i = 0; i < 2*m_iNoLinks; ++i )
            #endif//TAPs_STRAND_LOCK_SEGMENTS
                    {
                        glPushMatrix();
                            glTranslatef( 
                                static_cast<float>( m_prDispVertex[i][0] ),
                                static_cast<float>( m_prDispVertex[i][1] ),
                                static_cast<float>( m_prDispVertex[i][2] ) 
                            );
                            glCallList( m_uiDisplayList );
                        glPopMatrix();
                    }
                }
            }
        }
        else {
            #ifdef  TAPs_STRAND_LOCK_SEGMENTS
            for ( unsigned int s = 0; s < m_Segments.size(); ++s ) {
                if ( !m_Segments[s].isLocked ) {
                    for ( unsigned int i = m_Segments[s].start*2; i < 2*m_Segments[s].end-1; ++i )
            #else //TAPs_STRAND_LOCK_SEGMENTS
            {
                {
                    for ( int i = 0; i < 2*m_iNoLinks-1; ++i )
            #endif//TAPs_STRAND_LOCK_SEGMENTS
                    {
                        direction = m_prDispVertex[i+1] - m_prDispVertex[i];
                        currentLinkLength = direction.Length();
                        direction.Normalized();
                        angle  = acos( unitZ * direction ) * Math<T>::RAD_TO_DEG;
                        rotDir = unitZ ^ direction;
                        glPushMatrix();
                            glTranslatef( 
                                static_cast<float>( m_prDispVertex[i][0] ),
                                static_cast<float>( m_prDispVertex[i][1] ),
                                static_cast<float>( m_prDispVertex[i][2] )
                            );
                            glRotatef(
                                angle,
                                static_cast<float>( rotDir[0] ),
                                static_cast<float>( rotDir[1] ),
                                static_cast<float>( rotDir[2] )
                            );
                            glCallList( m_uiDisplayList );
                            glScalef( 1, 1, currentLinkLength );
                            glCallList( m_uiDisplayList+1 );
                        glPopMatrix();
                    }
                }
            }
        }


    //if ( drawMode == OpenGL::Enum::WIRE_FRAME ) {
    //  DrawBB();
    //}


        //*/

        //*
        //------------------------------------------------------------
        // Draw Fixed Point(s)
        if ( m_setOfFixedPts.size() != 0 ) {
            SetMaterial( Enum::METAL_BRONZE );
            ApplyMaterial( Enum::FRONT );
            int p;
            std::set<int>::const_iterator pos  = m_setOfFixedPts.begin();
            for ( int i = 0; i < static_cast<int>( m_setOfFixedPts.size() ); ++i, ++pos ) {
                p = *pos;
                glPushMatrix();
                    glTranslatef( 
                        static_cast<float>( m_prVertex[p][0] ),
                        static_cast<float>( m_prVertex[p][1] ),
                        static_cast<float>( m_prVertex[p][2] )
                    );
                    glScalef( 2, 2, 2 );
                    glCallList( m_uiDisplayList );
                glPopMatrix();
            }
        }
        //*/
    }
    /*
    //----------------------------------------------------------------
    // Draw Catmull-Rom spline
    if ( drawMode == GL_POINTS ) {
        SetMaterial( Enum::METAL_BRONZE );
        ApplyMaterial( Enum::FRONT );
        static Vector3<T> p;
        //std::set<int>::iterator p0 = m_setiD3BezierCurShape.begin();
        std::set<int>::iterator p1 = p0; ++p1;
        std::set<int>::iterator p2 = p1; ++p2;
        std::set<int>::iterator p3 = p2; ++p3;
        for ( int i = 0; i < static_cast<int>( m_setiD3BezierCurShape.size()-3 ); ++i ) {
            for ( float t = 0.0f; t <= 1.0f; t+=0.025f ) {
                p = CGMath<T>::CatmullRomSplinePt( 
                                m_prVertex[*p0],
                                m_prVertex[*p1],
                                m_prVertex[*p2],
                                m_prVertex[*p3], t );
                glPushMatrix();
                    glTranslatef( 
                        static_cast<float>( p[0] ),
                        static_cast<float>( p[1] ),
                        static_cast<float>( p[2] ) 
                    );
                    if ( t == 0.0f )    glScalef( 1, 1, 1 );
                    else                glScalef( 0.5, 0.5, 0.5 );
                    glCallList( m_uiDisplayList );
                glPopMatrix();
            }
            ++p0; ++p1; ++p2; ++p3;
        }
    }
    //*/
    //----------------------------------------------------------------
    glPopAttrib();
    //----------------------------------------------------------------
    //DrawTorsions();
    //DrawOrigShape();
    //----------------------------------------------------------------
//  if ( drawMode == GL_POINTS ) {
//          DrawBezierCurve();
//  }
}
/*
//-----------------------------------------------------------------------------
// Helper Fn
// DrawTorsions Fn
template <typename T>
void OpenGLModelStrand<T>::DrawTorsions ()
{
    Vector3<T> unitZ( 0, 0, 1 );
    Vector3<T> direction;
    T currentLinkLength;
    Vector3<T> rotDir;
    T angle;
//  Math<T>::PI;    // Initialize Math<T>::PI
    //----------------------------------------------------------------
    SetMaterial( Enum::RED );
    ApplyMaterial( Enum::FRONT );
    for ( int i = 0; i <= m_iNoLinks; ++i ) {
        direction = m_prVertex[i+1] - m_prVertex[i];
        currentLinkLength = direction.Length();
        direction.Normalized();
        angle  = acos( unitZ * direction ) * Math<T>::RAD_TO_DEG;
        rotDir = unitZ ^ direction;
        //------------------------------------------------------
        glPushMatrix();
        glTranslatef( 
            static_cast<float>( m_prVertex[i][0] ),
            static_cast<float>( m_prVertex[i][1] ),
            static_cast<float>( m_prVertex[i][2] ) );
        glRotatef(
            m_prDegRot[i],
            static_cast<float>( m_prVertex[i][0] ),
            static_cast<float>( m_prVertex[i][1] ),
            static_cast<float>( m_prVertex[i][2] )
        );
        glScalef( 0.03, 0.03, 0.03 );
        Obj::DrawOneHeadArrow();
        glPopMatrix();
    }
}
//*/
//-----------------------------------------------------------------------------
// Helper Fn
// void SetUpOpenGLDisplayList ()
template <typename T>
void OpenGLModelStrand<T>::SetUpOpenGLDisplayList ()
{
    if ( !m_uiDisplayList ) {
        m_uiDisplayList = glGenLists( 2 );
        GLUquadricObj *qObj = gluNewQuadric();
        //------------------------------------------------------------
        // Sphere with strand radius
        glNewList( m_uiDisplayList, GL_COMPILE );
            gluSphere( qObj, m_tRadius, m_iNumSlices, m_iNumStacks );
        glEndList();
        //------------------------------------------------------------
        // Cylinder with strand radius and length one which must be 
        // scaled by the current link length of each link in 
        // z-coordinate
        glNewList( m_uiDisplayList+1, GL_COMPILE );
            gluCylinder( qObj, m_tRadius, m_tRadius, 
                    1.0, m_iNumSlices, m_iNumStacks );
        glEndList();
        gluDeleteQuadric( qObj );
    }
}
/*
//-----------------------------------------------------------------------------
// Helper Fn
// DrawBezierCurve Fn
template <typename T>
void OpenGLModelStrand<T>::DrawBezierCurve ()
{
    static Vector3<T> P[4], T0, T3;
    //T LENGTH = (m_iLoopSize-1) / 1.95 * m_tLinkLength;    
    // e.g. 12 segments <==> 2 subdivisions of cublic Bezier curve
    T tLength;
    T A;
    static const int iNumSub = 3;
    static const int iNumCurvePts = 25; // depends on # of subdivisions
                                        // 1 -> 7, 2 -> 13, 3 -> 25, 4 -> 49 
    static T offset = 0;
    static Vector3<T> pt[iNumCurvePts];
    //----------------------------------------------------------------
    // Draw Bezier Ctrl Pts and Curves
    Vector3<T> unitZ( 0, 0, 1 );
    Vector3<T> direction;
    T currentLinkLength;
    Vector3<T> rotDir;
    T angle;
    int p;
    std::set<int>::iterator p0 = m_setiD3BezierCurShape.begin();
    std::set<int>::iterator p1 = p0; ++p1;
    std::set<int>::iterator p2 = p1; ++p2;
    std::set<int>::iterator p3 = p2; ++p3;
    T3 = ( m_prVertex[*p0] - m_prVertex[*p1] ).Normalized();
    for ( int i = 0; i < static_cast<int>( m_setiD3BezierCurShape.size() ) - 3; ++i ) {
        //------------------------------------------------------
        // Draw Bezier Ctrl Pts
        p = *p0;
        SetMaterial( Enum::RED );
        ApplyMaterial( Enum::FRONT );
        glPushMatrix();
            glTranslatef( 
                static_cast<float>( m_prVertex[p][0] ),
                static_cast<float>( m_prVertex[p][1] + offset ),
                static_cast<float>( m_prVertex[p][2] )
            );
            glScalef( 2, 2, 2 );
            glCallList( m_uiDisplayList );
        glPopMatrix();
        //------------------------------------------------------
        // Draw Bezier Curves
        SetMaterial( Enum::BLUE );
        ApplyMaterial( Enum::FRONT );
        P[0] = m_prVertex[*p1];
        P[3] = m_prVertex[*p2];
        T0 = -T3;
        T3 = ( P[3] - m_prVertex[*p3] ).Normalized();
        tLength = (*p2 - *p1) * m_tLinkLength * 1.0000001;
        A = CGMath<T>::SolveAForConstCubicBezierCurveLength( P[0], P[3], T0, T3, iNumSub, tLength, 0.00000001, pt );
        ++p0; ++p1; ++p2; ++p3;
        //------------------------------------------------------
        // Draw cubic Bezier ctrl pts
        P[1] = P[0] + A*T0;
        P[2] = P[3] + A*T3;
        for ( int p = 0; p < 3; ++p ) {
            direction = P[p+1] - P[p];
            currentLinkLength = direction.Length();
            direction.Normalized();
            angle  = acos( unitZ * direction ) * Math<T>::RAD_TO_DEG;
            rotDir = unitZ ^ direction;
            glPushMatrix();
                glTranslatef( 
                    static_cast<float>( P[p][0] ),
                    static_cast<float>( P[p][1] + offset ),
                    static_cast<float>( P[p][2] )
                );
                glRotatef(
                    angle,
                    static_cast<float>( rotDir[0] ),
                    static_cast<float>( rotDir[1] ),
                    static_cast<float>( rotDir[2] )
                );
                //glCallList( m_uiDisplayList );
                glScalef( 0.25, 0.25, currentLinkLength );
                glCallList( m_uiDisplayList+1 );
            glPopMatrix();
        }
        //------------------------------------------------------
        for ( int p = 0; p < iNumCurvePts-1; ++p ) {
            direction = pt[p+1] - pt[p];
            currentLinkLength = direction.Length();
            direction.Normalized();
            angle  = acos( unitZ * direction ) * Math<T>::RAD_TO_DEG;
            rotDir = unitZ ^ direction;
            glPushMatrix();
                glTranslatef( 
                    static_cast<float>( pt[p][0] ),
                    static_cast<float>( pt[p][1] + offset ),
                    static_cast<float>( pt[p][2] )
                );
                glRotatef(
                    angle,
                    static_cast<float>( rotDir[0] ),
                    static_cast<float>( rotDir[1] ),
                    static_cast<float>( rotDir[2] )
                );
                //glCallList( m_uiDisplayList );
                glScalef( 1, 1, currentLinkLength );
                glCallList( m_uiDisplayList+1 );
            glPopMatrix();
        }
    }
}
//*/


/*
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLModelStrand<T>::DrawBB ()
{
    Vector3<T> unitZ( 0, 0, 1 );
    Vector3<T> direction;
    T currentLinkLength;
    Vector3<T> rotDir;
    T angle;
    T offset = 0;
    for ( int i = 0; i < 512; ++i ) {
        //------------------------------------------------------
        // Draw Bezier Ctrl Pts
        SetMaterial( Enum::GREEN );
        ApplyMaterial( Enum::FRONT );
        glPushMatrix();
            glTranslatef( 
                static_cast<float>( QQQ[i][0] ),
                static_cast<float>( QQQ[i][1] + offset ),
                static_cast<float>( QQQ[i][2] )
            );
            glScalef( 1, 1, 1 );
            glCallList( m_uiDisplayList );
        glPopMatrix();
    }
    for ( int p = 0; p < 128; ++p ) {
        direction = CCC[p+1] - CCC[p];
        currentLinkLength = direction.Length();
        direction.Normalized();
        angle  = acos( unitZ * direction ) * Math<T>::RAD_TO_DEG;
        rotDir = unitZ ^ direction;
        glPushMatrix();
            glTranslatef( 
                static_cast<float>( CCC[p][0] ),
                static_cast<float>( CCC[p][1] + offset ),
                static_cast<float>( CCC[p][2] )
            );
            glRotatef(
                angle,
                static_cast<float>( rotDir[0] ),
                static_cast<float>( rotDir[1] ),
                static_cast<float>( rotDir[2] )
            );
            //glCallList( m_uiDisplayList );
            glScalef( 0.15, 0.15, currentLinkLength );
            //glScalef( 5, 5, 5 );
            glCallList( m_uiDisplayList+1 );
        glPopMatrix();
    }

    glDisable( GL_LIGHTING );
    for ( int p = 0; p < 128; ++p ) {
        int rem = p % 4;
        T scale;
        switch ( rem ) {
            case 0:
                glColor3f( 1, 0, 0 );
                scale = 3;
                break;
            case 1:
                glColor3f( 0, 1, 0 );
                scale = 2;
                break;
            case 2:
                glColor3f( 0, 0, 1 );
                scale = 2;
                break;
            case 3:
                glColor3f( 1, 1, 0 );
                scale = 2.5;
                break;
        }
        glPushMatrix();
            glTranslatef( 
                static_cast<float>( CCC[p][0] ),
                static_cast<float>( CCC[p][1] + offset ),
                static_cast<float>( CCC[p][2] )
            );
            glScalef( scale, scale, scale );
            glCallList( m_uiDisplayList );
        glPopMatrix();
    }
    glEnable( GL_LIGHTING );

    std::set<int>::iterator p0 = m_setiD3BezierCurShape.begin();
    for ( int i = 0; i < static_cast<int>( m_setiD3BezierCurShape.size() ); ++i ) {
        //------------------------------------------------------
        // Draw Bezier Ctrl Pts
        p = *p0;
        SetMaterial( Enum::RED );
        ApplyMaterial( Enum::FRONT );
        glPushMatrix();
            glTranslatef( 
                static_cast<float>( m_prVertex[p][0] ),
                static_cast<float>( m_prVertex[p][1] + offset ),
                static_cast<float>( m_prVertex[p][2] )
            );
            glScalef( 2, 2, 2 );
            glCallList( m_uiDisplayList );
        glPopMatrix();
        ++p0;
    }
}
//*/
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8