TAPsOpenGLFns.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLFns.cpp

OpenGL Global Functions.

SUKITTI PUNAK   (10/04/2004)
UPDATE          (10/27/2004)
******************************************************************************/
#include "TAPsOpenGLFns.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__Fn
//=============================================================================
// START:  GLOBAL VARIABLE(S)
//-----------------------------------------------------------------------------
// GLenum
//GLenum g_eCullFace = GL_BACK;
//GLenum g_eDrawFace = GL_FRONT_AND_BACK;
//GLenum g_eDrawMode = GL_FILL;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// END:  GLOBAL VARIABLE(S)
//=============================================================================
GLuint g_uiGLFontDisplayList = 0;
GLuint GetGLFontDisplayList () { return g_uiGLFontDisplayList; }
//=============================================================================
// START:  OPENGL DEBUG/ERROR
//-----------------------------------------------------------------------------
// Check OpenGL Error
#ifdef TAPs_DEBUG_MODE
    void GFnCheckGLError ( char * file, int line, int * glErrCode )
    {
        GLenum glErr = glGetError();
        int errCode = 0;
        while ( glErr != GL_NO_ERROR ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "GL Error #%d (%s) in file %s at line#%d" ), 
                        glErr, gluErrorString(glErr), file, line );
        #else
            std::cout
                << "GL Error #" << glErr << " (" << gluErrorString(glErr) << ") "
                << "in file " << file << " at line#" << line << std::endl;
        #endif
            errCode = 1;
            glErr = glGetError();
        }
        if ( glErrCode )    *glErrCode = errCode;
    }
#else
    void GFnCheckGLError ( char *file, int line, int * glErrCode ) {}
#endif
#define CHECK_GL_ERROR() GFnCheckGLError( __FILE__, __LINE__ )
//-----------------------------------------------------------------------------
// Check OpenGL Error with Custom Message
#ifdef TAPs_DEBUG_MODE
    void GFnCheckGLError ( char * customMessage, int * glErrCode )
    {
        GLenum glErr = glGetError();
        int errCode = 0;
        while ( glErr != GL_NO_ERROR ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "%s --> GL Error #%d (%s)!" ), 
                        customMessage, glErr, gluErrorString(glErr) );
        #else
            std::cerr
                << customMessage << " --> GL Error #" << glErr 
                << " (" << gluErrorString(glErr) << ")!" << std::endl;
        #endif
            errCode = 1;
            glErr = glGetError();
        }
        if ( glErrCode )    *glErrCode = errCode;
    }
#else
    void GFnCheckGLError ( char * customMessage, int * glErrCode ) {}
#endif
#define CHECK_GL_ERROR_MESSAGE( s ) GFnCheckGLError( s )
//-----------------------------------------------------------------------------
// Check OpenGL Frame Buffer Status
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_GLSL
    void GFnCheckFrameBufferStatus ()
    {
        //---------------------------------------------------------------
        switch ( glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ) ) {
        case GL_FRAMEBUFFER_COMPLETE_EXT:
            break;
        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" << std::endl;
            #endif
            break;
        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" << std::endl;
            #endif
            break;
        case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" << std::endl;
            #endif
            break;
        case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" << std::endl;
            #endif
            break;
        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" << std::endl;
            #endif
            break;
        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" << std::endl;
            #endif
            break;
        case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_UNSUPPORTED_EXT" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): GL_FRAMEBUFFER_UNSUPPORTED_EXT" << std::endl;
            #endif
            break;
        default:
            #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR (GLEXTFrameBufferObject): UNKNOWN ERROR!" ) );
            #else
            std::cout << "ERROR (GLEXTFrameBufferObject): UNKNOWN ERROR!" << std::endl;
            #endif
            break;
        }
    }
#else
    void GFnCheckFrameBufferStatus () {}
#endif
#else
    void GFnCheckFrameBufferStatus () {}
