GLExtensions.cpp

//**************************************************************
//*            OpenGLide - Glide to OpenGL Wrapper
//*             http://openglide.sourceforge.net
//*
//*                    OpenGL Extensions
//*
//*         OpenGLide is OpenSource under LGPL license
//*              Originally made by Fabio Barros
//*      Modified by Paul for Glidos (http://www.glidos.net)
//*               Linux version by Simon White
//**************************************************************

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "OpenGlide.h"
#include "GLExtensions.h"
#include "platform/openglext.h"
#include "platform/error.h"

//for some applications, the glGetString() result is truncated on Windows,
//(driver level workaround for application string buffer bugs, for Quake 2/3 etc.), 
//so some GL extensions becomes un-available.
//enable this to force detecting some extensions
#define GLEXT_FORCE_DETECT_EXTENSIONS 1

enum EExtensionType
{
    OGL_EXT_UNUSED = 0,
    OGL_EXT_REQUIRED,
    OGL_EXT_DESIRED,
};

enum ETunableType
{
    Tunable_No = 0,
    Tunable_On,
    Tunable_Off,
};

struct stExtensionSupport
{
    const char*    name;
    EExtensionType type;
    ETunableType tunable;
    FxBool* val;
    const char* desc;
};

GLExtensions GLExt;

stExtensionSupport glNecessaryExt[] =
{
    #define GLEXT_REF(n, r, t,d) {#n, r, Tunable_##t, &GLExt._##n, d},
    #include "glext_list.h"
    #undef GLEXT_REF
}; 

//Functions
PFNGLCLIENTACTIVETEXTUREARBPROC         p_glClientActiveTexture = NULL;

PFNGLMULTITEXCOORD4FARBPROC             p_glMultiTexCoord4fARB = NULL;
PFNGLMULTITEXCOORD3FARBPROC             p_glMultiTexCoord3fARB = NULL;
PFNGLMULTITEXCOORD4FVARBPROC            p_glMultiTexCoord4fvARB = NULL;
PFNGLACTIVETEXTUREARBPROC               p_glActiveTextureARB = NULL;

PFNGLSECONDARYCOLOR3UBVEXTPROC          p_glSecondaryColor3ubvEXT = NULL;
PFNGLSECONDARYCOLOR3UBEXTPROC           p_glSecondaryColor3ubEXT = NULL;
PFNGLSECONDARYCOLOR3FVEXTPROC           p_glSecondaryColor3fvEXT = NULL;
PFNGLSECONDARYCOLOR3FEXTPROC            p_glSecondaryColor3fEXT = NULL;
PFNGLSECONDARYCOLOR3BVEXTPROC           p_glSecondaryColor3bvEXT = NULL;
PFNGLSECONDARYCOLOR3SVEXTPROC           p_glSecondaryColor3svEXT = NULL;
PFNGLSECONDARYCOLOR3USVEXTPROC          p_glSecondaryColor3usvEXT = NULL;
PFNGLSECONDARYCOLOR3IVEXTPROC           p_glSecondaryColor3ivEXT = NULL;
PFNGLSECONDARYCOLORPOINTEREXTPROC       p_glSecondaryColorPointerEXT = NULL;

PFNGLFOGCOORDFEXTPROC                   p_glFogCoordfEXT = NULL;
PFNGLFOGCOORDPOINTEREXTPROC             p_glFogCoordPointerEXT = NULL;

PFNGLCOLORTABLEEXTPROC                  p_glColorTableEXT = NULL;
PFNGLCOLORSUBTABLEEXTPROC               p_glColorSubTableEXT = NULL;
PFNGLGETCOLORTABLEEXTPROC               p_glGetColorTableEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC    p_glGetColorTableParameterivEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC    p_glGetColorTableParameterfvEXT = NULL;

PFNGLBLENDFUNCSEPARATEEXTPROC           p_glBlendFuncSeparateEXT = NULL;

