TAPsOpenGLFns.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLFns.hpp

Global OpenGL Functions in TAPs::OpenGL::Fn namespace

SUKITTI PUNAK   (10/04/2004)
UPDATE          (11/03/2006)
******************************************************************************/
#ifndef TAPs_OPENGL_FNS_HPP
#define TAPs_OPENGL_FNS_HPP

#include "TAPsOpenGLEnumList.hpp"
#include "../Core/TAPsLib.hpp"

#ifdef TAPs_USE_WXWIDGETS
    #include "wx/wx.h"
#endif

BEGIN_NAMESPACE_TAPs__OpenGL__Fn
//=============================================================================
// START:  OPENGL DEBUG/ERROR
//-----------------------------------------------------------------------------
// Check OpenGL Error
//#ifdef TAPs_DEBUG_MODE
    void GFnCheckGLError ( char * file, int line, int * glErrCode = NULL );
//#else
//  void GFnCheckGLError ( char *file, int line, int * glErrCode = NULL );
//#endif
#define CHECK_GL_ERROR() GFnCheckGLError( __FILE__, __LINE__ )
//-----------------------------------------------------------------------------
// Check OpenGL Error with Custom Message
//#ifdef TAPs_DEBUG_MODE
    void GFnCheckGLError ( char * customMessage, int * glErrCode = NULL );
//#else
//  void GFnCheckGLError ( char * customMessage, int * glErrCode = NULL );
//#endif
#define CHECK_GL_ERROR_MESSAGE( s ) GFnCheckGLError( s )
//-----------------------------------------------------------------------------
// Check OpenGL Frame Buffer Status
#ifdef TAPs_DEBUG_MODE
//#ifdef TAPs_USE_GLSL
    void GFnCheckFrameBufferStatus ();