#endif
#define CHECK_FRAMEBUFFER_STATUS()  GFnCheckFrameBufferStatus()
//-----------------------------------------------------------------------------
// END:  OPENGL DEBUG/ERROR
//=============================================================================

//=============================================================================
// START:  OPENGL LIGHTING
//-----------------------------------------------------------------------------
// Initialize and Enable the Light (with the Default Values)
// The light is a GLenum, which can be (at least 8 lights) from 
// GL_LIGHT0, GL_LIGHT1,..., or GL_LIGHT7.
void InitializeLight(   GLenum light,
                        GLfloat a0, GLfloat a1, GLfloat a2, GLfloat a3,
                        GLfloat d0, GLfloat d1, GLfloat d2, GLfloat d3,
                        GLfloat s0, GLfloat s1, GLfloat s2, GLfloat s3,
                        GLfloat p0, GLfloat p1, GLfloat p2, GLfloat p3
)
{
    // Light Attributes
    GLfloat light_ambient[]  = { a0, a1, a2, a3 };
    GLfloat light_diffuse[]  = { d0, d1, d2, d3 };
    GLfloat light_specular[] = { s0, s1, s2, s3 };
    GLfloat light_position[] = { p0, p1, p2, p3 };

    // Setup Light
    glLightfv( light, GL_AMBIENT, light_ambient );
    glLightfv( light, GL_DIFFUSE, light_diffuse );
    glLightfv( light, GL_SPECULAR, light_specular );
    glLightfv( light, GL_POSITION, light_position );

    // Enable Light
    glEnable( light );
}
//-----------------------------------------------------------------------------
// Set the Light Ambient Property
inline void SetLightAmbient( GLenum light, GLfloat r, GLfloat g, GLfloat b, GLfloat a )
{
    GLfloat v[] = { r, g, b, a };
    glLightfv( light, GL_AMBIENT, v ); 
}
//-----------------------------------------------------------------------------
// Set the Light Diffuse Property
inline void SetLightDiffuse( GLenum light, GLfloat r, GLfloat g, GLfloat b, GLfloat a )
{
    GLfloat v[] = { r, g, b, a };
    glLightfv( light, GL_DIFFUSE, v ); 
}
//-----------------------------------------------------------------------------
// Set the Light Specular Property
inline void SetLightSpecular( GLenum light, GLfloat r, GLfloat g, GLfloat b, GLfloat a )
{
    GLfloat v[] = { r, g, b, a };
    glLightfv( light, GL_SPECULAR, v ); 
}
//-----------------------------------------------------------------------------
// Set the Light Position Property
inline void SetLightPosition( GLenum light, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    GLfloat v[] = { x, y, z, w };
    glLightfv( light, GL_POSITION, v ); 
}
//-----------------------------------------------------------------------------
// Set the Light Attenuation Property
inline void SetLightAttenuation( GLenum light, 
        GLfloat constant, GLfloat linear, GLfloat quadratic )
{
    glLightf( light, GL_CONSTANT_ATTENUATION, constant );
    glLightf( light, GL_LINEAR_ATTENUATION, linear );
    glLightf( light, GL_QUADRATIC_ATTENUATION, quadratic );
}
//-----------------------------------------------------------------------------
// Set the Light Spot Cutoff Property - spotlight cutoff angle
//   halfAngle is restricted to the range [0.0-90.0] in angles
// OpenGL Default:  180.0 - i.e. the angle at the cone's apex is 360 degrees
//   means a light that radiates in all directions.
inline void SetLightSpotCutoff( GLenum light, GLfloat halfAngle )
{
    glLightf( light, GL_SPOT_CUTOFF, halfAngle ); 
}
//-----------------------------------------------------------------------------
// Set the Light Spot Direction Property - direction of spotlight
// OpenGL Default:  (0,0,-1)
inline void SetLightSpotDirection( GLenum light, GLfloat x, GLfloat y, GLfloat z )
{
    GLfloat v[] = { x, y, z };
    glLightfv( light, GL_SPOT_DIRECTION, v ); 
}
//-----------------------------------------------------------------------------
// Set the Light Spot (Exponent) Attenuation Property - attenuated towards the egde
// OpenGL Default:  0
inline void SetLightSpotExponent( GLenum light, GLfloat exp )
{
    glLightf( light, GL_SPOT_EXPONENT, exp ); 
}
//-----------------------------------------------------------------------------
// Enable An OpenGL Light
inline void EnableLight( GLenum light )
{
    glEnable( light );
}
//-----------------------------------------------------------------------------
// Disable An OpenGL Light
inline void DisableLight( GLenum light )
{
    glDisable( light );
}
//-----------------------------------------------------------------------------
// Enable OpenGL Lighting with GL_SMOOTH Shading and GL_DEPTH_TEST
// with GL_LIGHT_MODEL_TWO_SIDE option
void EnableLightingWithTwoSide( bool twoSide )
{
    // Set lighting for one side or two sides.
    if ( twoSide )  glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
    else            glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
    // Start Using GL Light(s)
    glShadeModel( GL_SMOOTH );
    glEnable( GL_LIGHTING );
    glEnable( GL_DEPTH_TEST );
}
//-----------------------------------------------------------------------------
// Enable OpenGL Lighting with GL_SMOOTH Shading and GL_DEPTH_TEST
// with GL_LIGHT_MODEL_TWO_SIDE option
inline void EnableLightingWithOneSide( bool oneSide )
{
    EnableLightingWithTwoSide( !oneSide );
}
//-----------------------------------------------------------------------------
// Enable OpenGL Lighting
inline void EnableLighting()    {   glEnable( GL_LIGHTING );    }
//-----------------------------------------------------------------------------
// Disable OpenGL Lighting
inline void DisableLighting()   {   glDisable( GL_LIGHTING );   }
//-----------------------------------------------------------------------------
// Toggle OpenGL Lighting
inline void ToggleLighting()
{
    if ( glIsEnabled( GL_LIGHTING ) )   glDisable( GL_LIGHTING );
    else                                glEnable ( GL_LIGHTING );
}
//-----------------------------------------------------------------------------
// Enable OpenGL Depth Test
inline void EnableDepthTest()   {   glEnable( GL_DEPTH_TEST );  }
//-----------------------------------------------------------------------------
// Disable OpenGL Depth Test
inline void DisableDepthTest()  {   glDisable( GL_DEPTH_TEST ); }
//-----------------------------------------------------------------------------
// Toggle OpenGL Depth Test
inline void ToggleDepthTest()
{
    if ( glIsEnabled( GL_DEPTH_TEST ) ) glDisable( GL_DEPTH_TEST );
    else                                glEnable ( GL_DEPTH_TEST );
}
//-----------------------------------------------------------------------------
// END:  OPENGL LIGHTING
//=============================================================================


