TAPsGLARBVertexBufferObject.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsGLSLFns.cpp

Based on 3DLabs Inc. Ltd. and aGLSL.h by Martin Christen

SUKITTI PUNAK   (06/08/2005)
UPDATE          (09/10/2006)
******************************************************************************/
#include "TAPsGLSLFns.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
//=============================================================================
// Global Variables
//-----------------------------------------------------------------------------
char * gbGLSLErrStr[] = {
    "GLSL is not supported/enabled!",               // ERR00
    "Not a valid program object!",                  // ERR01
    "Not a valid object!",                          // ERR02
    "Out of memory!",                               // ERR03
    "Compiler log is not available!",               // ERR04
    "Unknown compiler error!"                       // ERR05
    "Linker log is not available!",                 // ERR06
    "Unknown linker error!",                        // ERR07
    ""                                              // ERR08    
};
bool gbIsGLSLSupported = false;
bool gbIsInitialized   = false;
//-----------------------------------------------------------------------------
//=============================================================================
// Global Functions
//-----------------------------------------------------------------------------
// Check GL Error
int GFnCheckGLError ( char *file, int line )
{
    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::cerr << "GL Error #" << glErr << " (" << gluErrorString(glErr) << ") "
                  << "in file " << file << " at line#" << line << std::endl;
#endif
        errCode = 1;
        glErr = glGetError();
    }
    return errCode;
}
#define CHECK_GL_ERROR() GFnCheckGLError( __FILE__, __LINE__ )
//-----------------------------------------------------------------------------
// Get file length
unsigned long GFnGetFileLength ( std::ifstream & file )
{
    if ( !file.good() ) return 0;
    //unsigned long pos = file.tellg();
    file.seekg( 0, std::ios::end );
    unsigned long len = file.tellg();
    file.seekg( std::ios::beg );
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Length of File: %d" ), len );
    #else
        std::cout << "Length of File: " << len << std::endl;
    #endif
#endif
    return len;
}
//-----------------------------------------------------------------------------
// Get file length
unsigned long GFnGetFileLength ( char * fileName )
{
    // Returns the size in bytes of the shader fileName.
    // If an error occurred, it returns -1.
    int fd;
    int count = -1;
    //
    // Open the file, seek to the end to find its length
    //
#ifdef WIN32 /*[*/
    fd = _open(fileName, _O_RDONLY);
    if (fd != -1)
    {
        count = _lseek(fd, 0, SEEK_END) + 1;
        _close(fd);
    }
#else /*][*/
    fd = open(fileName, O_RDONLY);
    if (fd != -1)
    {
        count = lseek(fd, 0, SEEK_END) + 1;
        close(fd);
    }
#endif /*]*/

    return count;
}
//-----------------------------------------------------------------------------
bool GFnInitGLSL ()
{
    if ( gbIsGLSLSupported ) return true;   // GLSL has already been initialized
    //---------------------------------------------------------------
    // Initialize the "OpenGL Extension Wrangler" library
    if ( gbIsInitialized )   return true;
    gbIsInitialized = true;
    GLenum err = glewInit();
    if ( GLEW_OK != err ) {
#ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Error: %s" ), glewGetErrorString( err ) );
#else
        std::cerr << "Error: " << glewGetErrorString( err ) << std::endl;
#endif
        gbIsGLSLSupported = false;
        return gbIsGLSLSupported;
    }
    //---------------------------------------------------------------
    // OpenGL Info
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "OpenGL Vendor:   %s" ), glGetString( GL_VENDOR ) );
        wxLogError( wxT( "OpenGL Renderer: %s" ), glGetString( GL_RENDERER ) );
        wxLogError( wxT( "OpenGL Version:  %s" ), glGetString( GL_VERSION ) );
    #else
        std::cout << "OpenGL Vendor:   " << glGetString( GL_VENDOR ) << "\n";
        std::cout << "OpenGL Renderer: " << glGetString( GL_RENDERER ) << "\n";
        std::cout << "OpenGL Version:  " << glGetString( GL_VERSION ) << "\n";
    #endif