//#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 = 1.0, GLfloat a1 = 1.0, GLfloat a2 = 1.0, GLfloat a3 = 1.0,
                        GLfloat d0 = 1.0, GLfloat d1 = 1.0, GLfloat d2 = 1.0, GLfloat d3 = 1.0,
                        GLfloat s0 = 1.0, GLfloat s1 = 1.0, GLfloat s2 = 1.0, GLfloat s3 = 1.0,
                        GLfloat p0 = 0.0, GLfloat p1 = 0.0, GLfloat p2 = 10.0, GLfloat p3 = 1.0
);
//-----------------------------------------------------------------------------
// Set the Light Ambient Property
// OpenGL Default:  (0,0,0,1)
inline void SetLightAmbient( GLenum light, GLfloat r, GLfloat g, GLfloat b, GLfloat a );
//-----------------------------------------------------------------------------
// Set the Light Diffuse Property
// OpenGL Default:  (1,1,1,1) for GL_LIGHT0 and (0,0,0,1) for other lights
inline void SetLightDiffuse( GLenum light, GLfloat r, GLfloat g, GLfloat b, GLfloat a );
//-----------------------------------------------------------------------------
// Set the Light Specular Property
// OpenGL Default:  (1,1,1,1) for GL_LIGHT0 and (0,0,0,1) for other lights
inline void SetLightSpecular( GLenum light, GLfloat r, GLfloat g, GLfloat b, GLfloat a );
//-----------------------------------------------------------------------------
// Set the Light Position Property
// OpenGL Default:  (0,0,1,0) <=> (x,y,z,w) -- means a DIRECTIONAL light
//   (a light at infinity)
// If w component is not zero, the light is a POSITIONAL light.
inline void SetLightPosition( GLenum light, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
//-----------------------------------------------------------------------------
// Set the Light Attenuation Property
// OpenGL Default:  1.0 - GL_CONSTANT_ATTENUATION
//                  0.0 - GL_LINEAR_ATTENUATION
//                  0.0 - GL_QUADRATIC_ATTENUATION
inline void SetLightAttenuation( GLenum light, 
        GLfloat constant, GLfloat linear, GLfloat 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 );
//-----------------------------------------------------------------------------
// 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 );
//-----------------------------------------------------------------------------
// Set the Light Spot (Exponent) Attenuation Property - attenuated towards the egde
// OpenGL Default:  0
inline void SetLightSpotExponent( GLenum light, GLfloat exp );
//-----------------------------------------------------------------------------
// Enable An OpenGL Light
inline void EnableLight( GLenum light );
//-----------------------------------------------------------------------------
// Disable An OpenGL Light
inline void DisableLight( GLenum light );
//-----------------------------------------------------------------------------
// Enable OpenGL Lighting with GL_SMOOTH Shading
void EnableLightingWithTwoSide( bool twoSide = true );
//-----------------------------------------------------------------------------
// Enable OpenGL Lighting with GL_SMOOTH Shading
inline void EnableLightingWithOneSide( bool oneSide = true );
//-----------------------------------------------------------------------------
// Enable OpenGL Lighting
inline void EnableLighting();
//-----------------------------------------------------------------------------
// Disable OpenGL Lighting
inline void DisableLighting();
//-----------------------------------------------------------------------------
// Toggle OpenGL Lighting
inline void ToggleLighting();
//-----------------------------------------------------------------------------
// Enable OpenGL Depth Test
inline void EnableDepthTest();
//-----------------------------------------------------------------------------
// Disable OpenGL Depth Test
inline void DisableDepthTest();
//-----------------------------------------------------------------------------
// Toggle OpenGL Depth Test: On <--> Off
inline void ToggleDepthTest();
//-----------------------------------------------------------------------------
// END:  OPENGL LIGHTING
//=============================================================================


//=============================================================================
// START:  OPENGL DRAWING
//-----------------------------------------------------------------------------
// Set Polygon Face Oriantation with CCW
inline void SetFrontFaceCCW( bool = true );
//-----------------------------------------------------------------------------
// Set Polygon Face Oriantation with CW
inline void SetFrontFaceCW( bool = true );
//-----------------------------------------------------------------------------
// Toggle Polygon Face Oriantation: CCW <--> CW
inline void ToggleFrontFaceOriantation();
//-----------------------------------------------------------------------------
// Enable OpenGL Cull Face
inline void EnableCullFace();
//-----------------------------------------------------------------------------
// Disable OpenGL Cull Face
inline void DisableCullFace();
//-----------------------------------------------------------------------------
// Toggle OpenGL Cull Face
inline void ToggleCullFace();
//-----------------------------------------------------------------------------
// 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 );
//-----------------------------------------------------------------------------
// Switch Drawing Mode
// the drawing mode is switched circularly from
//     GL_POINT, GL_LINE, and GL_FILL
void SwitchDrawingMode();
//-----------------------------------------------------------------------------
// Switch Draw Face Mode
// the draw face mode is switched circularly from
//     GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK
void SwitchDrawFaceMode();
//-----------------------------------------------------------------------------
// Switch Cull Face Mode
// the cull face mode is switched circularly from 
//     GL_BACK, GL_FRONT, and GL_FRONT_AND_BACK
void SwitchCullFaceMode();
//-----------------------------------------------------------------------------
// END:  OPENGL DRAWING
//=============================================================================




//=============================================================================
// START:  OPENGL VIEWING
//-----------------------------------------------------------------------------
/*
// Reshape Orthogonal Viewing
void ReshapeOrthogonal(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h)
        glOrtho(-20.0, 20.0, -20.0 * (GLfloat) h / (GLfloat) w,
            20.0 * (GLfloat) h / (GLfloat) w, -100.0, 100.0);
    else
        glOrtho(-20.0 * (GLfloat) w / (GLfloat) h,
            20.0 * (GLfloat) w / (GLfloat) h, -20.0, 20.0, -100.0, 100.0);
    glMatrixMode(GL_MODELVIEW);

    glutReshapeFunc(ReshapeOrthogonal);     // set the reshape fn
}
//-----------------------------------------------------------------------------
// Reshape Orthogonal Viewing
void ReshapePerspectiveViewing(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h)
        glOrtho(-20.0, 20.0, -20.0 * (GLfloat) h / (GLfloat) w,
            20.0 * (GLfloat) h / (GLfloat) w, -100.0, 100.0);
    else
        glOrtho(-20.0 * (GLfloat) w / (GLfloat) h,
            20.0 * (GLfloat) w / (GLfloat) h, -20.0, 20.0, -100.0, 100.0);
    glMatrixMode(GL_MODELVIEW);
}
*/
//-----------------------------------------------------------------------------
// 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 );
//-----------------------------------------------------------------------------
// END:  SHADOW FUNCTIONS
//=============================================================================

//=============================================================================
// START:  TEXT FUNCTIONS
//-----------------------------------------------------------------------------
// Generate Text
// Enum::GLUT created to match Bitmap font constants in "glut.h"
//  BITMAP_9_BY_15,
//  BITMAP_8_BY_13,
//  BITMAP_TIMES_ROMAN_10,
//  BITMAP_TIMES_ROMAN_24,
//  BITMAP_HELVETICA_10,
//  BITMAP_HELVETICA_12,
//  BITMAP_HELVETICA_18

//extern GLuint g_uiGLFontDisplayList;
GLuint GetGLFontDisplayList (); //{ return g_uiGLFontDisplayList; }

void GenerateScreenText( Enum::GLUT = Enum::BITMAP_9_BY_15 );
//-----------------------------------------------------------------------------
// Draw Text at the current raster position
inline void DrawGLText( char const * const str )
    {
        //std::cout << "DrawGLText\n";

        if ( GetGLFontDisplayList() == 0 ) {
            GenerateScreenText( Enum::BITMAP_9_BY_15 );
        }
        glListBase( GetGLFontDisplayList() );
        glCallLists( static_cast<GLsizei>(strlen(str)) , GL_BYTE, str );
    }
inline void DrawGLText( std::string str )
    { DrawGLText( str.c_str() ); }
//-----------------------------------------------------------------------------
// Draw Text at the position
inline void DrawGLText( char const * const str, GLfloat x, GLfloat y, GLfloat z = 0.0f )
    {
        glRasterPos3f( x, y, z );
        DrawGLText( str );
    }
inline void DrawGLText( std::string str, GLfloat x, GLfloat y, GLfloat z = 0.0f )
    { DrawGLText( str.c_str(), x, y, z ); }
//-----------------------------------------------------------------------------
// Draw Text at the position
inline void DrawGLText( char const * const str, GLfloat const pos[] )
    {   DrawGLText( str, pos[0], pos[1], pos[2] );  }
inline void DrawGLText( std::string str, GLfloat const pos[] )
    { DrawGLText( str.c_str(), pos ); }
//-----------------------------------------------------------------------------
// Draw Text at the position
//inline void DrawGLText( char const * const str, GLint x, GLint y, GLint z = 0 );
//-----------------------------------------------------------------------------
// 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 );
void Draw3DLine ( GLfloat const * const p1, GLfloat const * const p2 );
void Draw3DLine ( const Vector3<GLint> P1, const Vector3<GLint> P2 );
void Draw3DLine ( const Vector3<GLfloat> P1, const Vector3<GLfloat> P2 );
void Draw3DLine ( const Vector3<GLdouble> P1, const Vector3<GLdouble> P2 );
//-----------------------------------------------------------------------------
// END:  DRAW OBJECTs
//=============================================================================

//=============================================================================
// STRART:  QUADRICS OBJECTS BY GLU ROUTINES
//-----------------------------------------------------------------------------
GLUquadricObj * NewGLUQuardic ();   // *obj is NULL, if creation is fail
void DeleteGLUQuardic ( GLUquadricObj *qObj );
void ErrorCallBack ( GLenum errorCode );
//-----------------------------------------------------------------------------
// END:  QUADRICS OBJECTS BY GLU ROUTINES
//=============================================================================

//=============================================================================
END_NAMESPACE_TAPs__OpenGL__Fn
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
#if !defined( TAPs_USE_EXPORT )
    #include "TAPsOpenGLFns.cpp"
#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8