PFNSETSWAPINTERVALEXT p_wglSwapIntervalEXT = NULL;
#ifdef __linux__
PFNGLXSWAPINTERVALEXT p_glXSwapIntervalEXT = NULL;
#endif

PFNGLARRAYELEMENTEXTPROC p_glArrayElementEXT = NULL;
PFNGLCOLORPOINTEREXTPROC p_glColorPointerEXT = NULL;
PFNGLDRAWARRAYSEXTPROC p_glDrawArraysEXT = NULL;
PFNGLEDGEFLAGPOINTEREXTPROC p_glEdgeFlagPointerEXT = NULL;
PFNGLGETPOINTERVEXTPROC p_glGetPointervEXT = NULL;
PFNGLINDEXPOINTEREXTPROC p_glIndexPointerEXT = NULL;
PFNGLNORMALPOINTEREXTPROC p_glNormalPointerEXT = NULL;
PFNGLVERTEXPOINTEREXTPROC p_glVertexPointerEXT = NULL;
PFNGLTEXCOORDPOINTEREXTPROC p_glTexCoordPointerEXT = NULL;

PFNDEBUGMESSAGECALLBACKARB p_glDebugMessageCallbackARB = NULL;
PFNDEBUGMESSAGECONTROLARB p_glDebugMessageControlARB = NULL;

PFNGLCOMPRESSEDTEXIMAGE2DARBPROC p_glCompressedTexImage2DARB = NULL;

PFNGLDELETEOBJECTARBPROC p_glDeleteObjectARB = NULL;
PFNGLGETHANDLEARBPROC p_glGetHandleARB = NULL;
PFNGLDETACHOBJECTARBPROC p_glDetachObjectARB = NULL;
PFNGLCREATESHADEROBJECTARBPROC p_glCreateShaderObjectARB = NULL;
PFNGLSHADERSOURCEARBPROC p_glShaderSourceARB = NULL;
PFNGLCOMPILESHADERARBPROC p_glCompileshaderARB = NULL;
PFNGLCREATEPROGRAMOBJECTARBPROC p_glCreateProgramObjectARB = NULL;
PFNGLATTACHOBJECTARBPROC p_glAttachObjectARB = NULL;
PFNGLLINKPROGRAMARBPROC p_glLinkProgramARB = NULL;
PFNGLUSEPROGRAMOBJECTARBPROC p_glUseProgramObjectARB = NULL;
PFNGLVALIDATEPROGRAMARBPROC p_glValidateProgramARB = NULL;
PFNGLUNIFORM1IARBPROC p_glUniform1iARB = NULL;
PFNGLUNIFORM4FARBPROC p_glUniform4fARB = NULL;
PFNGLUNIFORM4FVARBPROC p_glUniform4fvARB = NULL;
PFNGLUNIFORM1FVARBPROC p_glUniform1fvARB = NULL;
PFNGLGETUNIFORMLOCATIONARBPROC p_glGetUniformLocationARB = NULL;
PFNGLGETINFOLOGARBPROC p_glGetInfoLogARB = NULL;
PFNGLVERTEXATTRIBPOINTERARBPROC p_glVertexAttribPointerARB = NULL;
PFNGLENABLEVERTEXATTRIBARRAYARBPROC p_glEnableVertexAttribArrayARB = NULL;
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC p_glDisableVertexAttribArrayARB = NULL;
PFNGLBINDATTRIBLOCATIONARBPROC p_glBindAttribLocationARB = NULL;
PFNGLVERTEXATTRIB1FPROC p_glVertexAttrib1fARB = NULL;
PFNGLVERTEXATTRIB2FPROC p_glVertexAttrib2fARB = NULL;
PFNGLVERTEXATTRIB3FPROC p_glVertexAttrib3fARB = NULL;
PFNGLVERTEXATTRIB4FPROC p_glVertexAttrib4fARB = NULL;
PFNGLVERTEXATTRIB4NUBPROC p_glVertexAttrib4NubARB = NULL;