#endif
    //---------------------------------------------------------------
    GFnCheckGLSL();
    //---------------------------------------------------------------
    return gbIsGLSLSupported;
}
//-----------------------------------------------------------------------------
bool GFnCheckGLSL ()
{
    if ( gbIsGLSLSupported ) return true;   // GLSL is available and initailized
    //---------------------------------------------------------------
    if ( !gbIsInitialized ) GFnInitGLSL();
    //---------------------------------------------------------------
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        if      ( GLEW_VERSION_2_0 )
            wxLogError( wxT( "OpenGL 2.0 is available!" ) );
        else if ( GLEW_VERSION_1_5 )
            wxLogError( wxT( "OpenGL 1.5 is available!" ) );
        else if ( GLEW_VERSION_1_4 )
            wxLogError( wxT( "OpenGL 1.4 is available!" ) );
        else if ( GLEW_VERSION_1_3 )
            wxLogError( wxT( "OpenGL 1.3 is available!" ) );
        else if ( GLEW_VERSION_1_2 )
            wxLogError( wxT( "OpenGL 1.2 is available!" ) );
    #else
        if      ( GLEW_VERSION_2_0 )
            std::cout << "OpenGL 2.0 is available!\n";
        else if ( GLEW_VERSION_1_5 )
            std::cout << "OpenGL 1.5 is available!\n";
        else if ( GLEW_VERSION_1_4 )
            std::cout << "OpenGL 1.4 is available!\n";
        else if ( GLEW_VERSION_1_3 )
            std::cout << "OpenGL 1.3 is available!\n";
        else if ( GLEW_VERSION_1_2 )
            std::cout << "OpenGL 1.2 is available!\n";
    #endif
#endif
    //---------------------------------------------------------------
    // Ensure we have the necessary OpenGL Shading Language extensions.
    if (glewGetExtension("GL_ARB_fragment_shader")      != GL_TRUE ||
        glewGetExtension("GL_ARB_vertex_shader")        != GL_TRUE ||
        glewGetExtension("GL_ARB_shader_objects")       != GL_TRUE ) //||
        //glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE)
    {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "[FAILIED] OpenGL Shading Language is NOT available!" ) );
    #else
        std::cout << "[FAILIED] OpenGL Shading Language is NOT available!\n";
    #endif
#endif
        gbIsGLSLSupported = false;
    }
    else {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "[OK] OpenGL Shading Language is available!" ) );
    #else
        std::cout << "[OK] OpenGL Shading Language is available!\n";
    #endif
#endif
        gbIsGLSLSupported = true;
    }
    //---------------------------------------------------------------
    return gbIsGLSLSupported;
}
//-----------------------------------------------------------------------------
bool GFnCheckGL2 ()
{
    if ( !gbIsInitialized ) GFnInitGLSL();
    return GLEW_VERSION_2_0 == GL_TRUE;
}
//-----------------------------------------------------------------------------