//=============================================================================
// START:  OPENGL DRAWING
//-----------------------------------------------------------------------------
// Set Polygon Face Oriantation
inline void SetFrontFaceCCW( bool b )
{
    if ( b )    glFrontFace( GL_CCW );
    else        glFrontFace( GL_CW );
}
//-----------------------------------------------------------------------------
// Set Polygon Face Oriantation
inline void SetFrontFaceCW( bool b )
{
    SetFrontFaceCCW( !b );
}
//-----------------------------------------------------------------------------
// Toggle Polygon Face Oriantation: CCW <--> CW
inline void ToggleFrontFaceOriantation()
{
    GLint value;
    glGetIntegerv( GL_FRONT_FACE, &value );
    if ( GL_CCW == value )
        glEnable( GL_CW );
    else
        glEnable( GL_CCW );
}
//-----------------------------------------------------------------------------
// Enable OpenGL Cull Face
inline void EnableCullFace()    {   glEnable( GL_CULL_FACE );   }
//-----------------------------------------------------------------------------
// Disable OpenGL Cull Face
inline void DisableCullFace()   {   glDisable( GL_CULL_FACE );  }
//-----------------------------------------------------------------------------
// Toggle OpenGL Cull Face
inline void ToggleCullFace()
{
    if ( glIsEnabled( GL_CULL_FACE ) )  glDisable( GL_CULL_FACE );
    else                                glEnable ( GL_CULL_FACE );
}
//-----------------------------------------------------------------------------
// Set Drawing Mode
// face (GLenum) can be 
//   GL_FRONT_AND_BACK = 1032
//   GL_FRONT          = 1028
//   GL_BACK           = 1029
// mode (GLenum) can be
//   GL_POINT = 6912
//   GL_LINE  = 6913
//   GL_FILL  = 6914
inline void SetDrawingMode( GLenum face, GLenum mode )
{
    glPolygonMode( face, mode );
    glCullFace( face );
    glEnable( GL_CULL_FACE );
}
//-----------------------------------------------------------------------------
// Switch Drawing Mode
// the drawing mode is switched circlely from
//     GL_POINT, GL_LINE, and GL_FILL
void SwitchDrawingMode()
{
    GLint DrawFaceAndMode[2];
    glGetIntegerv( GL_POLYGON_MODE, DrawFaceAndMode );
    switch ( DrawFaceAndMode[1] ) {
        case GL_POINT:
            DrawFaceAndMode[1] = GL_LINE;
            break;
        case GL_LINE:
            DrawFaceAndMode[1] = GL_FILL;
            break;
        case GL_FILL:
            DrawFaceAndMode[1] = GL_POINT;
            break;
    }
    glPolygonMode( DrawFaceAndMode[0], DrawFaceAndMode[1] );

    //++g_eDrawMode;
    //if ( g_eDrawMode > GL_FILL ) g_eDrawMode = GL_POINT;
    //glPolygonMode( g_eDrawFace, g_eDrawMode );
}
//-----------------------------------------------------------------------------
// Switch Draw Face Mode
// the draw face mode is switched circlely from
//     GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK
void SwitchDrawFaceMode()
{
    GLint DrawFaceAndMode[2];
    glGetIntegerv( GL_POLYGON_MODE, DrawFaceAndMode );
    switch ( DrawFaceAndMode[0] ) {
        case GL_FRONT:
            DrawFaceAndMode[0] = GL_BACK;
            break;
        case GL_BACK:
            DrawFaceAndMode[0] = GL_FRONT_AND_BACK;
            break;
        case GL_FRONT_AND_BACK:
            DrawFaceAndMode[0] = GL_FRONT;
            break;
    }
    glPolygonMode( DrawFaceAndMode[0], DrawFaceAndMode[1] );

//  if      ( GL_FRONT == g_eCullFace ) g_eCullFace = GL_BACK;
//  else if ( GL_BACK  == g_eCullFace ) g_eCullFace = GL_FRONT_AND_BACK;
//  else                                g_eCullFace = GL_FRONT;
//  glPolygonMode( g_eDrawFace, g_eDrawMode );
}
//-----------------------------------------------------------------------------
// Switch Cull Face Mode
// the cull face mode is switched circlely from 
//     GL_BACK, GL_FRONT, and GL_FRONT_AND_BACK
void SwitchCullFaceMode()
{
    GLint cullFace;
    glGetIntegerv( GL_CULL_FACE_MODE, &cullFace );
    switch ( cullFace ) {
        case GL_FRONT:
            cullFace = GL_BACK;
            break;
        case GL_BACK:
            cullFace = GL_FRONT_AND_BACK;
            break;
        case GL_FRONT_AND_BACK:
            cullFace = GL_FRONT;
            break;
    }
    glCullFace( cullFace );

//  if      ( GL_BACK  == g_eCullFace ) g_eCullFace = GL_FRONT;
//  else if ( GL_FRONT == g_eCullFace ) g_eCullFace = GL_FRONT_AND_BACK;
//  else                                g_eCullFace = GL_BACK;
//  glCullFace( g_eCullFace );
}
//-----------------------------------------------------------------------------
// END:  OPENGL DRAWING
//=============================================================================