PFNGLGENFRAMEBUFFERSEXTPROC p_glGenFramebuffersEXT = NULL;
PFNGLDELETEFRAMEBUFFERSEXTPROC p_glDeleteFramebuffersEXT = NULL;
PFNGLBINDFRAMEBUFFEREXTPROC p_glBindFramebufferEXT = NULL;
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC p_glFramebufferTexture2DEXT = NULL;
PFNGLGENRENDERBUFFERSEXTPROC p_glGenRenderbuffersEXT = NULL;
PFNGLDELETERENDERBUFFERSEXTPROC p_glDeleteRenderbuffersEXT = NULL;
PFNGLBINDRENDERBUFFEREXTPROC p_glBindRenderbufferEXT = NULL;
PFNGLRENDERBUFFERSTORAGEEXTPROC p_glRenderbufferStorageEXT = NULL;
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC p_glFramebufferRenderbufferEXT = NULL;

PFNGLGENSAMPLERSPROC p_glGenSamplers = NULL;
PFNGLDELETESAMPLERSPROC p_glDeleteSamplers = NULL;
PFNGLBINDSAMPLERPROC p_glBindSampler = NULL;
PFNGLSAMPLERPARAMETERIPROC p_glSamplerParameteri = NULL;

PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC p_glRenderbufferStorageMultisampleEXT = NULL;

PFNGLBLITFRAMEBUFFEREXTPROC p_glBlitFramebufferEXT = NULL;

// Declarations
void GLEXT_LoadFunctions( void );

void APIENTRY DummyV( const void *a )
{
}

void APIENTRY DummyF( GLfloat a )
{
}

void APIENTRY Dummy3ub( GLubyte a, GLubyte b, GLubyte c )
{
}


// check to see if Extension is Supported
// code by Mark J. Kilgard of NVidia modified by Fabio Barros
bool OGLIsExtensionSupported( const char * extension )
{
    const char  * extensions;
    const char  * start;
    char        * where, 
                * terminator;

    where = (char *) strchr( extension, ' ' );
    if ( where || ( *extension == '\0' ) )
    {
        return false;
    }

    extensions = (char*)glGetString( GL_EXTENSIONS );

    start = extensions;

    if ( *start == '\0' )
    {
        LOGE(INIT, "No OpenGL extension supported, using all emulated.\n" );
        return false;
    }

    while ( true )
    {
        where = (char *)strstr( start, extension );
        if ( !where )
        {
            break;
        }
        terminator = where + strlen( extension );
        if ( ( where == start ) || ( *( where - 1 ) == ' ' ) )
        {
            if ( ( *terminator == ' ' ) || ( *terminator == '\0' ) )
            {
                return true;
            }
        }
        start = terminator;
    }

    return false;
}