//******************************************************************************
//=============================================================================
// class GLSLProgramObject
//-----------------------------------------------------------------------------
// Static Variable(s)
bool GLSLProgramObject::m_stcbShaderActive = true;
//-----------------------------------------------------------------------------
// Constructor
GLSLProgramObject::GLSLProgramObject () :
    m_uiProgramObject( NULL ),
    m_bLinkStatus( false ),
    m_cpLinkerLog( NULL ),
    m_bManageMemory( false )
{
    if ( GFnInitGLSL() ) {
        m_uiProgramObject = glCreateProgram();
        //CHECK_GL_ERROR();
    }
    else {
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: OpenGL Shading Language is NOT available!" ) );
    #else
        std::cerr << "ERROR: OpenGL Shading Language is NOT available!\n";
    #endif
    }
}
//-----------------------------------------------------------------------------
// Destructor
GLSLProgramObject::~GLSLProgramObject ()
{
    //---------------------------------------------------------------
    if ( m_cpLinkerLog ) {
        delete [] m_cpLinkerLog;
        m_cpLinkerLog = NULL;
    }
    if ( gbIsGLSLSupported )
    {
        for (unsigned int i = 0; i < m_vShaderList.size(); ++i ) {
            glDetachShader( m_uiProgramObject, m_vShaderList[i]->m_uiShaderObject );
            CHECK_GL_ERROR();   // if get an error here, the program object is deleted first
                                // the m_uiProgramObject must be deleted last
            if ( m_bManageMemory ) delete m_vShaderList[i];
        }
        glDeleteProgram( m_uiProgramObject );
        CHECK_GL_ERROR();
    }
}
//-----------------------------------------------------------------------------
// IsGLSLEnabled
bool GLSLProgramObject::IsGLSLEnabled ()
{
    return gbIsGLSLSupported;
}
//-----------------------------------------------------------------------------
// Add a vertex or fragment shader
void GLSLProgramObject::AddShader ( GLSLShader * glslShader )
{
    if ( !gbIsGLSLSupported ) return;
    if ( glslShader == NULL ) return;
    if ( !glslShader->m_bCompileStatus ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Trying to compile the shader program ... " ) );
        if ( !glslShader->Compile() ) {
            wxLogError( wxT( " ... compile ERROR!" ) );
            return;
        }
        else {
            wxLogError( wxT( " ... Compilation Passed!" ) );
        }
    #else
        std::cout << "Trying to compile the shader program ... ";
        if ( !glslShader->Compile() ) {
            std::cout << " ... compile ERROR!\n";
            return;
        }
        else {
            std::cout << " ... Compilation Passed!\n";
        }
    #endif
#endif
    }
    m_vShaderList.push_back( glslShader );
}
//-----------------------------------------------------------------------------
// Link
bool GLSLProgramObject::Link ()
{
    if ( !gbIsGLSLSupported ) return false;
    unsigned int i;
    //----------------------------------------------------------------
    if ( m_bLinkStatus ) {  // already linked, detach everything
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Object is already linked, trying to link it again ..." ) );
    #else
        std::cout << "Object is already linked, trying to link it again ...";
    #endif
#endif
        for ( i = 0; i < m_vShaderList.size(); ++i ) {
            glDetachShader( m_uiProgramObject, m_vShaderList[i]->m_uiShaderObject );
            CHECK_GL_ERROR();
        }
    }
    //----------------------------------------------------------------
    for ( i = 0; i < m_vShaderList.size(); ++i ) {
        glAttachShader( m_uiProgramObject, m_vShaderList[i]->m_uiShaderObject );
        CHECK_GL_ERROR();
    }
    //----------------------------------------------------------------
    int linked;
    glLinkProgram( m_uiProgramObject );
    CHECK_GL_ERROR();
    glGetProgramiv( m_uiProgramObject, GL_LINK_STATUS, &linked );
    CHECK_GL_ERROR();
    //----------------------------------------------------------------
    if ( linked ) {
        m_bLinkStatus = true;
    }
    else {
        m_bLinkStatus = false;
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: GLSL Linker Error" ) );
    #else
        std::cerr << "ERROR: GLSL Linker Error" << std::endl;
    #endif
    }
    //----------------------------------------------------------------
    return m_bLinkStatus;
}
//-----------------------------------------------------------------------------
// Get linker messages
char * GLSLProgramObject::GetLinkerLog ()
{
    //----------------------------------------------------------------
    if ( !gbIsGLSLSupported ) return gbGLSLErrStr[0];
    int bLen = 0, sLen = 0;
    //----------------------------------------------------------------
    if ( m_uiProgramObject == NULL ) return gbGLSLErrStr[2];
    glGetProgramiv( m_uiProgramObject, GL_INFO_LOG_LENGTH, &bLen );
    CHECK_GL_ERROR();
    //----------------------------------------------------------------
    if ( bLen > 1 ) {
        if ( m_cpLinkerLog ) {
            delete [] m_cpLinkerLog;
            m_cpLinkerLog = NULL;
        }
        if ( (m_cpLinkerLog = new GLchar[bLen]) == NULL ) {
        //if ( (m_cpLinkerLog = (GLchar *) malloc (bLen*sizeof(char))) == NULL ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: Cound not allocate linker log buffer" ) );
        #else
            std::cerr << "ERROR: Cound not allocate linker log buffer\n";
        #endif
            return gbGLSLErrStr[3];
        }
        glGetProgramInfoLog( m_uiProgramObject, bLen, &sLen, m_cpLinkerLog );
        CHECK_GL_ERROR();
    }
    if ( m_cpLinkerLog ) {
        return static_cast<char *>( m_cpLinkerLog );
    }
    else {
        return gbGLSLErrStr[6];
    }
    //----------------------------------------------------------------
    return gbGLSLErrStr[7];
}
//-----------------------------------------------------------------------------
// Begin this shader.  OpenGL calls will go through shader
void GLSLProgramObject::BeginGLSL ()
{
    if ( !gbIsGLSLSupported )           return;
    if ( m_uiProgramObject == NULL )    return;
    if ( !m_stcbShaderActive )          return;
    if ( m_bLinkStatus ) {
        glUseProgram( m_uiProgramObject );
        CHECK_GL_ERROR();
    }
}
//-----------------------------------------------------------------------------
// Stop using this shader. OpenGL calls will go through regular pipeline.
void GLSLProgramObject::EndGLSL ()
{
    if ( !gbIsGLSLSupported )   return;
    if ( !m_stcbShaderActive )  return;
    glUseProgram( NULL );
    CHECK_GL_ERROR();
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform1f ( char *var, GLfloat x )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform1f( loc, x );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform2f ( char *var, GLfloat x, GLfloat y )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform2f( loc, x, y );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform3f ( char *var, GLfloat x, GLfloat y, GLfloat z )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform3f( loc, x, y, z );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform4f ( char *var, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform4f( loc, x, y, z, w );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform1i ( char *var, GLint x )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform1i( loc, x );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform2i ( char *var, GLint x, GLint y )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform2i( loc, x, y );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform3i ( char *var, GLint x, GLint y, GLint z )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform3i( loc, x, y, z );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform4i ( char *var, GLint x, GLint y, GLint z, GLint w )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform4i( loc, x, y, z, w );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform1fv ( char *var, GLsizei count, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform1fv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform2fv ( char *var, GLsizei count, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform2fv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform3fv ( char *var, GLsizei count, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform3fv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform4fv ( char *var, GLsizei count, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform4fv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform1iv ( char *var, GLsizei count, GLint *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform1iv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform2iv ( char *var, GLsizei count, GLint *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform2iv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform3iv ( char *var, GLsizei count, GLint *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform3iv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniform4iv ( char *var, GLsizei count, GLint *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniform4iv( loc, count, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniformMatrix2fv ( char *var, GLsizei count, GLboolean transpose, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniformMatrix2fv( loc, count, transpose, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniformMatrix3fv ( char *var, GLsizei count, GLboolean transpose, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniformMatrix3fv( loc, count, transpose, val );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetUniformMatrix4fv ( char *var, GLsizei count, GLboolean transpose, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return false;
    if ( !m_stcbShaderActive )  return true;
    //----------------------------------------------------------------
    GLint loc = GetUniLoc( var );
    if ( loc == -1 )    return false;   // cannot find variable
    //----------------------------------------------------------------
    glUniformMatrix4fv( loc, count, transpose, val );
    return true;
}
//-----------------------------------------------------------------------------
void GLSLProgramObject::GetUniformfv ( char *name, GLfloat *val )
{
    if ( !gbIsGLSLSupported )   return;
    GLint loc = GetUniLoc( name );
    /*
    GLint loc = glGetUniformLocation( m_uiProgramObject, name );
    if ( loc == -1 ) {
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 
                    name );
    #else
        std::cerr << "ERROR: cannot find uniform variable \"" 
                    << name << "\"\n";
    #endif
    }
    //*/
    glGetUniformfv( m_uiProgramObject, loc, val );
}
//-----------------------------------------------------------------------------
void GLSLProgramObject::GetUniformiv ( char *name, GLint *val )
{
    if ( !gbIsGLSLSupported )   return;
    GLint loc = GetUniLoc( name );
    /*
    GLint loc = glGetUniformLocation( m_uiProgramObject, name );
    if ( loc == -1 ) {
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 
                    name );
    #else
        std::cerr << "ERROR: cannot find uniform variable \"" 
                    << name << "\"\n";
    #endif
    }
    //*/
    glGetUniformiv( m_uiProgramObject, loc, val );
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetVertexAttrib1f ( GLuint index, GLfloat x )
{
    if ( !gbIsGLSLSupported )   return false;
    glVertexAttrib1f( index, x );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetVertexAttrib2f ( GLuint index, GLfloat x, GLfloat y )
{
    if ( !gbIsGLSLSupported )   return false;
    glVertexAttrib2f( index, x, y );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetVertexAttrib3f ( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{
    if ( !gbIsGLSLSupported )   return false;
    glVertexAttrib3f( index, x, y, z );
    return true;
}
//-----------------------------------------------------------------------------
bool GLSLProgramObject::SetVertexAttrib4f ( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    if ( !gbIsGLSLSupported )   return false;
    glVertexAttrib4f( index, x, y, z, w );
    return true;
}
//-----------------------------------------------------------------------------
GLint GLSLProgramObject::GetUniLoc ( const GLchar *name )
{
    GLint loc = glGetUniformLocation( m_uiProgramObject, name );
    if ( loc == -1 ) {
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 
                    name );
    #else
        std::cerr << "ERROR: Cannot find uniform variable \"" 
                    << name << "\"\n";
    #endif
    }
    CHECK_GL_ERROR();
    return loc;
}
//-----------------------------------------------------------------------------
//=============================================================================
//******************************************************************************


//******************************************************************************
//=============================================================================
// class GLSLShader
//-----------------------------------------------------------------------------
// Constructor
GLSLShader::GLSLShader () :
    m_iShaderType( 0 ),         // 1 = Vertex Shader; 2 = Fragment Shader; else = NONE
    m_uiShaderObject( NULL ),       // program object
    m_cpShaderSource( NULL ),       // ASCII source code
    m_bCompileStatus( false ),      // true if shader is compiled
    m_cpCompilerLog( NULL ),        // compiler log message
    m_bMemAlloc( false )                // true if shader allocated memory
{
    GFnInitGLSL();
}
//-----------------------------------------------------------------------------
// Destructor
GLSLShader::~GLSLShader ()
{
    if ( m_cpCompilerLog ) {
        delete [] m_cpCompilerLog;
        m_cpCompilerLog = NULL;
    }
    if ( m_cpShaderSource ) {
        if ( m_bMemAlloc )  delete [] m_cpShaderSource;
        m_cpShaderSource = NULL;
        m_bMemAlloc = false;
    }
    if ( m_bCompileStatus ) {
        glDeleteShader( m_uiShaderObject );
        CHECK_GL_ERROR();
    }
}
/*
//-----------------------------------------------------------------------------
// Load a file
int GLSLShader::Load ( char *fileName )
{
    std::ifstream file;
    if ( !file )    return -1;  // File name is empty
    unsigned long len = GFnGetFileLength( fileName );
    //---------------------------------------------------------------
    file.open( fileName, std::ios::in );
    //file.close();
    //std::cout << "file len = " << len << std::cout;
    //char c;
    //std::cout << "Press any key to continue." << std::endl;
    //std::cin >> c;
    if ( len == 0 ) return -2;  // File is empty
    //---------------------------------------------------------------
    if ( m_cpShaderSource ) {   // there is a loaded source, free it
        if ( m_bMemAlloc )  delete [] m_cpShaderSource;
    }
    m_cpShaderSource = new GLchar[len+1];
    //m_cpShaderSource = (GLchar *) malloc (len+1);
    if ( m_cpShaderSource == NULL ) return -3;  // cannot reserve memory
    m_bMemAlloc = true;
    //---------------------------------------------------------------
    // len isn't always strlen because some characters are stripped in
    // ASCII read.
    // It is important to 0-terminate the real length later,
    // len is just the max location.
    //m_cpShaderSource[len] = 0;    // '\0'
    m_cpShaderSource[len] = '\0';
    //---------------------------------------------------------------
    unsigned int  i = 0;
    //while ( !file.eof() && i < len ) {
    //file.open( fileName, std::ios::in );
    //while ( i < len ) {
    while ( file.good() ) {
        m_cpShaderSource[i++] = file.get(); // get a char from file
        //std::cout << m_cpShaderSource[i-1];
        if ( i > len )  i = len;
    }
    m_cpShaderSource[i] = '\0'; // 0-terminate
    //std::cout << "\ni = " << i << std::endl;
    file.close();
    //----------------------------------------------------------------
    return 0;
}
//*/
//*
//-----------------------------------------------------------------------------
// Load a file
int GLSLShader::Load ( char * fileName )
{
    if ( !fileName )    return -1;  // File name is empty
    unsigned long len = GFnGetFileLength( fileName );
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_WXWIDGETS
    wxLogError( wxT( "len: %d" ), len );
#else
    std::cout << "len: " << len << "\n";
#endif
#endif

    if ( len == 0 ) return -2;  // File is empty
    //----------------------------------------------------------------
    if ( m_cpShaderSource ) {   // there is a loaded source, free it
        if ( m_bMemAlloc )  delete [] m_cpShaderSource;
    }
    m_cpShaderSource = new GLchar[len+1];
    //m_cpShaderSource = (GLchar *) malloc (len+1);
    if ( m_cpShaderSource == NULL ) return -3;  // cannot reserve memory
    m_bMemAlloc = true;

    //
    // Open the file
    //
    FILE *fh = fopen(fileName, "r");
    if (!fh)
        return -1;

    //
    // Get the shader from a file.
    //
    fseek(fh, 0, SEEK_SET);
    int count = static_cast<int>( fread(m_cpShaderSource, 1, len, fh) );
    m_cpShaderSource[count] = '\0';

    if (ferror(fh))
        count = 0;

    fclose(fh);
    //----------------------------------------------------------------
    return 0;
}
//*/
//-----------------------------------------------------------------------------
// Load a file
void GLSLShader::LoadFromMemory ( const char *program )
{
    if ( m_cpShaderSource == NULL ) {   // there is a loaded source, free it
        if ( m_bMemAlloc )  delete [] m_cpShaderSource;
    }
    m_bMemAlloc = false;
    m_cpShaderSource = (GLchar *) program;
}
//-----------------------------------------------------------------------------
// Get compiler log messages
char * GLSLShader::GetCompilerLog ()
{
    if ( !gbIsGLSLSupported )           return gbGLSLErrStr[0];
    if ( m_uiShaderObject == NULL )     return gbGLSLErrStr[1];
    //----------------------------------------------------------------
    int bLen = 0;   int sLen = 0;
    glGetShaderiv( m_uiShaderObject, GL_INFO_LOG_LENGTH, &bLen );
    CHECK_GL_ERROR();
    //----------------------------------------------------------------
    if ( bLen > 1 ) {
        if ( m_cpCompilerLog == NULL ) {
            delete [] m_cpCompilerLog;
            m_cpCompilerLog = NULL;
        }
        if ( (m_cpCompilerLog = new GLchar[bLen]) == NULL ) {
        //if ( (m_cpCompilerLog = (GLchar *) malloc (bLen*sizeof(char))) == NULL ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: Could not allocate memory for compiler log buffer" ) );
        #else
            std::cerr << "ERROR: Could not allocate memory for compiler log buffer\n";
        #endif
            return gbGLSLErrStr[3];
        }
        glGetShaderInfoLog( m_uiShaderObject, bLen, &sLen, m_cpCompilerLog );
        CHECK_GL_ERROR();
    }
    if ( m_cpCompilerLog == NULL )  return static_cast<char *>( m_cpCompilerLog );
    else                            return gbGLSLErrStr[4];
    //----------------------------------------------------------------
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_WXWIDGETS
    wxLogError( wxT( "blen: %d" ), bLen );
    wxLogError( wxT( "slen: %d" ), sLen );
#else
    std::cout << "blen: " << bLen << std::endl;
    std::cout << "slen: " << sLen << std::endl;
#endif
#endif

    return gbGLSLErrStr[5];
}
//-----------------------------------------------------------------------------
// Get compiler log messages
bool GLSLShader::Compile ()
{
    if ( !gbIsGLSLSupported ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "gbIsGLSLSupported == false" ) );
    #else
        std::cout << "gbIsGLSLSupported == false\n" << std::endl;
    #endif
#endif
        return false;
    }
    m_bCompileStatus = false;
    int compiled = 0;
    if ( m_cpShaderSource == NULL ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "m_cpShaderSource == NULL (i.e. Shader is empty!)" ) );
    #else
        std::cout << "m_cpShaderSource == NULL (i.e. Shader is empty!)\n" << std::endl;
    #endif
#endif
        return false;   // Shader is empty
    }
    //----------------------------------------------------------------
    GLint length = static_cast<GLint>( strlen( (const char*) m_cpShaderSource ) );
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_WXWIDGETS
    wxLogError( wxT( "Source (Length %d ):" ), length );
    wxLogError( wxT( "-------------------------------------------------------------" ) );
    wxLogError( wxT( "%s" ), m_cpShaderSource );
    wxLogError( wxT( "-------------------------------------------------------------" ) );
#else
    std::cout << "Source (Length " << length << "):\n";
    std::cout << "-------------------------------------------------------------\n";
    std::cout << m_cpShaderSource << "\n";
    std::cout << "-------------------------------------------------------------\n";
#endif
#endif
    glShaderSource( m_uiShaderObject, 1, (const GLchar **) &m_cpShaderSource, &length );
    //glShaderSource( m_uiShaderObject, 1, (const GLchar **) &m_cpShaderSource, NULL );
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_WXWIDGETS
    wxLogError( wxT( "Pass glShaderSource" ) );
#else
    std::cout << "Pass glShaderSource\n";
#endif
#endif
    CHECK_GL_ERROR();

    glCompileShader( m_uiShaderObject );
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_WXWIDGETS
    wxLogError( wxT( "Pass glCompileShader" ) );
#else
    std::cout << "Pass glCompileShader\n";
#endif
#endif
    CHECK_GL_ERROR();

    glGetShaderiv( m_uiShaderObject, GL_COMPILE_STATUS, &compiled );
#ifdef TAPs_DEBUG_MODE
#ifdef TAPs_USE_WXWIDGETS
    wxLogError( wxT( "Pass glGetObjectParameteriv" ) );
#else
    std::cout << "Pass glGetObjectParameteriv\n";
#endif
#endif
    CHECK_GL_ERROR();
    //----------------------------------------------------------------
    if ( compiled ) m_bCompileStatus = true;
    return m_bCompileStatus;
}
//-----------------------------------------------------------------------------
// Get localtion of the attribute
GLint GLSLShader::GetAttribLoc ( char * cpAttribName )
{
    return glGetAttribLocation( m_uiShaderObject, cpAttribName );
}
//-----------------------------------------------------------------------------
//=============================================================================
//******************************************************************************


//******************************************************************************
//=============================================================================
// class GLSLVertexShader
//-----------------------------------------------------------------------------
// Constructor
GLSLVertexShader::GLSLVertexShader ()
{
    m_iShaderType = 1;
    if ( gbIsGLSLSupported ) {
        m_uiShaderObject = glCreateShader( GL_VERTEX_SHADER );
        CHECK_GL_ERROR();
    }
}
//-----------------------------------------------------------------------------
// Destructor
GLSLVertexShader::~GLSLVertexShader ()
{}
//-----------------------------------------------------------------------------
//=============================================================================
//******************************************************************************


//******************************************************************************
//=============================================================================
// class GLSLFragmentShader
//-----------------------------------------------------------------------------
// Constructor
GLSLFragmentShader::GLSLFragmentShader ()
{
    m_iShaderType = 2;
    if ( gbIsGLSLSupported ) {
        m_uiShaderObject = glCreateShader( GL_FRAGMENT_SHADER );
        CHECK_GL_ERROR();
    }
}
//-----------------------------------------------------------------------------
// Destructor
GLSLFragmentShader::~GLSLFragmentShader ()
{}
//-----------------------------------------------------------------------------
//=============================================================================
//******************************************************************************


//******************************************************************************
//=============================================================================
// class GLSLShaderManager
//-----------------------------------------------------------------------------
// Constructor
GLSLShaderManager::GLSLShaderManager ()
{}
//-----------------------------------------------------------------------------
// Destructor
GLSLShaderManager::~GLSLShaderManager ()
{
    // Delete objects
    std::vector<GLSLProgramObject *>::iterator pos = m_vProgramObjectList.begin();
    while ( pos != m_vProgramObjectList.end() ) {
        GLSLProgramObject *obj = *pos;
        pos = m_vProgramObjectList.erase( pos );
        delete obj;
    }
}
//-----------------------------------------------------------------------------
// Load vertex/fragment shader from file
GLSLProgramObject * GLSLShaderManager::LoadFromFile ( char * vertFile, char * fragFile )
{
    GLSLProgramObject   * obj           = new GLSLProgramObject();
    GLSLVertexShader    * vertShader    = new GLSLVertexShader();
    GLSLFragmentShader  * fragShader    = new GLSLFragmentShader();
    //----------------------------------------------------------------
    // Load vertex program
    if ( vertFile ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Load vertex program \"%s\"" ), vertFile );
    #else
        std::cout << "Load vertex program \"" << vertFile << "\"";
    #endif
#endif
        if ( vertShader->Load( vertFile ) ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: Could not load a vertex shader named \"%s\"" ), 
                        vertFile );
        #else
            std::cerr << "ERROR: Could not load a vertex shader named \"" 
                        << vertFile << "\"!\n";
        #endif
            delete obj;
            delete vertShader;
            delete fragShader;
            return NULL;
        }
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( " is successful!" ) );
    #else
        std::cout << " is successful!\n";
    #endif
#endif
    }
    //----------------------------------------------------------------
    // Load fragment program
    if ( fragFile ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Load fragment program \"%s\"" ), fragFile );
    #else
        std::cout << "Load fragment program \"" << fragFile << "\"";
    #endif
#endif
        if ( fragShader->Load( fragFile ) ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: Could not load a fragment shader named \"%s\"" ), 
                        fragFile );
        #else
            std::cerr << "ERROR: Could not load a fragment shader named \"" 
                        << fragFile << "\"!\n";
        #endif
            delete obj;
            delete vertShader;
            delete fragShader;
            return NULL;
        }
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( " is successful!" ) );
    #else
        std::cout << " is successful!\n";
    #endif
#endif
    }
    //----------------------------------------------------------------
    // Compile vertex program
    if ( vertFile ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Compile vertex program \"%s\"" ), vertFile );
    #else
        std::cout << "Compile vertex program \"" << vertFile << "\"";
    #endif
#endif
        if ( !vertShader->Compile() ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), vertFile );
            wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() );
        #else
            std::cerr << "ERROR: \"" << vertFile << "\" Compilation Error:\n";
            std::cerr << vertShader->GetCompilerLog() << "\n";
        #endif
            delete obj;
            delete vertShader;
            delete fragShader;
            return NULL;
        }
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( " is successful!" ) );
    #else
        std::cout << " is successful!\n";
    #endif
