back

gloe.h - opengl extension utility

Extension code for c++ opengl bindings, under a more liberal zlib license (close to public domain).

Once the extensions you want are added in the gloe extension definition area, just call the functions like usual. gloe.h will automatically do an (unprotected) late bind on a function pointer when the function is called.

Also worth checking out stb_gl.h, which also has ext handling plus other utils.

gloe.h
gloe.cpp

gloe.h

/// gloe.h
/// ver 2012.11.8
/// A simple utility for OpenGL ARB extention functions.
///
/// Copyright (c) 2009 Eric Itomura
///
/// This software is provided 'as-is', without any express or implied
/// warranty. In no event will the authors be held liable for any damages
/// arising from the use of this software.
///
/// Permission is granted to anyone to use this software for any purpose,
/// including commercial applications, and to alter it and redistribute it
/// freely.

//-----------------------------------------------
// Instructions, please read:
//
// One .cpp defintion file must include gloe.h with
// GLOE_DEFINITION_FILE defined with a value of 1
// before the include as follows:
//
//     // somefile.cpp
//     #define GLOE_DEFFINITION_FILE 1
//     #define GLOE_TEMPLATE_TYPE_CHECK 1 // optional setting
//     #include "gloe.h"
//
// Any settings defines should come before the
// include as well.
//
// Functions initialize themselves
// when called, allowing them to
// be used immediately.
//
// FuncName_bind(); will preinitialize
// the function to the gl extension,
//
// Gloe will not prevent errors created
// from calling extensions that are not
// implemented by the grpahics driver.
// It is up to you to disable features
// or exit gracefully.
//-----------------------------------------------

//-----------------------------------------------
// settings defines
//
// You may override settings by defining them (0 false / 1 true)
// right before including them in your header/code files,
// otherwise it will use the default values below.

// define for switching between header and defintion file
#ifndef GLOE_DEFFINITION_FILE
    #define GLOE_DEFFINITION_FILE 0
#endif

// activation for stronger typed c++ template version
#ifndef GLOE_TEMPLATE_TYPE_CHECK
    #define GLOE_TEMPLATE_TYPE_CHECK 0
#endif

// effectively disables creation and binding of extension functions
// since certain apple platforms might do binding automatically
#if !defined(GLOE_DISABLE_FUNC_DECLARATION)
    #if defined(__APPLE__)
        #define GLOE_DISABLE_FUNC_DECLARATION 1
    #else
        #define GLOE_DISABLE_FUNC_DECLARATION 0
    #endif
#endif


// settings defines
//-----------------------------------------------