void GLEXT_Init(void)
{
    LOGM(INIT, LOG_SEPARATE );
    LOGM(INIT, "** OpenGL Information **\n" );
    LOGM(INIT, LOG_SEPARATE );
    LOGM(INIT, "Vendor:      %s\n", glGetString( GL_VENDOR ) );
    LOGM(INIT, "Renderer:    %s\n", glGetString( GL_RENDERER ) );
    LOGM(INIT, "Version:     %s\n", glGetString( GL_VERSION ) );
    LOGM(INIT, "Extensions:  %s\n", glGetString( GL_EXTENSIONS ) );
    LOGM(INIT, "GLSL version:%s\n", glGetString( GL_SHADING_LANGUAGE_VERSION));

    LOGM(INIT, LOG_SEPARATE );

	int ver    = 0;
	int subver = 0;

	sscanf( (const char *)glGetString( GL_VERSION ), "%d.%d", &ver, &subver);

    GLExt.OGLVersion = ver * 100 + subver;

    LOGM(INIT, "OpenGL Extensions:\n" );
    LOGM(INIT, LOG_SEPARATE );

    int index = 0;
    for(index = 0; index < ARRAYSIZE(glNecessaryExt); ++index)
    {
        bool enable = *glNecessaryExt[index].val = OGLIsExtensionSupported(glNecessaryExt[index].name);

        switch ( glNecessaryExt[ index ].type )
        {
        case OGL_EXT_REQUIRED:
            if ( ! enable )
            {
                char szError[ 256 ];
                sprintf( szError, "Severe Problem: minimal required OpenGL %s extension is required for OpenGLide!", 
                    glNecessaryExt[ index ].name );
                LOGE(INIT, szError );
                ReportWarning( szError );
            }
            break;
        case OGL_EXT_DESIRED:
            if ( !enable )
            {
                char szError[ 256 ];
                sprintf( szError, "Note: desired OpenGL %s extension is not supported, emulating behavior.\n", 
                    glNecessaryExt[ index ].name );
                LOGW(INIT, szError );
            }
            else if(glNecessaryExt[ index ].tunable)
            {
                char prefixname[256];
                snprintf(prefixname, sizeof(prefixname)-1, "ext.%s", glNecessaryExt[ index ].name); //group them with prefix
                CFG_AddInt(prefixname, glNecessaryExt[ index ].desc, glNecessaryExt[ index ].tunable == Tunable_On ? 1:0);
                *glNecessaryExt[index].val = CFG_GetInt(prefixname, glNecessaryExt[ index ].tunable == Tunable_On ? enable : 0) ? true : false;
                if(enable && !*glNecessaryExt[index].val)
                {
                    char szError[ 256 ];
                    sprintf( szError, "Note: desired OpenGL %s extension is supported but disabled by config\n", 
                        glNecessaryExt[ index ].name );
                    LOGW(INIT, szError );
                }
            }
            break;

        case OGL_EXT_UNUSED:
            break;
        }
    }

    LOGM(INIT, LOG_SEPARATE );

    if ( DetectMMX( ) )
    {
        GLExt.MMXEnable    = true;
    }
    else
    {
#ifdef HAVE_MMX
        char szError[ 256 ];
        sprintf( szError, "Severe Problem: MMX is required for OpenGLide!" );
        LOGE(INIT, szError );
        LOGE(INIT, szError );
        ReportError( szError );
        exit( 1 );
#else
        GLExt.MMXEnable    = false;
#endif
    }

    GLEXT_LoadFunctions( );
}