//=============================================================================
// STRART:  OPENGL VIEWING
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// END:  OPENGL VIEWING
//=============================================================================

//=============================================================================
// START:  SHADOW FUNCTIONS
//-----------------------------------------------------------------------------
// Create a shadow projection matrix out of the plane equation
// lightPos ==> { xPos, yPos, zPos, 1 }
// planeEqn ==> a*x + b*y + c*z + d = 0
template <typename T>
Matrix4x4<T> CalShadowProjectionMatrix ( Vector4<T> const &lightPos, Vector4<T> const &planeEqn )
{
    T dot = planeEqn*lightPos;
    return Matrix4x4<T> ( 
            dot - lightPos[0]*planeEqn[0],
            dot - lightPos[0]*planeEqn[1],
            dot - lightPos[0]*planeEqn[2],
            dot - lightPos[0]*planeEqn[3],
            dot - lightPos[1]*planeEqn[0],
            dot - lightPos[1]*planeEqn[1],
            dot - lightPos[1]*planeEqn[2],
            dot - lightPos[1]*planeEqn[3],
            dot - lightPos[2]*planeEqn[0],
            dot - lightPos[2]*planeEqn[1],
            dot - lightPos[2]*planeEqn[2],
            dot - lightPos[2]*planeEqn[3],
            dot - lightPos[3]*planeEqn[0],
            dot - lightPos[3]*planeEqn[1],
            dot - lightPos[3]*planeEqn[2],
            dot - lightPos[3]*planeEqn[3]
        );
}
//-----------------------------------------------------------------------------
// END:  SHADOW FUNCTIONS
//=============================================================================