//-----------------------------------------------
// gloe setup code
#if !defined(GLOE_H) || GLOE_DEFFINITION_FILE == 1
#if GLOE_DEFFINITION_FILE == 0 // header file code
    #define GLOE_H

    // setup the proper include files here
    #ifndef GL_GLEXT_LEGACY
    #define GL_GLEXT_LEGACY
    #endif
    
    #if defined(__APPLE__)
    #include <OpenGL/gl.h>
    #include <OpenGL/glu.h>
    #else
    #include <gl/gl.h>
    #include <gl/glext.h>
    #endif

    #if !defined(APIENTRY)
        #if defined(_WIN32)
            #define APIENTRY __stdcall
        #else
            #define APIENTRY
        #endif
    #endif

    #if !defined(GLsizeiptr)
        #define GLsizeiptr GLsizei
    #endif

    #define CREATE_GLOE_FUNC( FUNCNAME, EXTID, RETTYPE, XARGS, BAREARGS ) \
        typedef RETTYPE (APIENTRY * FUNCNAME ## _func) XARGS ; \
        extern FUNCNAME ## _func FUNCNAME; \
        void APIENTRY FUNCNAME ## _bind ();

#else // implementation file code
    #if !defined(GLOE_H)
    #undef GLOE_DEFFINITION_FILE
    #define GLOE_DEFFINITION_FILE 0
    #include "gloe.h"
    #undef GLOE_DEFFINITION_FILE
    #define GLOE_DEFFINITION_FILE 1
    #endif

    #if defined(_WIN32)
        #include "windows.h"
        #define BEglGetProcAddress( funcname ) wglGetProcAddress( funcname )
    #elif defined(__APPLE__)
        #define BEglGetProcAddress( funcname ) 0
    #else
        #define GLX_GLXEXT_PROTOTYPES
        #define BEglGetProcAddress( funcname ) glXGetProcAddressARB( funcname )
    #endif

    #if defined(__cplusplus) && GLOE_TEMPLATE_TYPE_CHECK == 1
        #define GLOE_TEMPLATE_TYPE_CHECK_CPP 1
    #else
        #define GLOE_TEMPLATE_TYPE_CHECK_CPP 0
    #endif

    #if GLOE_TEMPLATE_TYPE_CHECK_CPP == 1
        #define GLOEFUNCCAST

        #define gloExtFuncLookUp( type ) gloExtensionFunc<type>
        template<typename FTP> FTP gloExtensionFunc( const char* extID, FTP * funcPtr );
        template<typename FTP> FTP gloExtensionFunc( const char* extID, FTP * funcPtr )
        {
            FTP returnFunc = reinterpret_cast<FTP>(BEglGetProcAddress(extID));
            (*funcPtr) = returnFunc;
            return returnFunc;
        }
    #else
        #define GLOEGENERICFUNCPTR void*
        #define GLOEFUNCCAST (void**)

        #define gloExtFuncLookUp( type ) gloExtensionFunc
        GLOEGENERICFUNCPTR gloExtensionFunc( const char* extID, GLOEGENERICFUNCPTR* funcPtr );
        GLOEGENERICFUNCPTR gloExtensionFunc( const char* extID, GLOEGENERICFUNCPTR* funcPtr )
        {
            (*funcPtr) = (GLOEGENERICFUNCPTR)BEglGetProcAddress(extID);
            return (*funcPtr);
        }
    #endif

    #ifdef CREATE_GLOE_FUNC
        #undef CREATE_GLOE_FUNC
    #endif
    #define CREATE_GLOE_FUNC( FUNCNAME, EXTID, RETTYPE, XARGS, BAREARGS ) \
        RETTYPE APIENTRY FUNCNAME ## _default XARGS ; \
        RETTYPE APIENTRY FUNCNAME ## _default XARGS \
        { \
            return ((FUNCNAME ## _func)( gloExtFuncLookUp( FUNCNAME ## _func )( EXTID , GLOEFUNCCAST &FUNCNAME ) )) BAREARGS ; \
        } \
        \
        void APIENTRY FUNCNAME ## _bind () \
        { \
            gloExtFuncLookUp( FUNCNAME ## _func )( EXTID, GLOEFUNCCAST &FUNCNAME ) ; \
        } \
        FUNCNAME ## _func FUNCNAME = FUNCNAME ## _default

#endif
// gloe setup code
//-----------------------------------------------

#ifdef __cplusplus
extern "C" {
#endif
//-----------------------------------------------
// CREATE_GLOE_FUNC( funcname, const char* extension id, return type, parameterlist, parameter names)
//  Parameters:
//    1. function name (customizeable)
//    2. opengl extension c-string ID
//    3. return type for gl extension function
//    4. gl extension function parameter list
//    5. gl extension function parameter name list
//
// Add or edit GL extensions below...
//
#if GLOE_DISABLE_FUNC_DECLARATION == 0

CREATE_GLOE_FUNC( glDeleteBuffers, "glDeleteBuffers", void, (GLsizei n, const GLuint * buffers), (n,buffers) );
CREATE_GLOE_FUNC( glGenBuffers, "glGenBuffers", void, (GLsizei n, GLuint * buffers), (n,buffers) );
CREATE_GLOE_FUNC( glBufferData, "glBufferData", void, (GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage), (target,size,data,usage) );
CREATE_GLOE_FUNC( glBindBuffer, "glBindBuffer", void, (GLenum target, GLuint buffer), (target,buffer) );
CREATE_GLOE_FUNC( glMapBuffer, "glMapBufferARB", void* , (GLenum target, GLenum access), (target,access) );
CREATE_GLOE_FUNC( glUnmapBuffer, "glUnmapBufferARB", GLboolean, (GLenum target), (target) );

CREATE_GLOE_FUNC( glDrawRangeElements, "glDrawRangeElements", void, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices), (mode,start,end,count,type,indices) );

CREATE_GLOE_FUNC( glCreateShader, "glCreateShader", GLuint, (GLenum shaderType), (shaderType) );
CREATE_GLOE_FUNC( glGenerateMipmap, "glGenerateMipmapEXT", void, (GLenum target), (target) );
CREATE_GLOE_FUNC( glUseProgram, "glUseProgram", void, (GLuint program), (program) );

#endif
// extensions
//-----------------------------------------------
#ifdef __cplusplus
}
#endif

#endif

gloe.cpp

// the example cpp file
#define GLOE_DEFFINITION_FILE 1
#include "gloe.h"