void GLEXT_LoadFunctions( void )
{
    p_glActiveTextureARB      = NULL;
    p_glMultiTexCoord4fARB    = NULL;

    p_glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC) DummyV;
    p_glSecondaryColor3fvEXT  = (PFNGLSECONDARYCOLOR3FVEXTPROC) DummyV;
    p_glFogCoordfEXT          = (PFNGLFOGCOORDFEXTPROC) DummyF;

    GLExt.MultiTexCount = 1;
    if ( GLExt._GL_ARB_multitexture )
    {
        glGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &GLExt.MultiTexCount ); //max texture for fixed-function pipeline
        LOGM(INIT, "MultiTexture Textures Units = %x\n", GLExt.MultiTexCount );

        //Note: the code is pretty old, but for max compatibility, we don't change it to higher core functions
        p_glClientActiveTexture       = (PFNGLCLIENTACTIVETEXTUREARBPROC) OGLGetProcAddress( "glClientActiveTextureARB" );
        p_glActiveTextureARB          = (PFNGLACTIVETEXTUREARBPROC) OGLGetProcAddress( "glActiveTextureARB" );
        p_glMultiTexCoord4fARB        = (PFNGLMULTITEXCOORD4FARBPROC) OGLGetProcAddress( "glMultiTexCoord4fARB" );
        p_glMultiTexCoord3fARB        = (PFNGLMULTITEXCOORD3FARBPROC) OGLGetProcAddress( "glMultiTexCoord3fARB" );
        p_glMultiTexCoord4fvARB       = (PFNGLMULTITEXCOORD4FVARBPROC) OGLGetProcAddress( "glMultiTexCoord4fvARB" );

        if ( ( p_glActiveTextureARB == NULL ) || 
             ( p_glMultiTexCoord4fARB == NULL ) || 
             ( p_glMultiTexCoord4fvARB == NULL ) 
            || !p_glMultiTexCoord3fARB )
        {
            LOGE(INIT, "Could not get the address of MultiTexture functions!\n" );
            GLExt._GL_ARB_multitexture = FXFALSE;
            GLExt.MultiTexCount = 1;
        }
    }

    if ( GLExt._GL_EXT_secondary_color )
    {
        p_glSecondaryColor3ubvEXT     = (PFNGLSECONDARYCOLOR3UBVEXTPROC) OGLGetProcAddress( "glSecondaryColor3ubvEXT" );
        p_glSecondaryColor3ubEXT      = (PFNGLSECONDARYCOLOR3UBEXTPROC) OGLGetProcAddress( "glSecondaryColor3ubEXT" );
        p_glSecondaryColor3fvEXT      = (PFNGLSECONDARYCOLOR3FVEXTPROC) OGLGetProcAddress( "glSecondaryColor3fvEXT" );
        p_glSecondaryColor3bvEXT      = (PFNGLSECONDARYCOLOR3BVEXTPROC) OGLGetProcAddress("glSecondaryColor3bvEXT");
        p_glSecondaryColor3svEXT      = (PFNGLSECONDARYCOLOR3SVEXTPROC) OGLGetProcAddress( "glSecondaryColor3svEXT" );
        p_glSecondaryColor3usvEXT     = (PFNGLSECONDARYCOLOR3USVEXTPROC) OGLGetProcAddress( "glSecondaryColor3usvEXT" );
        p_glSecondaryColor3ivEXT      = (PFNGLSECONDARYCOLOR3IVEXTPROC) OGLGetProcAddress( "glSecondaryColor3ivEXT" );
        p_glSecondaryColorPointerEXT  = (PFNGLSECONDARYCOLORPOINTEREXTPROC) OGLGetProcAddress( "glSecondaryColorPointerEXT" );
        if ( ( p_glSecondaryColor3ubvEXT == NULL ) || 
             ( p_glSecondaryColor3ubEXT == NULL )  || 
             ( p_glSecondaryColorPointerEXT == NULL ) || 
             ( p_glSecondaryColor3fvEXT == NULL ) ||
             p_glSecondaryColor3bvEXT == NULL ||
             p_glSecondaryColor3svEXT == NULL ||
             p_glSecondaryColor3usvEXT == NULL ||
             p_glSecondaryColor3ivEXT == NULL)
        {
            LOGE(INIT, "Could not get address of function glSecondaryColorEXT.\n" );
            GLExt._GL_EXT_secondary_color = FXFALSE;
        }
    }
    
    if ( GLExt._GL_EXT_fog_coord )
    {
        p_glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC) OGLGetProcAddress( "glFogCoordfEXT" );
        p_glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC) OGLGetProcAddress( "glFogCoordPointerEXT" );
        if ( p_glFogCoordfEXT == NULL )
        {
            LOGE(INIT, "Could not get address of function glFogCoordEXT.\n" );
            GLExt._GL_EXT_fog_coord = FXFALSE;
        }
    }

    if ( GLExt._GL_EXT_paletted_texture )
    {
        p_glColorTableEXT                 = (PFNGLCOLORTABLEEXTPROC) OGLGetProcAddress( "glColorTableEXT" );
        p_glColorSubTableEXT              = (PFNGLCOLORSUBTABLEEXTPROC) OGLGetProcAddress( "glColorSubTableEXT" );
        p_glGetColorTableEXT              = (PFNGLGETCOLORTABLEEXTPROC) OGLGetProcAddress( "glGetColorTableEXT" );
        p_glGetColorTableParameterivEXT   = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) OGLGetProcAddress( "glGetColorTableParameterivEXT" );
        p_glGetColorTableParameterfvEXT   = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) OGLGetProcAddress( "glGetColorTableParameterfvEXT" );

        if ( ( p_glColorTableEXT == NULL ) || 
             ( p_glColorSubTableEXT == NULL ) || 
             ( p_glGetColorTableEXT == NULL ) || 
             ( p_glGetColorTableParameterivEXT == NULL ) || 
             ( p_glGetColorTableParameterfvEXT == NULL ) )
        {
            LOGE(INIT, "Could not get address of function for PaletteEXT.\n" );
            GLExt._GL_EXT_paletted_texture = FXFALSE;
        }
        else
        {
            LOGM(INIT, "Using Palette Extension.\n" );
        }
    }

    //if(GLExt._WGL_EXT_swap_control) //always load it, because
    //1: it could be used internally. 2: WGL_EXT_swap_control should be "GLX_EXT_swap_control" on linux
    //note: wglSwapIntervalEXT is mapped to glXSwapIntervalEXT on WINE, but the function pointer is not inited (v10.7)
    //so it will crash, need path WINE.
    {
        #ifdef WIN32
        p_wglSwapIntervalEXT = (PFNSETSWAPINTERVALEXT) OGLGetProcAddress("wglSwapIntervalEXT");
        #else
        p_glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXT) OGLGetProcAddress("glXSwapIntervalEXT");
        #endif
    }

    p_glDebugMessageCallbackARB = (PFNDEBUGMESSAGECALLBACKARB)OGLGetProcAddress("glDebugMessageCallbackARB");
    p_glDebugMessageControlARB = (PFNDEBUGMESSAGECONTROLARB)OGLGetProcAddress("glDebugMessageControlARB");
    if(GLExt._GL_ARB_debug_output)
    {
        if(!p_glDebugMessageCallbackARB || !p_glDebugMessageControlARB)
        {
            LOGE(INIT, "GL_ARB_debug_output is supported, but cannot get glDebugMessageCallbackARB/glDebugMessageControlARB.\n");
            GLExt._GL_ARB_debug_output = FXFALSE;
        }
    }