//=============================================================================
// START:  TEXT FUNCTIONS
//-----------------------------------------------------------------------------
// Generate Text
void GenerateScreenText( Enum::GLUT textStyle )
{
    //std::cout << "GenerateScreenText\n";

    if ( g_uiGLFontDisplayList == 0 ) {
        void * ptr = NULL;
        switch (textStyle) {
            case Enum::BITMAP_9_BY_15:
                ptr = GLUT_BITMAP_9_BY_15;
                break;
            case Enum::BITMAP_8_BY_13:
                ptr = GLUT_BITMAP_8_BY_13;
                break;
            case Enum::BITMAP_TIMES_ROMAN_10:
                ptr = GLUT_BITMAP_TIMES_ROMAN_10;
                break;
            case Enum::BITMAP_TIMES_ROMAN_24:
                ptr = GLUT_BITMAP_TIMES_ROMAN_24;
                break;
            case Enum::BITMAP_HELVETICA_10:
                ptr = GLUT_BITMAP_HELVETICA_10;
                break;
            case Enum::BITMAP_HELVETICA_12:
                ptr = GLUT_BITMAP_HELVETICA_12;
                break;
            case Enum::BITMAP_HELVETICA_18:
                ptr = GLUT_BITMAP_HELVETICA_18;
                break;
            default:
                ptr = GLUT_BITMAP_9_BY_15;
        }
        int baseSize = 256;
        //int base = glGenLists( baseSize );    // font list base
        g_uiGLFontDisplayList = glGenLists( baseSize ); // font list base
        // generate fonts
        for ( int i = 0; i < 256; ++i ) {
            //glNewList(base+i, GL_COMPILE);
            glNewList(g_uiGLFontDisplayList+i, GL_COMPILE);
            glutBitmapCharacter(ptr, i);
            glEndList();
        }
        //glListBase(base);
    }
}
//-----------------------------------------------------------------------------
// Draw Text at the current raster position
//inline void DrawGLText( char const * const str )
//{
//  if ( g_uiGLFontDisplayList == 0 ) {
//      GenerateScreenText( Enum::BITMAP_9_BY_15 );
//  }
//  glListBase( g_uiGLFontDisplayList );
//  glCallLists( static_cast<GLsizei>(strlen(str)) , GL_BYTE, str );
//}
//-----------------------------------------------------------------------------
// Draw Text at the position
//inline void DrawGLText( char const * const str, GLfloat const pos[] )
//{ DrawGLText( str, pos[0], pos[1], pos[2] );  }
//-----------------------------------------------------------------------------
// Draw Text at the position
//inline void DrawGLText( char const * const str, GLfloat x, GLfloat y, GLfloat z )
//{
//  glRasterPos3f( x, y, z );
//  DrawGLText( str );
//}
//-----------------------------------------------------------------------------
// Draw Text at the position
//inline void DrawGLText( char const * const str, GLint x, GLint y, GLint z )
//{
//  glRasterPos3i( x, y, z );
//  DrawGLText( str );
//}
//-----------------------------------------------------------------------------
// END:  TEXT FUNCTIONS
//=============================================================================