#endif
    }
    //----------------------------------------------------------------
    // Compile fragment program
    if ( fragFile ) {
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "Compile fragment program \"%s\"" ), fragFile );
    #else
        std::cout << "Compile fragment program \"" << fragFile << "\"";
    #endif
#endif
        if ( !fragShader->Compile() ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), fragFile );
            wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() );
        #else
            std::cerr << "ERROR: \"" << fragFile << "\" Compilation Error:\n";
            std::cerr << fragShader->GetCompilerLog() << "\n";
        #endif
            delete obj;
            delete vertShader;
            delete fragShader;
            return NULL;
        }
#ifdef TAPs_DEBUG_MODE
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( " is successful!" ) );
    #else
        std::cout << " is successful!\n";
    #endif
#endif
    }
    //----------------------------------------------------------------
    // Add to the object
    if ( vertFile ) obj->AddShader( vertShader );
    if ( fragFile ) obj->AddShader( fragShader );
    //----------------------------------------------------------------
    // Link
    if ( !obj->Link() ) {
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\" and \"%s\"" ), 
                    vertFile, fragFile );
        wxLogError( wxT( "%s" ), obj->GetLinkerLog() );
    #else
        std::cerr << "ERROR: Cound not link a shader object created from \""
                << vertFile << "\" and \"" << fragFile << "\"\n";
        std::cerr << obj->GetLinkerLog() << "\n";
    #endif
        delete obj;
        delete vertShader;
        delete fragShader;
        return NULL;
    }
    //----------------------------------------------------------------
    m_vProgramObjectList.push_back( obj );
    obj->MemageMemory();
    //----------------------------------------------------------------
    return obj;
}
//-----------------------------------------------------------------------------
// Load vertex/fragment shader from memory
GLSLProgramObject * GLSLShaderManager::LoadFromMemory ( const char *vertMem, const char *fragMem )
{
    GLSLProgramObject   *obj        = new GLSLProgramObject();
    GLSLVertexShader    *vertShader = new GLSLVertexShader;
    GLSLFragmentShader  *fragShader = new GLSLFragmentShader;
    //----------------------------------------------------------------
    // Load vertex program
    if ( vertMem ) {
        vertShader->LoadFromMemory( vertMem );
    }
    //----------------------------------------------------------------
    // Load fragment program
    if ( fragMem ) {
        fragShader->LoadFromMemory( fragMem );
    }
    //----------------------------------------------------------------
    // Compile vertex program
    if ( vertMem ) {
        if ( !vertShader->Compile() ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), 
                        vertMem );
            wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() );
        #else
            std::cerr << "ERROR: \"" << vertMem << "\" Compilation Error:\n";
            std::cerr << vertShader->GetCompilerLog() << "\n";
        #endif
            delete obj;
            delete vertShader;
            delete fragShader;
            return NULL;
        }
    }
    //----------------------------------------------------------------
    // Compile fragment program
    if ( fragMem ) {
        if ( !fragShader->Compile() ) {
        #ifdef TAPs_USE_WXWIDGETS
            wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), 
                        fragMem );
            wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() );
        #else
            std::cerr << "ERROR: \"" << fragMem << "\" Compilation Error:\n";
            std::cerr << fragShader->GetCompilerLog() << "\n";
        #endif
            delete obj;
            delete vertShader;
            delete fragShader;
            return NULL;
        }
    }
    //----------------------------------------------------------------
    // Add to the object
    if ( vertMem )  obj->AddShader( vertShader );
    if ( fragMem )  obj->AddShader( fragShader );
    //----------------------------------------------------------------
    // Link
    if ( !obj->Link() ) {
    #ifdef TAPs_USE_WXWIDGETS
        wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\" and \"%s\"" ), 
                    vertMem, fragMem );
        wxLogError( wxT( "%s" ), obj->GetLinkerLog() );
    #else
        std::cerr << "ERROR: Cound not link a shader object created from \""
                << vertMem << "\"\n and \"\n" << fragMem << "\"\n";
        std::cerr << obj->GetLinkerLog() << "\n";
    #endif
        delete obj;
        delete vertShader;
        delete fragShader;
        return NULL;
    }
    //----------------------------------------------------------------
    m_vProgramObjectList.push_back( obj );
    obj->MemageMemory();
    //----------------------------------------------------------------
    return obj;
}
//-----------------------------------------------------------------------------
// Delete all shader objects
bool GLSLShaderManager::Delete ( GLSLProgramObject *obj )
{
    std::vector<GLSLProgramObject *>::iterator pos;
    for ( pos = m_vProgramObjectList.begin(); pos != m_vProgramObjectList.end(); ++pos ) {
        if ( *pos == obj ) {
            m_vProgramObjectList.erase( pos );
            delete obj;
            return true;
        }
    }
    return false;
}
//-----------------------------------------------------------------------------
//=============================================================================
//******************************************************************************


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