TAPsOpenGLPNTriangleModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLPNTriangleModel.cpp

(X <==> Extra)
Class TAPsOpenGLPNTriangleModel is for creating an OpenGL PN-Triangle Model.

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

SUKITTI PUNAK   (03/25/2005)
UPDATE          (05/29/2005)
******************************************************************************/
#include "TAPsOpenGLXTrigonalModel.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>
OpenGLPNTriangleModel<T>::OpenGLPNTriangleModel()
    : XTrigonalModel<T>()
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "OpenGLPNTriangleModel<" << typeid(T).name() << "> constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
OpenGLPNTriangleModel<T>::~OpenGLPNTriangleModel()
{
    if ( m_prPNTriCoef != NULL ) delete [] m_prPNTriCoef;
    if ( m_prPNTriNormal != NULL ) delete [] m_prPNTriNormal;

    #ifdef  TAPs_DEBUG_MODE
    std::cout << "OpenGLPNTriangleModel<" << typeid(T).name() << "> destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Initialize
template <typename T>
void OpenGLPNTriangleModel<T>::Initialize ()
{
    XPolygonalModel<T>::Initialize();
    CreateAndCalPNTriangles();
}
//-----------------------------------------------------------------------------
// (Helper Fn) CreateAndCalPNTriangles
template <typename T>
void OpenGLPNTriangleModel<T>::CreateAndCalPNTriangles () {
    if ( !AllocatePNTriangleCoefficients() ) exit(1);
    if ( !AllocatePNTriangleNormals() )  exit(1);
    InitializePNTriangleCoefficients();
    InitializePNTriangleNormals();
    CalculatePNTriangleCoefficients();
    CalculatePNTriangleNormals();
}
//-----------------------------------------------------------------------------
// (Helper Fn) AllocatePNTriangleCoefficients
template <typename T>
bool OpenGLPNTriangleModel<T>::AllocatePNTriangleCoefficients () {
    m_prPNTriCoef = new float[GetNoFaces()*10*3];
    if ( m_prPNTriCoef ) return true;
    return false;
}
//-----------------------------------------------------------------------------
// (Helper Fn) AllocatePNTriangleNormals
template <typename T>
bool OpenGLPNTriangleModel<T>::AllocatePNTriangleNormals () {
    m_prPNTriNormal = new float[GetNoFaces()*6*3];
    if ( m_prPNTriNormal ) return true;
    return false;
}
//-----------------------------------------------------------------------------
// (Helper Fn) InitializePNTriangleCoefficients
template <typename T>
void OpenGLPNTriangleModel<T>::InitializePNTriangleCoefficients () {
    // Coefficients or Control Points
    //                    b003                              9
    //                    /  \
    //                  /      \
    //               b102      b012                       7   8
    //              /              \           <===>    
    //            /                  \
    //         b201       b111       b021               4   5  6
    //        /                          \
    //      /                              \
    //     b300 ---- b210 ---- b120 ---- b030          0  1  2  3
    int b = 0;
    Vector3<T> *P1, *P2, *P3;
    for ( int f = 0; f < GetNoFaces(); ++f, b+=30 ) {
        // Initialize b300, b030, and b003
        P1 = &m_prXVertex[ m_prFace[f].GetVertexNo(0) ].GetPosition();
        P2 = &m_prXVertex[ m_prFace[f].GetVertexNo(1) ].GetPosition();
        P3 = &m_prXVertex[ m_prFace[f].GetVertexNo(2) ].GetPosition();
        for ( int i = 0; i < 3; ++i ) {
            *(m_prPNTriCoef+b+i)    = (*P1)[i];     // b300
            *(m_prPNTriCoef+b+9+i)  = (*P2)[i];     // b030
            *(m_prPNTriCoef+b+27+i) = (*P3)[i];     // b003
        }
    }
}
//-----------------------------------------------------------------------------
// (Helper Fn) InitializePNTriangleNormals
template <typename T>
void OpenGLPNTriangleModel<T>::InitializePNTriangleNormals () {
    // Normals
    //              n002                        5
    //              /  \
    //            /      \
    //         n101      n011        <===>    3  4
    //        /              \
    //      /                  \
    //    n200 ---- n110 ---- n020          0  1  2
    int n = 0;
    Vector3<T> *N1, *N2, *N3;
    for ( int f = 0; f < GetNoFaces(); ++f, n+=18 ) {
        // Initialize n200, n020, and n002
        N1 = &m_prXVertex[ m_prFace[f].GetVertexNo(0) ].GetNormal();
        N2 = &m_prXVertex[ m_prFace[f].GetVertexNo(1) ].GetNormal();
        N3 = &m_prXVertex[ m_prFace[f].GetVertexNo(2) ].GetNormal();
        for ( int i = 0; i < 3; ++i ) {
            *(m_prPNTriNormal+n+i)    = (*N1)[i];   // n200
            *(m_prPNTriNormal+n+6+i)  = (*N2)[i];   // n020
            *(m_prPNTriNormal+n+15+i) = (*N3)[i];   // n002
        }
    }
}
//-----------------------------------------------------------------------------
// (Helper Fn) CalculatePNTriangleVertices
template <typename T>
void OpenGLPNTriangleModel<T>::CalculatePNTriangleCoefficients () {
    // Coefficients or Control Points
    //                    b003                              9
    //                    /  \
    //                  /      \
    //               b102      b012                       7   8
    //              /              \           <===>    
    //            /                  \
    //         b201       b111       b021               4   5  6
    //        /                          \
    //      /                              \
    //     b300 ---- b210 ---- b120 ---- b030          0  1  2  3
    int b = 0;
    Vector3<T> *P1, *P2, *P3;
    Vector3<T> *N1, *N2, *N3;
    Vector3<T> temp, sum;
    T w12, w21, w23, w32, w31, w13;
    for ( int f = 0; f < GetNoFaces(); ++f ) {
        P1 = &m_prXVertex[ m_prFace[f].GetVertexNo(0) ].GetPosition();
        P2 = &m_prXVertex[ m_prFace[f].GetVertexNo(1) ].GetPosition();
        P3 = &m_prXVertex[ m_prFace[f].GetVertexNo(2) ].GetPosition();
        N1 = &m_prXVertex[ m_prFace[f].GetVertexNo(0) ].GetNormal();
        N2 = &m_prXVertex[ m_prFace[f].GetVertexNo(1) ].GetNormal();
        N3 = &m_prXVertex[ m_prFace[f].GetVertexNo(2) ].GetNormal();
        // Calculate w12, w23, and w31
        w12 = ( (*P2) - (*P1) ) * (*N1);
        w21 = ( (*P1) - (*P2) ) * (*N2);
        w23 = ( (*P3) - (*P2) ) * (*N2);
        w32 = ( (*P2) - (*P3) ) * (*N3);
        w31 = ( (*P1) - (*P3) ) * (*N3);
        w13 = ( (*P3) - (*P1) ) * (*N1);
        // b210
        b += 3;
        sum = temp = (2*(*P1) + (*P2) - w12*(*N1)) / 3.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];
        // b120
        b += 3;
        sum += temp = (2*(*P2) + (*P1) - w21*(*N2)) / 3.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];
        // b021
        b += 12;
        sum += temp = (2*(*P2) + (*P3) - w23*(*N2)) / 3.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];
        // b012
        b += 6;
        sum += temp = (2*(*P3) + (*P2) - w32*(*N3)) / 3.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];
        // b102
        b -= 3;
        sum += temp = (2*(*P3) + (*P1) - w31*(*N3)) / 3.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];
        // b201
        b -= 9;
        sum += temp = (2*(*P1) + (*P3) - w13*(*N1)) / 3.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];
        // b111
        b += 3;
        sum /= 6.0;
        temp = (*P1 + *P2 + *P3) / 3.0;
        temp = sum + (sum - temp) / 2.0;
        *(m_prPNTriCoef+b)   = temp[0];
        *(m_prPNTriCoef+b+1) = temp[1];
        *(m_prPNTriCoef+b+2) = temp[2];

        b += 15;    // update b index
    }
}
//-----------------------------------------------------------------------------
// (Helper Fn) CalculatePNTriangleNormals
template <typename T>
void OpenGLPNTriangleModel<T>::CalculatePNTriangleNormals () {
    // Normals
    //              n002                        5
    //              /  \
    //            /      \
    //         n101      n011        <===>    3  4
    //        /              \
    //      /                  \
    //    n200 ---- n110 ---- n020          0  1  2
    int n = 0;
    Vector3<T> *P1, *P2, *P3;
    Vector3<T> *N1, *N2, *N3;
    Vector3<T> temp;
    T v12, v23, v31;
    for ( int f = 0; f < GetNoFaces(); ++f ) {
        P1 = &m_prXVertex[ m_prFace[f].GetVertexNo(0) ].GetPosition();
        P2 = &m_prXVertex[ m_prFace[f].GetVertexNo(1) ].GetPosition();
        P3 = &m_prXVertex[ m_prFace[f].GetVertexNo(2) ].GetPosition();
        N1 = &m_prXVertex[ m_prFace[f].GetVertexNo(0) ].GetNormal();
        N2 = &m_prXVertex[ m_prFace[f].GetVertexNo(1) ].GetNormal();
        N3 = &m_prXVertex[ m_prFace[f].GetVertexNo(2) ].GetNormal();
        //cout << *N1 << " " << *N2 << " " << *N3 << endl;
        Vector3<T> p12(*P2 - *P1);
        Vector3<T> p23(*P3 - *P2);
        Vector3<T> p31(*P1 - *P3);
        Vector3<T> n12(*N2 + *N1);
        Vector3<T> n23(*N3 + *N2);
        Vector3<T> n31(*N1 + *N3);
        v12 = 2.0 * (p12 * n12) / (p12 * p12);
        v23 = 2.0 * (p23 * n23) / (p23 * p23);
        v31 = 2.0 * (p31 * n31) / (p31 * p31);
        // n110
        temp = (n12 - v12*p12).Normalized();
        n += 3;
        *(m_prPNTriNormal+n)   = temp[0];
        *(m_prPNTriNormal+n+1) = temp[1];
        *(m_prPNTriNormal+n+2) = temp[2];
        // n101
        temp = (n23 - v23*p23).Normalized();
        n += 6;
        *(m_prPNTriNormal+n)   = temp[0];
        *(m_prPNTriNormal+n+1) = temp[1];
        *(m_prPNTriNormal+n+2) = temp[2];
        // n011
        temp = (n31 - v31*p31).Normalized();
        n += 3;
        *(m_prPNTriNormal+n)   = temp[0];
        *(m_prPNTriNormal+n+1) = temp[1];
        *(m_prPNTriNormal+n+2) = temp[2];
        n += 6; // update n index
    }
}
//-----------------------------------------------------------------------------
// (Helper Fn) DrawTriBezierPatchNo
template <typename T>
void OpenGLPNTriangleModel<T>::DrawTriBezierPatchNo(int noOfFaces, int smoothness) {
    int noOfVertices = smoothness*(smoothness+1)/2;
    float *vertex = new float[noOfVertices*3];
    float *normal = new float[noOfVertices*3];
    float uInc = 1.0 / (smoothness-1);
    float vInc = 1.0 / (smoothness-1);
    float uu, vv, ww;
    for ( int faceNo = 0; faceNo < noOfFaces; ++faceNo ) {
        int index = 0;
        float u = 0.0f, v = 0.0f, w;
        int bCount = faceNo * 30;
        int nCount = faceNo * 18;
        float *b = m_prPNTriCoef;
        float *n = m_prPNTriNormal;
        for ( int i = 0; i < smoothness; ++i, u += uInc ) {
            v = 0.0f;
            for ( int j = 0; j < smoothness; ++j, v += vInc ) {
                w = 1.0f - u - v;
                if ( w < -0.0000001f ) break;
                ww = w*w;
                uu = u*u;
                vv = v*v;
                T magnitude = 0.0;
                for ( int d = 0; d < 3; ++d, ++index ) {
                    vertex[index] =     b[bCount+d]*ww*w + b[bCount+9+d]*uu*u + b[bCount+27+d]*vv*v
                                        + 3.0f*(   b[bCount+3+d]*ww*u  + b[bCount+6+d]*w*uu 
                                                + b[bCount+12+d]*ww*v + b[bCount+18+d]*uu*v
                                                + b[bCount+21+d]*w*vv + b[bCount+24+d]*u*vv )
                                        + b[bCount+15+d]*6.0f*w*u*v;
                    normal[index] =   n[nCount+d]*ww + n[nCount+6+d]*uu + n[nCount+15+d]*vv
                                    + n[nCount+3+d]*w*u + n[nCount+9+d]*u*v + n[nCount+12+d]*w*v;
                    magnitude += normal[index]*normal[index];
                }
                magnitude = sqrt(magnitude);
                normal[index-3] /= magnitude;
                normal[index-2] /= magnitude;
                normal[index-1] /= magnitude;
            }
        }
        /*
        glPointSize(11);
        int pos = 0;
        glBegin( GL_POINTS );
            for ( int i = 0; i < noOfVertices; ++i, pos+=3 ) {
                glVertex3f( vertex[pos], vertex[pos+1], vertex[pos+2] );
            }
        glEnd();
        */

        int row1 = 0, row2 = smoothness*3;
        for ( int r = 1; r < smoothness; ++r, row1+=3 ) {
            glBegin( GL_TRIANGLE_STRIP );
                for ( int i = 0; i < smoothness-r; ++i, row1+=3, row2+=3 ) {
                    glNormal3f( normal[row1], normal[row1+1], normal[row1+2] );
                    glVertex3f( vertex[row1], vertex[row1+1], vertex[row1+2] );
                    glNormal3f( normal[row2], normal[row2+1], normal[row2+2] );
                    glVertex3f( vertex[row2], vertex[row2+1], vertex[row2+2] );
                }
                glNormal3f( normal[row1], normal[row1+1], normal[row1+2] );
                glVertex3f( vertex[row1], vertex[row1+1], vertex[row1+2] );
            glEnd();
        }
        /*
        row1 = 0;
        for ( int r = 0; r < noOfVertices; ++r, row1+=3 ) {
            glBegin( GL_LINES );
                GLfloat ppp[3];
                ppp[0]= normal[row1]+vertex[row1];
                ppp[1]= normal[row1+1]+vertex[row1+1];
                ppp[2]= normal[row1+2]+vertex[row1+2];
                    glVertex3f( vertex[row1], vertex[row1+1], vertex[row1+2] );
                    glVertex3fv( ppp );
            glEnd();
        }*/
        /*
        int idx = 0;
        DrawText( "b300", 
            static_cast<float>( vertex[idx] ),
            static_cast<float>( vertex[idx+1] ),
            static_cast<float>( vertex[idx+2] ) );
        idx = (smoothness-1)*3;
        DrawText( "b030", 
            static_cast<float>( vertex[idx] ),
            static_cast<float>( vertex[idx+1] ),
            static_cast<float>( vertex[idx+2] ) );
        idx = (noOfVertices-1)*3;
        DrawText( "b003", 
            static_cast<float>( vertex[idx] ),
            static_cast<float>( vertex[idx+1] ),
            static_cast<float>( vertex[idx+2] ) );
        */
    }
    delete [] vertex;
    delete [] normal;
}
/*
//-----------------------------------------------------------------------------
//void DisplayGL()
template <typename T>
void OpenGLPNTriangleModel<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 OpenGLPNTriangleModel<T>::DrawGL( GLenum drawMode )
{
    //if ( isFacetShading ) {
    if ( false ) {
        // 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 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 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();
        }
        //glDisable( GL_TEXTURE_2D );
    }
    else {
        // Draw the object
        //glEnable( GL_TEXTURE_2D );

        int b[3] = { 0, 9, 27 }, n[3] = { 0, 6, 15 };

        /*
        // For FPS
        clock_t start, finish;
        start = clock();
        */
        //for ( int i = 0; i < m_iNoFaces; ++i )
        {
            #ifdef TAPs_USE_GLSL
            if ( gbUseGPU ) {   // draw by GLSL hardware
                //setUniformVariables();
                //DrawPNTrianglePatch(i, 10, m_prPNTriCoef, m_prPNTriNormal);
                #ifdef TAPs_SHADER_FNS_HPP
                DrawTriangleUsingHardware(m_iNoFaces, 10, m_prPNTriCoef, m_prPNTriNormal);
                #endif
            }
            else {  // draw by CPU software
                // Draw Bezier Patch
                //DrawTriBezierPatchNo(i, 10);
                DrawTriBezierPatchNo(m_iNoFaces, 10);
            }
            #else   // draw by CPU software
            DrawTriBezierPatchNo(m_iNoFaces, 10);
            #endif

            /*
            glBegin( GL_LINE_LOOP );
            for ( int j = 0; j < 3; ++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_prPNTriNormal[n[j]  ] ),
                             static_cast<float>( m_prPNTriNormal[n[j]+1] ),
                             static_cast<float>( m_prPNTriNormal[n[j]+2] ) );
                // Draw the vertex
                glVertex3f ( 
                    static_cast<float>( m_prPNTriCoef[ b[j]  ] ),
                    static_cast<float>( m_prPNTriCoef[ b[j]+1] ),
                    static_cast<float>( m_prPNTriCoef[ b[j]+2] ) );
            }
            glEnd();
            */

            /*
            DrawText( "b300", 
                    static_cast<float>( m_prPNTriCoef[ b[0]  ] ),
                    static_cast<float>( m_prPNTriCoef[ b[0]+1] ),
                    static_cast<float>( m_prPNTriCoef[ b[0]+2] ) );
            DrawText( "b030", 
                    static_cast<float>( m_prPNTriCoef[ b[1]  ] ),
                    static_cast<float>( m_prPNTriCoef[ b[1]+1] ),
                    static_cast<float>( m_prPNTriCoef[ b[1]+2] ) );
            DrawText( "b003", 
                    static_cast<float>( m_prPNTriCoef[ b[2]  ] ),
                    static_cast<float>( m_prPNTriCoef[ b[2]+1] ),
                    static_cast<float>( m_prPNTriCoef[ b[2]+2] ) );
            */

            /*
            // Draw Bezier control points
            glPointSize(5);
            glDisable(GL_LIGHTING);
            int s;
            glBegin( GL_POINTS );
            for ( s = 0; s < 30; s+=3 ) {
                // Draw the vertex
                glColor3ub( s*25, 0, 0 );
                glVertex3f (
                    static_cast<float>( m_prPNTriCoef[ b[0]+s   ] ),
                    static_cast<float>( m_prPNTriCoef[ b[0]+s+1 ] ),
                    static_cast<float>( m_prPNTriCoef[ b[0]+s+2 ] ) );
            }
            glEnd();
            */

            /*
            DrawText( "b300", 
                static_cast<float>( m_prPNTriCoef[ b[0]  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+2] ) );
            DrawText( "b210", 
                static_cast<float>( m_prPNTriCoef[ b[0]+3] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+4] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+5] ) );
            DrawText( "b120", 
                static_cast<float>( m_prPNTriCoef[ b[0]+6] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+7] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+8] ) );
            DrawText( "b030", 
                static_cast<float>( m_prPNTriCoef[ b[0]+9 ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+10] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+11] ) );
            DrawText( "b201", 
                static_cast<float>( m_prPNTriCoef[ b[0]+12] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+13] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+14] ) );
            DrawText( "b111", 
                static_cast<float>( m_prPNTriCoef[ b[0]+15] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+16] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+17] ) );
            DrawText( "b021", 
                static_cast<float>( m_prPNTriCoef[ b[0]+18] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+19] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+20] ) );
            DrawText( "b102", 
                static_cast<float>( m_prPNTriCoef[ b[0]+21] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+22] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+23] ) );
            DrawText( "b012", 
                static_cast<float>( m_prPNTriCoef[ b[0]+24] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+25] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+26] ) );
            DrawText( "b003", 
                static_cast<float>( m_prPNTriCoef[ b[0]+27] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+28] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+29] ) );
            */

            /*
            // Draw lines connecting Bezier control points
            glColor3ub( 0, 220, 0 );
            glBegin( GL_LINE_LOOP );
            s = 0;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 3;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 6;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 9;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 18;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 24;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 27;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 21;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 12;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            glEnd();
            glBegin( GL_LINE_LOOP );
            s = 3;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 12;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 15;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            glEnd();
            glBegin( GL_LINE_LOOP );
            s = 6;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 15;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 18;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            glEnd();
            glBegin( GL_LINE_LOOP );
            s = 15;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 21;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            s = 24;
            glVertex3f ( 
                static_cast<float>( m_prPNTriCoef[ b[0]+s  ] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+1] ),
                static_cast<float>( m_prPNTriCoef[ b[0]+s+2] ) );
            glEnd();
            */

            //glEnable(GL_LIGHTING);
            /*
            b[0] += 30;
            b[1] += 30;
            b[2] += 30;
            n[0] += 18;
            n[1] += 18;
            n[2] += 18;
            */
        }
        /*
        // For FPS
        finish = clock();
        double duration = static_cast<double>(finish - start);
        int dFPS;
        if ( duration > 0.0 ) {
            dFPS = CLOCKS_PER_SEC / duration;
        }
        else {
            dFPS = 1000;
        }
        std::cout << "FPs: " << dFPS << "\n";
        */

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