//=============================================================================
// START:  DRAW OBJECTs
//-----------------------------------------------------------------------------
// Draw a line from P1 to P2
void Draw3DLine ( const GLfloat x1, const GLfloat y1, const GLfloat z1, 
                  const GLfloat x2, const GLfloat y2, const GLfloat z2 )
{
    glBegin( GL_LINES );
    glVertex3f( x1, y1, z1 );
    glVertex3f( x2, y2, z2 );
    glEnd();
}
void Draw3DLine ( GLfloat const * const p1, GLfloat const * const p2 )
{
    glBegin( GL_LINES );
    glVertex3fv( p1 );
    glVertex3fv( p2 );
    glEnd();
}
void Draw3DLine ( const Vector3<GLint> P1, const Vector3<GLint> P2 )
{
    glBegin( GL_LINES );
    glVertex3i( P1[0], P1[1], P1[2] );
    glVertex3i( P2[0], P2[1], P2[2] );
    glEnd();
}
void Draw3DLine ( const Vector3<GLfloat> P1, const Vector3<GLfloat> P2 )
{
    glBegin( GL_LINES );
    glVertex3f( P1[0], P1[1], P1[2] );
    glVertex3f( P2[0], P2[1], P2[2] );
    glEnd();
}
void Draw3DLine ( const Vector3<GLdouble> P1, const Vector3<GLdouble> P2 )
{
    glBegin( GL_LINES );
    glVertex3d( P1[0], P1[1], P1[2] );
    glVertex3d( P2[0], P2[1], P2[2] );
    glEnd();
}
//-----------------------------------------------------------------------------
// END:  DRAW OBJECTs
//=============================================================================

//=============================================================================
// STRART:  QUADRICS OBJECTS BY GLU ROUTINES
//-----------------------------------------------------------------------------
GLUquadricObj * NewGLUQuardic ()
{
    GLUquadricObj * qObj = gluNewQuadric();
#ifdef TAPs_DEBUG_ENABLE
    if ( !qObj ) {
        std::cerr << "Warning: GLUquadricObj cannot be created!\n";
        return qObj;
    }
#endif
    //gluQuadricCallback( qObj, GLU_ERROR, ErrorCallBack);
    gluQuadricDrawStyle( qObj, GLU_FILL );  // smooth shaded
    gluQuadricNormals( qObj, GLU_SMOOTH );
    return qObj;
}
void DeleteGLUQuardic ( GLUquadricObj *qObj )
{
    gluDeleteQuadric( qObj );
}
void ErrorCallBack ( GLenum errCode )
{
    const GLubyte *errStr = gluErrorString( errCode );
    std::cerr << "Quadric Error: " << errStr << "!" << std::endl;
    exit(1);
}
//-----------------------------------------------------------------------------
// END:  QUADRICS OBJECTS BY GLU ROUTINES
//=============================================================================

//=============================================================================
END_NAMESPACE_TAPs__OpenGL__Fn
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8