#if GLEXT_FORCE_DETECT_EXTENSIONS
    else if(p_glDebugMessageCallbackARB && p_glDebugMessageControlARB)
    {
        GLExt._GL_ARB_debug_output = FXTRUE;
        LOGM(INIT, "GL_ARB_debug_output present, enabling it.\n");
    }
#endif

    if(GLExt._GL_ARB_texture_compression)
    {
        #if 0
        GLint fmtnum = 0;
        glGetIntegerv(NUM_COMPRESSED_TEXTURE_FORMATS_ARB, &fmtnum);
        GLint* fmts = new GLint[fmtnum];
        glGetIntegerv(COMPRESSED_TEXTURE_FORMATS_ARB, fmts);
        LOGD(INIT, "Compressed image formats: ");
        for(int i = 0; i < fmtnum; ++i)
        {
            LOGD(INIT, "%x ", fmts[i]);
        }
        LOGD(INIT, "\n");
        delete[] fmts;
        #endif

        p_glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) OGLGetProcAddress("glCompressedTexImage2DARB");
        if(!p_glActiveTextureARB)
        {
            LOGE(INIT, "cannot get proc addr: glCompressedTexImage2DARB.\n");
            GLExt._GL_ARB_texture_compression = FXFALSE;
            GLExt._GL_EXT_texture_compression_s3tc = FXFALSE;
        }
    }

    if(GLExt._GL_ARB_shader_objects && GLExt._GL_ARB_vertex_shader && GLExt._GL_ARB_fragment_shader)
    {
        p_glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) OGLGetProcAddress("glDeleteObjectARB");
        p_glGetHandleARB = (PFNGLGETHANDLEARBPROC)OGLGetProcAddress("glGetHandleARB");
        p_glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)OGLGetProcAddress("glDetachObjectARB");
        p_glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC )OGLGetProcAddress("glCreateShaderObjectARB");
        p_glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC )OGLGetProcAddress("glShaderSourceARB");
        p_glCompileshaderARB = (PFNGLCOMPILESHADERARBPROC )OGLGetProcAddress("glCompileShaderARB");
        p_glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC )OGLGetProcAddress("glCreateProgramObjectARB");
        p_glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)OGLGetProcAddress("glAttachObjectARB");
        p_glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC )OGLGetProcAddress("glLinkProgramARB");
        p_glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC )OGLGetProcAddress("glUseProgramObjectARB");
        p_glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC )OGLGetProcAddress("glValidateProgramARB");
        p_glUniform1iARB = (PFNGLUNIFORM1IARBPROC)OGLGetProcAddress("glUniform1iARB");
        p_glUniform4fARB = (PFNGLUNIFORM4FARBPROC )OGLGetProcAddress("glUniform4fARB");
        p_glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC )OGLGetProcAddress("glUniform4fvARB");
        p_glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC )OGLGetProcAddress("glUniform1fvARB");
        p_glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC )OGLGetProcAddress("glGetUniformLocationARB");
        p_glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)OGLGetProcAddress("glGetInfoLogARB");
        p_glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)OGLGetProcAddress("glVertexAttribPointerARB");
        p_glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)OGLGetProcAddress("glEnableVertexAttribArrayARB");
        p_glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)OGLGetProcAddress("glDisableVertexAttribArrayARB");
        p_glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)OGLGetProcAddress("glBindAttribLocationARB");
        p_glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FPROC)OGLGetProcAddress("glVertexAttrib1fARB");
        p_glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FPROC)OGLGetProcAddress("glVertexAttrib2fARB");
        p_glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FPROC)OGLGetProcAddress("glVertexAttrib3fARB");
        p_glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FPROC)OGLGetProcAddress("glVertexAttrib4fARB");
        p_glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBPROC)OGLGetProcAddress("glVertexAttrib4NubARB");

        if(!p_glDeleteObjectARB
            || !p_glGetHandleARB
            || !p_glDetachObjectARB
            || !p_glCreateShaderObjectARB
            || !p_glShaderSourceARB
            || !p_glCompileshaderARB
            || !p_glCreateProgramObjectARB
            || !p_glAttachObjectARB
            || !p_glUseProgramObjectARB
            || !p_glValidateProgramARB
            || !p_glUniform1iARB
            || !p_glUniform4fARB
            || !p_glUniform4fvARB
            || !p_glUniform1fvARB
            || !p_glGetUniformLocationARB
            || !p_glGetInfoLogARB
            || !p_glVertexAttribPointerARB
            || !p_glEnableVertexAttribArrayARB
            || !p_glDisableVertexAttribArrayARB
            || !p_glBindAttribLocationARB
            || !p_glVertexAttrib1fARB
            || !p_glVertexAttrib2fARB
            || !p_glVertexAttrib3fARB
            || !p_glVertexAttrib4fARB
            || !p_glVertexAttrib4NubARB
        )
        {
            LOGE(INIT, "cannot get proc addr for shader functions.\n");
            GLExt._GL_ARB_shader_objects = FXFALSE;
            GLExt._GL_ARB_vertex_shader = FXFALSE;
            GLExt._GL_ARB_fragment_shader = FXFALSE;
            GLExt.ShaderEnabled = false;
        }
        else
        {
            GLExt.ShaderEnabled = OG_ENABLE_SHADER;
            if(!OG_ENABLE_SHADER)
                LOGW(INIT, "shader supported but disabled in build.\n");
        }
    }
    if(!GLExt.ShaderEnabled)
        LOGW(INIT, "shader not supported, texture & color & alpha combine may not work properly.\n");
    else
    {
        //max texture for programmable pipeline, used by GL_ARB_fragment_program (assembly)
        //but should also be available for GL_ARB_fragment_shader (GLSL)
        GLint ShaderTexCount = 0;
        glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &ShaderTexCount);
        LOGM(INIT, "MultiTexture Textures Units (Shader) = %x\n", ShaderTexCount);
        GLExt.MultiTexCount = max(GLExt.MultiTexCount, ShaderTexCount);
    }

    if(GLExt._GL_EXT_framebuffer_object)
    {
        p_glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)OGLGetProcAddress("glGenFramebuffersEXT");
        p_glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)OGLGetProcAddress("glDeleteFramebuffersEXT");
        p_glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)OGLGetProcAddress("glBindFramebufferEXT");
        p_glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)OGLGetProcAddress("glFramebufferTexture2DEXT");
        p_glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)OGLGetProcAddress("glGenRenderbuffersEXT");
        p_glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)OGLGetProcAddress("glDeleteRenderbuffersEXT");
        p_glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)OGLGetProcAddress("glBindRenderbufferEXT");
        p_glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)OGLGetProcAddress("glRenderbufferStorageEXT");
        p_glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)OGLGetProcAddress("glFramebufferRenderbufferEXT");

        if(!p_glGenFramebuffersEXT
            || !p_glDeleteFramebuffersEXT
            || !p_glBindFramebufferEXT
            || !p_glFramebufferTexture2DEXT
            || !p_glGenRenderbuffersEXT
            || !p_glDeleteRenderbuffersEXT
            || !p_glBindRenderbufferEXT
            || !p_glRenderbufferStorageEXT
            || !p_glFramebufferRenderbufferEXT
        )
        {
            LOGE(INIT, "cannot get proc addr for FBO functions.\n");
            GLExt._GL_EXT_framebuffer_object = FXFALSE;
        }
    }

    p_glGenSamplers = (PFNGLGENSAMPLERSPROC)OGLGetProcAddress("glGenSamplers");
    p_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)OGLGetProcAddress("glDeleteSamplers");
    p_glBindSampler = (PFNGLBINDSAMPLERPROC)OGLGetProcAddress("glBindSampler");
    p_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)OGLGetProcAddress("glSamplerParameteri");

    if(GLExt._GL_ARB_sampler_objects)
    {
        if(!p_glGenSamplers || !p_glDeleteSamplers || !p_glBindSampler || !p_glSamplerParameteri)
        {
            LOGE(INIT, "cannot get proc addr for sampler functions.\n");
            GLExt._GL_ARB_sampler_objects = FXFALSE;
        }
    }
#if GLEXT_FORCE_DETECT_EXTENSIONS
    else if(p_glGenSamplers && p_glDeleteSamplers && p_glBindSampler && p_glSamplerParameteri)
    {
        GLExt._GL_ARB_sampler_objects = FXTRUE;
        LOGM(INIT, "GL_ARB_sampler_objects present, enabling it.\n");
    }
#endif

    if(GLExt._GL_EXT_framebuffer_multisample)
    {
        p_glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)OGLGetProcAddress("glRenderbufferStorageMultisampleEXT");
        if(!p_glRenderbufferStorageMultisampleEXT)
        {
            LOGE(INIT, "cannot get proc addr for framebuffer multisample.\n");
            GLExt._GL_EXT_framebuffer_multisample = FXFALSE;
        }
    }

    if(GLExt._GL_EXT_framebuffer_blit)
    {
        p_glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)OGLGetProcAddress("glBlitFramebufferEXT");
        if(!p_glBlitFramebufferEXT)
        {
            LOGE(INIT, "cannot get proc addr for framebuffer blit.\n");
            GLExt._GL_EXT_framebuffer_blit = FXFALSE;
        }
    }

    if(GLExt._GL_ARB_multisample && GLExt._GL_EXT_framebuffer_multisample && GLExt._GL_EXT_framebuffer_blit)
        GLExt.MSAA_Available = true;

    LOGM(INIT, "GLEXT_LoadFunctions done.\n" );
}