tests/caveview/stb_glprog.h - third_party/stb - Git at Google

 // stb_glprog v0.02 public domain         functions to reduce GLSL boilerplate
 // http://nothings.org/stb/stb_glprog.h   especially with GL1 + ARB extensions
 //
 // Following defines *before* including have following effects:
 //
 //     STB_GLPROG_IMPLEMENTATION
 //           creates the implementation
 //
 //     STB_GLPROG_STATIC
 //           forces the implementation to be static (private to file that creates it)
 //
 //     STB_GLPROG_ARB
 //           uses ARB extension names for GLSL functions and enumerants instead of core names
 //
 //     STB_GLPROG_ARB_DEFINE_EXTENSIONS
 //           instantiates function pointers needed, static to implementing file
 //           to avoid collisions (but will collide if implementing file also
 //           defines any; best to isolate this to its own file in this case).
 //           This will try to automatically #include glext.h, but if it's not
 //           in the default include directories you'll need to include it
 //           yourself and define the next macro.
 //
 //     STB_GLPROG_SUPPRESS_GLEXT_INCLUDE
 //           disables the automatic #include of glext.h which is normally
 //           forced by STB_GLPROG_ARB_DEFINE_EXTENSIONS
 //
 // So, e.g., sample usage on an old Windows compiler:
 //
 //     #define STB_GLPROG_IMPLEMENTATION
 //     #define STB_GLPROG_ARB_DEFINE_EXTENSIONS
 //     #include <windows.h>
 //     #include "gl/gl.h"
 //     #include "stb_glprog.h"
 //
 // Note though that the header-file version of this (when you don't define
 // STB_GLPROG_IMPLEMENTATION) still uses GLint and such, so you basically
 // can only include it in places where you're already including GL, especially
 // on Windows where including "gl.h" requires (some of) "windows.h".
 //
 // See following comment blocks for function documentation.
 //
 // Version history:
 //    2013-12-08   v0.02   slightly simplified API and reduced GL resource usage (@rygorous)
 //    2013-12-08   v0.01   initial release


 // header file section starts here
 #if !defined(INCLUDE_STB_GLPROG_H)
 #define INCLUDE_STB_GLPROG_H

 #ifndef STB_GLPROG_STATIC
 #ifdef __cplusplus
 extern "C" {
 #endif

 //////////////////////////////////////////////////////////////////////////////

 /////////////    SHADER CREATION


 /// EASY API

 extern GLuint stbgl_create_program(char const **vertex_source, char const **frag_source, char const **binds, char *error, int error_buflen);
 // This function returns a compiled program or 0 if there's an error.
 // To free the created program, call stbgl_delete_program.
 //
 //     stbgl_create_program(
 //             char **vertex_source,   // NULL or one or more strings with the vertex shader source, with a final NULL
 //             char **frag_source,     // NULL or one or more strings with the fragment shader source, with a final NULL
 //             char **binds,           // NULL or zero or more strings with attribute bind names, with a final NULL
 //             char *error,            // output location where compile error message is placed
 //             int error_buflen)       // length of error output buffer
 //
 // Returns a GLuint with the GL program object handle.
 //
 // If an individual bind string is "", no name is bound to that slot (this
 // allows you to create binds that aren't continuous integers starting at 0).
 //
 // If the vertex shader is NULL, then fixed-function vertex pipeline
 // is used, if that's legal in your version of GL.
 //
 // If the fragment shader is NULL, then fixed-function fragment pipeline
 // is used, if that's legal in your version of GL.

 extern void stgbl_delete_program(GLuint program);
 // deletes a program created by stbgl_create_program or stbgl_link_program


 /// FLEXIBLE API

 extern GLuint stbgl_compile_shader(GLenum type, char const **sources, int num_sources, char *error, int error_buflen);
 // compiles a shader. returns the shader on success or 0 on failure.
 //
 //    type          either:  GL_VERTEX_SHADER or GL_FRAGMENT_SHADER
 //                     or    GL_VERTEX_SHADER_ARB or GL_FRAGMENT_SHADER_ARB
 //                     or    STBGL_VERTEX_SHADER or STBGL_FRAGMENT_SHADER
 //    sources       array of strings containing the shader source
 //    num_sources   number of string in sources, or -1 meaning sources is NULL-terminated
 //    error         string to output compiler error to
 //    error_buflen  length of error buffer in chars

 extern GLuint stbgl_link_program(GLuint vertex_shader, GLuint fragment_shader, char const **binds, int num_binds, char *error, int error_buflen);
 // links a shader. returns the linked program on success or 0 on failure.
 //
 //    vertex_shader    a compiled vertex shader from stbgl_compile_shader, or 0 for fixed-function (if legal)
 //    fragment_shader  a compiled fragment shader from stbgl_compile_shader, or 0 for fixed-function (if legal)
 //

 extern void stbgl_delete_shader(GLuint shader);
 // deletes a shader created by stbgl_compile_shader


 /////////////    RENDERING WITH SHADERS

 extern GLint stbgl_find_uniform(GLuint prog, char *uniform);

 extern void stbgl_find_uniforms(GLuint prog, GLint *locations, char const **uniforms, int num_uniforms);
 // Given the locations array that is num_uniforms long, fills out
 // the locations of each of those uniforms for the specified program.
 // If num_uniforms is -1, then uniforms[] must be NULL-terminated

 // the following functions just wrap the difference in naming between GL2+ and ARB,
 // so you don't need them unless you're using both ARB and GL2+ in the same codebase,
 // or you're relying on this lib to provide the extensions
 extern void stbglUseProgram(GLuint program);
 extern void stbglVertexAttribPointer(GLuint index,  GLint size,  GLenum type,  GLboolean normalized,  GLsizei stride,  const GLvoid * pointer);
 extern void stbglEnableVertexAttribArray(GLuint index);
 extern void stbglDisableVertexAttribArray(GLuint index);
 extern void stbglUniform1fv(GLint loc, GLsizei count, const GLfloat *v);
 extern void stbglUniform2fv(GLint loc, GLsizei count, const GLfloat *v);
 extern void stbglUniform3fv(GLint loc, GLsizei count, const GLfloat *v);
 extern void stbglUniform4fv(GLint loc, GLsizei count, const GLfloat *v);
 extern void stbglUniform1iv(GLint loc, GLsizei count, const GLint *v);
 extern void stbglUniform2iv(GLint loc, GLsizei count, const GLint *v);
 extern void stbglUniform3iv(GLint loc, GLsizei count, const GLint *v);
 extern void stbglUniform4iv(GLint loc, GLsizei count, const GLint *v);
 extern void stbglUniform1f(GLint loc, float v0);
 extern void stbglUniform2f(GLint loc, float v0, float v1);
 extern void stbglUniform3f(GLint loc, float v0, float v1, float v2);
 extern void stbglUniform4f(GLint loc, float v0, float v1, float v2, float v3);
 extern void stbglUniform1i(GLint loc, GLint v0);
 extern void stbglUniform2i(GLint loc, GLint v0, GLint v1);
 extern void stbglUniform3i(GLint loc, GLint v0, GLint v1, GLint v2);
 extern void stbglUniform4i(GLint loc, GLint v0, GLint v1, GLint v2, GLint v3);


 //////////////     END OF FUNCTIONS

 //////////////////////////////////////////////////////////////////////////////

 #ifdef __cplusplus
 }
 #endif
 #endif // STB_GLPROG_STATIC

 #ifdef STB_GLPROG_ARB
 #define STBGL_VERTEX_SHADER    GL_VERTEX_SHADER_ARB
 #define STBGL_FRAGMENT_SHADER  GL_FRAGMENT_SHADER_ARB
 #else
 #define STBGL_VERTEX_SHADER    GL_VERTEX_SHADER
 #define STBGL_FRAGMENT_SHADER  GL_FRAGMENT_SHADER
 #endif

 #endif // INCLUDE_STB_GLPROG_H


 /////////    header file section ends here


 #ifdef STB_GLPROG_IMPLEMENTATION
 #include <string.h> // strncpy

 #ifdef STB_GLPROG_STATIC
 #define STB_GLPROG_DECLARE static
 #else
 #define STB_GLPROG_DECLARE extern
 #endif

 // check if user wants this file to define the GL extensions itself
 #ifdef STB_GLPROG_ARB_DEFINE_EXTENSIONS
 #define STB_GLPROG_ARB  // make sure later code uses the extensions

 #ifndef STB_GLPROG_SUPPRESS_GLEXT_INCLUDE
 #include "glext.h"
 #endif

 #define STB_GLPROG_EXTENSIONS                                 \
    STB_GLPROG_FUNC(ATTACHOBJECT        , AttachObject        ) \
    STB_GLPROG_FUNC(BINDATTRIBLOCATION  , BindAttribLocation  ) \
    STB_GLPROG_FUNC(COMPILESHADER       , CompileShader       ) \
    STB_GLPROG_FUNC(CREATEPROGRAMOBJECT , CreateProgramObject ) \
    STB_GLPROG_FUNC(CREATESHADEROBJECT  , CreateShaderObject  ) \
    STB_GLPROG_FUNC(DELETEOBJECT        , DeleteObject        ) \
    STB_GLPROG_FUNC(DETACHOBJECT        , DetachObject        ) \
    STB_GLPROG_FUNC(DISABLEVERTEXATTRIBARRAY, DisableVertexAttribArray) \
    STB_GLPROG_FUNC(ENABLEVERTEXATTRIBARRAY,  EnableVertexAttribArray ) \
    STB_GLPROG_FUNC(GETATTACHEDOBJECTS  , GetAttachedObjects  ) \
    STB_GLPROG_FUNC(GETOBJECTPARAMETERIV, GetObjectParameteriv) \
    STB_GLPROG_FUNC(GETINFOLOG          , GetInfoLog          ) \
    STB_GLPROG_FUNC(GETUNIFORMLOCATION  , GetUniformLocation  ) \
    STB_GLPROG_FUNC(LINKPROGRAM         , LinkProgram         ) \
    STB_GLPROG_FUNC(SHADERSOURCE        , ShaderSource        ) \
    STB_GLPROG_FUNC(UNIFORM1F           , Uniform1f           ) \
    STB_GLPROG_FUNC(UNIFORM2F           , Uniform2f           ) \
    STB_GLPROG_FUNC(UNIFORM3F           , Uniform3f           ) \
    STB_GLPROG_FUNC(UNIFORM4F           , Uniform4f           ) \
    STB_GLPROG_FUNC(UNIFORM1I           , Uniform1i           ) \
    STB_GLPROG_FUNC(UNIFORM2I           , Uniform2i           ) \
    STB_GLPROG_FUNC(UNIFORM3I           , Uniform3i           ) \
    STB_GLPROG_FUNC(UNIFORM4I           , Uniform4i           ) \
    STB_GLPROG_FUNC(UNIFORM1FV          , Uniform1fv          ) \
    STB_GLPROG_FUNC(UNIFORM2FV          , Uniform2fv          ) \
    STB_GLPROG_FUNC(UNIFORM3FV          , Uniform3fv          ) \
    STB_GLPROG_FUNC(UNIFORM4FV          , Uniform4fv          ) \
    STB_GLPROG_FUNC(UNIFORM1IV          , Uniform1iv          ) \
    STB_GLPROG_FUNC(UNIFORM2IV          , Uniform2iv          ) \
    STB_GLPROG_FUNC(UNIFORM3IV          , Uniform3iv          ) \
    STB_GLPROG_FUNC(UNIFORM4IV          , Uniform4iv          ) \
    STB_GLPROG_FUNC(USEPROGRAMOBJECT    , UseProgramObject    ) \
    STB_GLPROG_FUNC(VERTEXATTRIBPOINTER , VertexAttribPointer )

 // define the static function pointers

 #define STB_GLPROG_FUNC(x,y)  static PFNGL##x##ARBPROC gl##y##ARB;
 STB_GLPROG_EXTENSIONS
 #undef STB_GLPROG_FUNC

 // define the GetProcAddress

 #ifdef _WIN32
 #ifndef WINGDIAPI
 #ifndef STB__HAS_WGLPROC
 typedef int (__stdcall *stbgl__voidfunc)(void);
 static __declspec(dllimport) stbgl__voidfunc wglGetProcAddress(char *);
 #endif
 #endif
 #define STBGL__GET_FUNC(x)   wglGetProcAddress(x)
 #else
 #error "need to define how this platform gets extensions"
 #endif

 // create a function that fills out the function pointers

 static void stb_glprog_init(void)
 {
    static int initialized = 0; // not thread safe!
    if (initialized) return;
    #define STB_GLPROG_FUNC(x,y) gl##y##ARB = (PFNGL##x##ARBPROC) STBGL__GET_FUNC("gl" #y "ARB");
    STB_GLPROG_EXTENSIONS
    #undef STB_GLPROG_FUNC
 }
 #undef STB_GLPROG_EXTENSIONS

 #else
 static void stb_glprog_init(void)
 {
 }
 #endif


 // define generic names for many of the gl functions or extensions for later use;
 // note that in some cases there are two functions in core and one function in ARB
 #ifdef STB_GLPROG_ARB
 #define stbglCreateShader          glCreateShaderObjectARB
 #define stbglDeleteShader          glDeleteObjectARB
 #define stbglAttachShader          glAttachObjectARB
 #define stbglDetachShader          glDetachObjectARB
 #define stbglShaderSource          glShaderSourceARB
 #define stbglCompileShader         glCompileShaderARB
 #define stbglGetShaderStatus(a,b)  glGetObjectParameterivARB(a, GL_OBJECT_COMPILE_STATUS_ARB, b)
 #define stbglGetShaderInfoLog      glGetInfoLogARB
 #define stbglCreateProgram         glCreateProgramObjectARB
 #define stbglDeleteProgram         glDeleteObjectARB
 #define stbglLinkProgram           glLinkProgramARB
 #define stbglGetProgramStatus(a,b) glGetObjectParameterivARB(a, GL_OBJECT_LINK_STATUS_ARB, b)
 #define stbglGetProgramInfoLog     glGetInfoLogARB
 #define stbglGetAttachedShaders    glGetAttachedObjectsARB
 #define stbglBindAttribLocation    glBindAttribLocationARB
 #define stbglGetUniformLocation    glGetUniformLocationARB
 #define stbgl_UseProgram           glUseProgramObjectARB
 #else
 #define stbglCreateShader          glCreateShader
 #define stbglDeleteShader          glDeleteShader
 #define stbglAttachShader          glAttachShader
 #define stbglDetachShader          glDetachShader
 #define stbglShaderSource          glShaderSource
 #define stbglCompileShader         glCompileShader
 #define stbglGetShaderStatus(a,b)  glGetShaderiv(a, GL_COMPILE_STATUS, b)
 #define stbglGetShaderInfoLog      glGetShaderInfoLog
 #define stbglCreateProgram         glCreateProgram
 #define stbglDeleteProgram         glDeleteProgram
 #define stbglLinkProgram           glLinkProgram
 #define stbglGetProgramStatus(a,b) glGetProgramiv(a, GL_LINK_STATUS, b)
 #define stbglGetProgramInfoLog     glGetProgramInfoLog
 #define stbglGetAttachedShaders    glGetAttachedShaders
 #define stbglBindAttribLocation    glBindAttribLocation
 #define stbglGetUniformLocation    glGetUniformLocation
 #define stbgl_UseProgram           glUseProgram
 #endif


 // perform a safe strcat of 3 strings, given that we can't rely on portable snprintf
 // if you need to break on error, this is the best place to place a breakpoint
 static void stb_glprog_error(char *error, int error_buflen, char *str1, char *str2, char *str3)
 {
    int n = strlen(str1);
    strncpy(error, str1, error_buflen);
    if (n < error_buflen && str2) {
       strncpy(error+n, str2, error_buflen - n);
       n += strlen(str2);
       if (n < error_buflen && str3) {
          strncpy(error+n, str3, error_buflen - n);
       }
    }
    error[error_buflen-1] = 0;
 }

 STB_GLPROG_DECLARE GLuint stbgl_compile_shader(GLenum type, char const **sources, int num_sources, char *error, int error_buflen)
 {
    char *typename = (type == STBGL_VERTEX_SHADER ? "vertex" : "fragment");
    int len;
    GLint result;
    GLuint shader;

    // initialize the extensions if we haven't already
    stb_glprog_init();

    // allocate

    shader = stbglCreateShader(type);
    if (!shader) {
       stb_glprog_error(error, error_buflen, "Couldn't allocate shader object in stbgl_compile_shader for ", typename, NULL);
       return 0;
    }

    // compile

    // if num_sources is negative, assume source is NULL-terminated and count the non-NULL ones
    if (num_sources < 0)
       for (num_sources = 0; sources[num_sources] != NULL; ++num_sources)
          ;
    stbglShaderSource(shader, num_sources, sources, NULL);
    stbglCompileShader(shader);
    stbglGetShaderStatus(shader, &result);
    if (result)
       return shader;

    // errors

    stb_glprog_error(error, error_buflen, "Compile error for ", typename, " shader: ");
    len = strlen(error);
    if (len < error_buflen)
       stbglGetShaderInfoLog(shader, error_buflen-len, NULL, error+len);

    stbglDeleteShader(shader);
    return 0;
 }

 STB_GLPROG_DECLARE GLuint stbgl_link_program(GLuint vertex_shader, GLuint fragment_shader, char const **binds, int num_binds, char *error, int error_buflen)
 {
    int len;
    GLint result;

    // allocate

    GLuint prog = stbglCreateProgram();
    if (!prog) {
       stb_glprog_error(error, error_buflen, "Couldn't allocate program object in stbgl_link_program", NULL, NULL);
       return 0;
    }

    // attach

    if (vertex_shader)
       stbglAttachShader(prog, vertex_shader);
    if (fragment_shader)
       stbglAttachShader(prog, fragment_shader);

    // attribute binds

    if (binds) {
       int i;
       // if num_binds is negative, then it is NULL terminated
       if (num_binds < 0)
          for (num_binds=0; binds[num_binds]; ++num_binds)
             ;
       for (i=0; i < num_binds; ++i)
          if (binds[i] && binds[i][0]) // empty binds can be NULL or ""
             stbglBindAttribLocation(prog, i, binds[i]);
    }

    // link

    stbglLinkProgram(prog);

    // detach

    if (vertex_shader)
       stbglDetachShader(prog, vertex_shader);
    if (fragment_shader)
       stbglDetachShader(prog, fragment_shader);

    // errors

    stbglGetProgramStatus(prog, &result);
    if (result)
       return prog;

    stb_glprog_error(error, error_buflen, "Link error: ", NULL, NULL);
    len = strlen(error);
    if (len < error_buflen)
       stbglGetProgramInfoLog(prog, error_buflen-len, NULL, error+len);

    stbglDeleteProgram(prog);
    return 0;
 }

 STB_GLPROG_DECLARE GLuint stbgl_create_program(char const **vertex_source, char const **frag_source, char const **binds, char *error, int error_buflen)
 {
    GLuint vertex, fragment, prog=0;
    vertex = stbgl_compile_shader(STBGL_VERTEX_SHADER, vertex_source, -1, error, error_buflen);
    if (vertex) {
       fragment = stbgl_compile_shader(STBGL_FRAGMENT_SHADER, frag_source, -1, error, error_buflen);
       if (fragment)
          prog = stbgl_link_program(vertex, fragment, binds, -1, error, error_buflen);
       if (fragment)
          stbglDeleteShader(fragment);
       stbglDeleteShader(vertex);
    }
    return prog;
 }

 STB_GLPROG_DECLARE void stbgl_delete_shader(GLuint shader)
 {
    stbglDeleteShader(shader);
 }

 STB_GLPROG_DECLARE void stgbl_delete_program(GLuint program)
 {
    stbglDeleteProgram(program);
 }

 GLint stbgl_find_uniform(GLuint prog, char *uniform)
 {
    return stbglGetUniformLocation(prog, uniform);
 }

 STB_GLPROG_DECLARE void stbgl_find_uniforms(GLuint prog, GLint *locations, char const **uniforms, int num_uniforms)
 {
    int i;
    if (num_uniforms < 0)
       num_uniforms = 999999;
    for (i=0; i < num_uniforms && uniforms[i]; ++i)
       locations[i] = stbglGetUniformLocation(prog, uniforms[i]);
 }

 STB_GLPROG_DECLARE void stbglUseProgram(GLuint program)
 {
    stbgl_UseProgram(program);
 }

 #ifdef STB_GLPROG_ARB
 #define STBGL_ARBIFY(name)   name##ARB
 #else
 #define STBGL_ARBIFY(name)   name
 #endif

 STB_GLPROG_DECLARE void stbglVertexAttribPointer(GLuint index,  GLint size,  GLenum type,  GLboolean normalized,  GLsizei stride,  const GLvoid * pointer)
 {
    STBGL_ARBIFY(glVertexAttribPointer)(index, size, type, normalized, stride, pointer);
 }

 STB_GLPROG_DECLARE void stbglEnableVertexAttribArray (GLuint index) { STBGL_ARBIFY(glEnableVertexAttribArray )(index); }
 STB_GLPROG_DECLARE void stbglDisableVertexAttribArray(GLuint index) { STBGL_ARBIFY(glDisableVertexAttribArray)(index); }

 STB_GLPROG_DECLARE void stbglUniform1fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform1fv)(loc,count,v); }
 STB_GLPROG_DECLARE void stbglUniform2fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform2fv)(loc,count,v); }
 STB_GLPROG_DECLARE void stbglUniform3fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform3fv)(loc,count,v); }
 STB_GLPROG_DECLARE void stbglUniform4fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform4fv)(loc,count,v); }

 STB_GLPROG_DECLARE void stbglUniform1iv(GLint loc, GLsizei count, const GLint   *v) { STBGL_ARBIFY(glUniform1iv)(loc,count,v); }
 STB_GLPROG_DECLARE void stbglUniform2iv(GLint loc, GLsizei count, const GLint   *v) { STBGL_ARBIFY(glUniform2iv)(loc,count,v); }
 STB_GLPROG_DECLARE void stbglUniform3iv(GLint loc, GLsizei count, const GLint   *v) { STBGL_ARBIFY(glUniform3iv)(loc,count,v); }
 STB_GLPROG_DECLARE void stbglUniform4iv(GLint loc, GLsizei count, const GLint   *v) { STBGL_ARBIFY(glUniform4iv)(loc,count,v); }

 STB_GLPROG_DECLARE void stbglUniform1f(GLint loc, float v0)
     { STBGL_ARBIFY(glUniform1f)(loc,v0); }
 STB_GLPROG_DECLARE void stbglUniform2f(GLint loc, float v0, float v1)
     { STBGL_ARBIFY(glUniform2f)(loc,v0,v1); }
 STB_GLPROG_DECLARE void stbglUniform3f(GLint loc, float v0, float v1, float v2)
     { STBGL_ARBIFY(glUniform3f)(loc,v0,v1,v2); }
 STB_GLPROG_DECLARE void stbglUniform4f(GLint loc, float v0, float v1, float v2, float v3)
     { STBGL_ARBIFY(glUniform4f)(loc,v0,v1,v2,v3); }

 STB_GLPROG_DECLARE void stbglUniform1i(GLint loc, GLint v0)
     { STBGL_ARBIFY(glUniform1i)(loc,v0); }
 STB_GLPROG_DECLARE void stbglUniform2i(GLint loc, GLint v0, GLint v1)
     { STBGL_ARBIFY(glUniform2i)(loc,v0,v1); }
 STB_GLPROG_DECLARE void stbglUniform3i(GLint loc, GLint v0, GLint v1, GLint v2)
     { STBGL_ARBIFY(glUniform3i)(loc,v0,v1,v2); }
 STB_GLPROG_DECLARE void stbglUniform4i(GLint loc, GLint v0, GLint v1, GLint v2, GLint v3)
     { STBGL_ARBIFY(glUniform4i)(loc,v0,v1,v2,v3); }

 #endif
	// stb_glprog v0.02 public domain functions to reduce GLSL boilerplate
	// http://nothings.org/stb/stb_glprog.h especially with GL1 + ARB extensions
	//
	// Following defines before including have following effects:
	//
	// STB_GLPROG_IMPLEMENTATION
	// creates the implementation
	//
	// STB_GLPROG_STATIC
	// forces the implementation to be static (private to file that creates it)
	//
	// STB_GLPROG_ARB
	// uses ARB extension names for GLSL functions and enumerants instead of core names
	//
	// STB_GLPROG_ARB_DEFINE_EXTENSIONS
	// instantiates function pointers needed, static to implementing file
	// to avoid collisions (but will collide if implementing file also
	// defines any; best to isolate this to its own file in this case).
	// This will try to automatically #include glext.h, but if it's not
	// in the default include directories you'll need to include it
	// yourself and define the next macro.
	//
	// STB_GLPROG_SUPPRESS_GLEXT_INCLUDE
	// disables the automatic #include of glext.h which is normally
	// forced by STB_GLPROG_ARB_DEFINE_EXTENSIONS
	//
	// So, e.g., sample usage on an old Windows compiler:
	//
	// #define STB_GLPROG_IMPLEMENTATION
	// #define STB_GLPROG_ARB_DEFINE_EXTENSIONS
	// #include <windows.h>
	// #include "gl/gl.h"
	// #include "stb_glprog.h"
	//
	// Note though that the header-file version of this (when you don't define
	// STB_GLPROG_IMPLEMENTATION) still uses GLint and such, so you basically
	// can only include it in places where you're already including GL, especially
	// on Windows where including "gl.h" requires (some of) "windows.h".
	//
	// See following comment blocks for function documentation.
	//
	// Version history:
	// 2013-12-08 v0.02 slightly simplified API and reduced GL resource usage (@rygorous)
	// 2013-12-08 v0.01 initial release


	// header file section starts here
	#if !defined(INCLUDE_STB_GLPROG_H)
	#define INCLUDE_STB_GLPROG_H

	#ifndef STB_GLPROG_STATIC
	#ifdef __cplusplus
	extern "C" {
	#endif

	//////////////////////////////////////////////////////////////////////////////

	///////////// SHADER CREATION


	/// EASY API

	extern GLuint stbgl_create_program(char const vertex_source, char const frag_source, char const *binds, char error, int error_buflen);
	// This function returns a compiled program or 0 if there's an error.
	// To free the created program, call stbgl_delete_program.
	//
	// stbgl_create_program(
	// char **vertex_source, // NULL or one or more strings with the vertex shader source, with a final NULL
	// char **frag_source, // NULL or one or more strings with the fragment shader source, with a final NULL
	// char **binds, // NULL or zero or more strings with attribute bind names, with a final NULL
	// char *error, // output location where compile error message is placed
	// int error_buflen) // length of error output buffer
	//
	// Returns a GLuint with the GL program object handle.
	//
	// If an individual bind string is "", no name is bound to that slot (this
	// allows you to create binds that aren't continuous integers starting at 0).
	//
	// If the vertex shader is NULL, then fixed-function vertex pipeline
	// is used, if that's legal in your version of GL.
	//
	// If the fragment shader is NULL, then fixed-function fragment pipeline
	// is used, if that's legal in your version of GL.

	extern void stgbl_delete_program(GLuint program);
	// deletes a program created by stbgl_create_program or stbgl_link_program


	/// FLEXIBLE API

	extern GLuint stbgl_compile_shader(GLenum type, char const *sources, int num_sources, char error, int error_buflen);
	// compiles a shader. returns the shader on success or 0 on failure.
	//
	// type either: GL_VERTEX_SHADER or GL_FRAGMENT_SHADER
	// or GL_VERTEX_SHADER_ARB or GL_FRAGMENT_SHADER_ARB
	// or STBGL_VERTEX_SHADER or STBGL_FRAGMENT_SHADER
	// sources array of strings containing the shader source
	// num_sources number of string in sources, or -1 meaning sources is NULL-terminated
	// error string to output compiler error to
	// error_buflen length of error buffer in chars

	extern GLuint stbgl_link_program(GLuint vertex_shader, GLuint fragment_shader, char const *binds, int num_binds, char error, int error_buflen);
	// links a shader. returns the linked program on success or 0 on failure.
	//
	// vertex_shader a compiled vertex shader from stbgl_compile_shader, or 0 for fixed-function (if legal)
	// fragment_shader a compiled fragment shader from stbgl_compile_shader, or 0 for fixed-function (if legal)
	//

	extern void stbgl_delete_shader(GLuint shader);
	// deletes a shader created by stbgl_compile_shader


	///////////// RENDERING WITH SHADERS

	extern GLint stbgl_find_uniform(GLuint prog, char *uniform);

	extern void stbgl_find_uniforms(GLuint prog, GLint locations, char const *uniforms, int num_uniforms);
	// Given the locations array that is num_uniforms long, fills out
	// the locations of each of those uniforms for the specified program.
	// If num_uniforms is -1, then uniforms[] must be NULL-terminated

	// the following functions just wrap the difference in naming between GL2+ and ARB,
	// so you don't need them unless you're using both ARB and GL2+ in the same codebase,
	// or you're relying on this lib to provide the extensions
	extern void stbglUseProgram(GLuint program);
	extern void stbglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
	extern void stbglEnableVertexAttribArray(GLuint index);
	extern void stbglDisableVertexAttribArray(GLuint index);
	extern void stbglUniform1fv(GLint loc, GLsizei count, const GLfloat *v);
	extern void stbglUniform2fv(GLint loc, GLsizei count, const GLfloat *v);
	extern void stbglUniform3fv(GLint loc, GLsizei count, const GLfloat *v);
	extern void stbglUniform4fv(GLint loc, GLsizei count, const GLfloat *v);
	extern void stbglUniform1iv(GLint loc, GLsizei count, const GLint *v);
	extern void stbglUniform2iv(GLint loc, GLsizei count, const GLint *v);
	extern void stbglUniform3iv(GLint loc, GLsizei count, const GLint *v);
	extern void stbglUniform4iv(GLint loc, GLsizei count, const GLint *v);
	extern void stbglUniform1f(GLint loc, float v0);
	extern void stbglUniform2f(GLint loc, float v0, float v1);
	extern void stbglUniform3f(GLint loc, float v0, float v1, float v2);
	extern void stbglUniform4f(GLint loc, float v0, float v1, float v2, float v3);
	extern void stbglUniform1i(GLint loc, GLint v0);
	extern void stbglUniform2i(GLint loc, GLint v0, GLint v1);
	extern void stbglUniform3i(GLint loc, GLint v0, GLint v1, GLint v2);
	extern void stbglUniform4i(GLint loc, GLint v0, GLint v1, GLint v2, GLint v3);


	////////////// END OF FUNCTIONS

	//////////////////////////////////////////////////////////////////////////////

	#ifdef __cplusplus
	}
	#endif
	#endif // STB_GLPROG_STATIC

	#ifdef STB_GLPROG_ARB
	#define STBGL_VERTEX_SHADER GL_VERTEX_SHADER_ARB
	#define STBGL_FRAGMENT_SHADER GL_FRAGMENT_SHADER_ARB
	#else
	#define STBGL_VERTEX_SHADER GL_VERTEX_SHADER
	#define STBGL_FRAGMENT_SHADER GL_FRAGMENT_SHADER
	#endif

	#endif // INCLUDE_STB_GLPROG_H


	///////// header file section ends here


	#ifdef STB_GLPROG_IMPLEMENTATION
	#include <string.h> // strncpy

	#ifdef STB_GLPROG_STATIC
	#define STB_GLPROG_DECLARE static
	#else
	#define STB_GLPROG_DECLARE extern
	#endif

	// check if user wants this file to define the GL extensions itself
	#ifdef STB_GLPROG_ARB_DEFINE_EXTENSIONS
	#define STB_GLPROG_ARB // make sure later code uses the extensions

	#ifndef STB_GLPROG_SUPPRESS_GLEXT_INCLUDE
	#include "glext.h"
	#endif

	#define STB_GLPROG_EXTENSIONS \
	STB_GLPROG_FUNC(ATTACHOBJECT , AttachObject ) \
	STB_GLPROG_FUNC(BINDATTRIBLOCATION , BindAttribLocation ) \
	STB_GLPROG_FUNC(COMPILESHADER , CompileShader ) \
	STB_GLPROG_FUNC(CREATEPROGRAMOBJECT , CreateProgramObject ) \
	STB_GLPROG_FUNC(CREATESHADEROBJECT , CreateShaderObject ) \
	STB_GLPROG_FUNC(DELETEOBJECT , DeleteObject ) \
	STB_GLPROG_FUNC(DETACHOBJECT , DetachObject ) \
	STB_GLPROG_FUNC(DISABLEVERTEXATTRIBARRAY, DisableVertexAttribArray) \
	STB_GLPROG_FUNC(ENABLEVERTEXATTRIBARRAY, EnableVertexAttribArray ) \
	STB_GLPROG_FUNC(GETATTACHEDOBJECTS , GetAttachedObjects ) \
	STB_GLPROG_FUNC(GETOBJECTPARAMETERIV, GetObjectParameteriv) \
	STB_GLPROG_FUNC(GETINFOLOG , GetInfoLog ) \
	STB_GLPROG_FUNC(GETUNIFORMLOCATION , GetUniformLocation ) \
	STB_GLPROG_FUNC(LINKPROGRAM , LinkProgram ) \
	STB_GLPROG_FUNC(SHADERSOURCE , ShaderSource ) \
	STB_GLPROG_FUNC(UNIFORM1F , Uniform1f ) \
	STB_GLPROG_FUNC(UNIFORM2F , Uniform2f ) \
	STB_GLPROG_FUNC(UNIFORM3F , Uniform3f ) \
	STB_GLPROG_FUNC(UNIFORM4F , Uniform4f ) \
	STB_GLPROG_FUNC(UNIFORM1I , Uniform1i ) \
	STB_GLPROG_FUNC(UNIFORM2I , Uniform2i ) \
	STB_GLPROG_FUNC(UNIFORM3I , Uniform3i ) \
	STB_GLPROG_FUNC(UNIFORM4I , Uniform4i ) \
	STB_GLPROG_FUNC(UNIFORM1FV , Uniform1fv ) \
	STB_GLPROG_FUNC(UNIFORM2FV , Uniform2fv ) \
	STB_GLPROG_FUNC(UNIFORM3FV , Uniform3fv ) \
	STB_GLPROG_FUNC(UNIFORM4FV , Uniform4fv ) \
	STB_GLPROG_FUNC(UNIFORM1IV , Uniform1iv ) \
	STB_GLPROG_FUNC(UNIFORM2IV , Uniform2iv ) \
	STB_GLPROG_FUNC(UNIFORM3IV , Uniform3iv ) \
	STB_GLPROG_FUNC(UNIFORM4IV , Uniform4iv ) \
	STB_GLPROG_FUNC(USEPROGRAMOBJECT , UseProgramObject ) \
	STB_GLPROG_FUNC(VERTEXATTRIBPOINTER , VertexAttribPointer )

	// define the static function pointers

	#define STB_GLPROG_FUNC(x,y) static PFNGL##x##ARBPROC gl##y##ARB;
	STB_GLPROG_EXTENSIONS
	#undef STB_GLPROG_FUNC

	// define the GetProcAddress

	#ifdef _WIN32
	#ifndef WINGDIAPI
	#ifndef STB__HAS_WGLPROC
	typedef int (__stdcall *stbgl__voidfunc)(void);
	static __declspec(dllimport) stbgl__voidfunc wglGetProcAddress(char *);
	#endif
	#endif
	#define STBGL__GET_FUNC(x) wglGetProcAddress(x)
	#else
	#error "need to define how this platform gets extensions"
	#endif

	// create a function that fills out the function pointers

	static void stb_glprog_init(void)
	{
	static int initialized = 0; // not thread safe!
	if (initialized) return;
	#define STB_GLPROG_FUNC(x,y) gl##y##ARB = (PFNGL##x##ARBPROC) STBGL__GET_FUNC("gl" #y "ARB");
	STB_GLPROG_EXTENSIONS
	#undef STB_GLPROG_FUNC
	}
	#undef STB_GLPROG_EXTENSIONS

	#else
	static void stb_glprog_init(void)
	{
	}
	#endif


	// define generic names for many of the gl functions or extensions for later use;
	// note that in some cases there are two functions in core and one function in ARB
	#ifdef STB_GLPROG_ARB
	#define stbglCreateShader glCreateShaderObjectARB
	#define stbglDeleteShader glDeleteObjectARB
	#define stbglAttachShader glAttachObjectARB
	#define stbglDetachShader glDetachObjectARB
	#define stbglShaderSource glShaderSourceARB
	#define stbglCompileShader glCompileShaderARB
	#define stbglGetShaderStatus(a,b) glGetObjectParameterivARB(a, GL_OBJECT_COMPILE_STATUS_ARB, b)
	#define stbglGetShaderInfoLog glGetInfoLogARB
	#define stbglCreateProgram glCreateProgramObjectARB
	#define stbglDeleteProgram glDeleteObjectARB
	#define stbglLinkProgram glLinkProgramARB
	#define stbglGetProgramStatus(a,b) glGetObjectParameterivARB(a, GL_OBJECT_LINK_STATUS_ARB, b)
	#define stbglGetProgramInfoLog glGetInfoLogARB
	#define stbglGetAttachedShaders glGetAttachedObjectsARB
	#define stbglBindAttribLocation glBindAttribLocationARB
	#define stbglGetUniformLocation glGetUniformLocationARB
	#define stbgl_UseProgram glUseProgramObjectARB
	#else
	#define stbglCreateShader glCreateShader
	#define stbglDeleteShader glDeleteShader
	#define stbglAttachShader glAttachShader
	#define stbglDetachShader glDetachShader
	#define stbglShaderSource glShaderSource
	#define stbglCompileShader glCompileShader
	#define stbglGetShaderStatus(a,b) glGetShaderiv(a, GL_COMPILE_STATUS, b)
	#define stbglGetShaderInfoLog glGetShaderInfoLog
	#define stbglCreateProgram glCreateProgram
	#define stbglDeleteProgram glDeleteProgram
	#define stbglLinkProgram glLinkProgram
	#define stbglGetProgramStatus(a,b) glGetProgramiv(a, GL_LINK_STATUS, b)
	#define stbglGetProgramInfoLog glGetProgramInfoLog
	#define stbglGetAttachedShaders glGetAttachedShaders
	#define stbglBindAttribLocation glBindAttribLocation
	#define stbglGetUniformLocation glGetUniformLocation
	#define stbgl_UseProgram glUseProgram
	#endif


	// perform a safe strcat of 3 strings, given that we can't rely on portable snprintf
	// if you need to break on error, this is the best place to place a breakpoint
	static void stb_glprog_error(char error, int error_buflen, char str1, char str2, char str3)
	{
	int n = strlen(str1);
	strncpy(error, str1, error_buflen);
	if (n < error_buflen && str2) {
	strncpy(error+n, str2, error_buflen - n);
	n += strlen(str2);
	if (n < error_buflen && str3) {
	strncpy(error+n, str3, error_buflen - n);
	}
	}
	error[error_buflen-1] = 0;
	}

	STB_GLPROG_DECLARE GLuint stbgl_compile_shader(GLenum type, char const *sources, int num_sources, char error, int error_buflen)
	{
	char *typename = (type == STBGL_VERTEX_SHADER ? "vertex" : "fragment");
	int len;
	GLint result;
	GLuint shader;

	// initialize the extensions if we haven't already
	stb_glprog_init();

	// allocate

	shader = stbglCreateShader(type);
	if (!shader) {
	stb_glprog_error(error, error_buflen, "Couldn't allocate shader object in stbgl_compile_shader for ", typename, NULL);
	return 0;
	}

	// compile

	// if num_sources is negative, assume source is NULL-terminated and count the non-NULL ones
	if (num_sources < 0)
	for (num_sources = 0; sources[num_sources] != NULL; ++num_sources)
	;
	stbglShaderSource(shader, num_sources, sources, NULL);
	stbglCompileShader(shader);
	stbglGetShaderStatus(shader, &result);
	if (result)
	return shader;

	// errors

	stb_glprog_error(error, error_buflen, "Compile error for ", typename, " shader: ");
	len = strlen(error);
	if (len < error_buflen)
	stbglGetShaderInfoLog(shader, error_buflen-len, NULL, error+len);

	stbglDeleteShader(shader);
	return 0;
	}

	STB_GLPROG_DECLARE GLuint stbgl_link_program(GLuint vertex_shader, GLuint fragment_shader, char const *binds, int num_binds, char error, int error_buflen)
	{
	int len;
	GLint result;

	// allocate

	GLuint prog = stbglCreateProgram();
	if (!prog) {
	stb_glprog_error(error, error_buflen, "Couldn't allocate program object in stbgl_link_program", NULL, NULL);
	return 0;
	}

	// attach

	if (vertex_shader)
	stbglAttachShader(prog, vertex_shader);
	if (fragment_shader)
	stbglAttachShader(prog, fragment_shader);

	// attribute binds

	if (binds) {
	int i;
	// if num_binds is negative, then it is NULL terminated
	if (num_binds < 0)
	for (num_binds=0; binds[num_binds]; ++num_binds)
	;
	for (i=0; i < num_binds; ++i)
	if (binds[i] && binds[i][0]) // empty binds can be NULL or ""
	stbglBindAttribLocation(prog, i, binds[i]);
	}

	// link

	stbglLinkProgram(prog);

	// detach

	if (vertex_shader)
	stbglDetachShader(prog, vertex_shader);
	if (fragment_shader)
	stbglDetachShader(prog, fragment_shader);

	// errors

	stbglGetProgramStatus(prog, &result);
	if (result)
	return prog;

	stb_glprog_error(error, error_buflen, "Link error: ", NULL, NULL);
	len = strlen(error);
	if (len < error_buflen)
	stbglGetProgramInfoLog(prog, error_buflen-len, NULL, error+len);

	stbglDeleteProgram(prog);
	return 0;
	}

	STB_GLPROG_DECLARE GLuint stbgl_create_program(char const vertex_source, char const frag_source, char const *binds, char error, int error_buflen)
	{
	GLuint vertex, fragment, prog=0;
	vertex = stbgl_compile_shader(STBGL_VERTEX_SHADER, vertex_source, -1, error, error_buflen);
	if (vertex) {
	fragment = stbgl_compile_shader(STBGL_FRAGMENT_SHADER, frag_source, -1, error, error_buflen);
	if (fragment)
	prog = stbgl_link_program(vertex, fragment, binds, -1, error, error_buflen);
	if (fragment)
	stbglDeleteShader(fragment);
	stbglDeleteShader(vertex);
	}
	return prog;
	}

	STB_GLPROG_DECLARE void stbgl_delete_shader(GLuint shader)
	{
	stbglDeleteShader(shader);
	}

	STB_GLPROG_DECLARE void stgbl_delete_program(GLuint program)
	{
	stbglDeleteProgram(program);
	}

	GLint stbgl_find_uniform(GLuint prog, char *uniform)
	{
	return stbglGetUniformLocation(prog, uniform);
	}

	STB_GLPROG_DECLARE void stbgl_find_uniforms(GLuint prog, GLint locations, char const *uniforms, int num_uniforms)
	{
	int i;
	if (num_uniforms < 0)
	num_uniforms = 999999;
	for (i=0; i < num_uniforms && uniforms[i]; ++i)
	locations[i] = stbglGetUniformLocation(prog, uniforms[i]);
	}

	STB_GLPROG_DECLARE void stbglUseProgram(GLuint program)
	{
	stbgl_UseProgram(program);
	}

	#ifdef STB_GLPROG_ARB
	#define STBGL_ARBIFY(name) name##ARB
	#else
	#define STBGL_ARBIFY(name) name
	#endif

	STB_GLPROG_DECLARE void stbglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)
	{
	STBGL_ARBIFY(glVertexAttribPointer)(index, size, type, normalized, stride, pointer);
	}

	STB_GLPROG_DECLARE void stbglEnableVertexAttribArray (GLuint index) { STBGL_ARBIFY(glEnableVertexAttribArray )(index); }
	STB_GLPROG_DECLARE void stbglDisableVertexAttribArray(GLuint index) { STBGL_ARBIFY(glDisableVertexAttribArray)(index); }

	STB_GLPROG_DECLARE void stbglUniform1fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform1fv)(loc,count,v); }
	STB_GLPROG_DECLARE void stbglUniform2fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform2fv)(loc,count,v); }
	STB_GLPROG_DECLARE void stbglUniform3fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform3fv)(loc,count,v); }
	STB_GLPROG_DECLARE void stbglUniform4fv(GLint loc, GLsizei count, const GLfloat *v) { STBGL_ARBIFY(glUniform4fv)(loc,count,v); }

	STB_GLPROG_DECLARE void stbglUniform1iv(GLint loc, GLsizei count, const GLint *v) { STBGL_ARBIFY(glUniform1iv)(loc,count,v); }
	STB_GLPROG_DECLARE void stbglUniform2iv(GLint loc, GLsizei count, const GLint *v) { STBGL_ARBIFY(glUniform2iv)(loc,count,v); }
	STB_GLPROG_DECLARE void stbglUniform3iv(GLint loc, GLsizei count, const GLint *v) { STBGL_ARBIFY(glUniform3iv)(loc,count,v); }
	STB_GLPROG_DECLARE void stbglUniform4iv(GLint loc, GLsizei count, const GLint *v) { STBGL_ARBIFY(glUniform4iv)(loc,count,v); }

	STB_GLPROG_DECLARE void stbglUniform1f(GLint loc, float v0)
	{ STBGL_ARBIFY(glUniform1f)(loc,v0); }
	STB_GLPROG_DECLARE void stbglUniform2f(GLint loc, float v0, float v1)
	{ STBGL_ARBIFY(glUniform2f)(loc,v0,v1); }
	STB_GLPROG_DECLARE void stbglUniform3f(GLint loc, float v0, float v1, float v2)
	{ STBGL_ARBIFY(glUniform3f)(loc,v0,v1,v2); }
	STB_GLPROG_DECLARE void stbglUniform4f(GLint loc, float v0, float v1, float v2, float v3)
	{ STBGL_ARBIFY(glUniform4f)(loc,v0,v1,v2,v3); }

	STB_GLPROG_DECLARE void stbglUniform1i(GLint loc, GLint v0)
	{ STBGL_ARBIFY(glUniform1i)(loc,v0); }
	STB_GLPROG_DECLARE void stbglUniform2i(GLint loc, GLint v0, GLint v1)
	{ STBGL_ARBIFY(glUniform2i)(loc,v0,v1); }
	STB_GLPROG_DECLARE void stbglUniform3i(GLint loc, GLint v0, GLint v1, GLint v2)
	{ STBGL_ARBIFY(glUniform3i)(loc,v0,v1,v2); }
	STB_GLPROG_DECLARE void stbglUniform4i(GLint loc, GLint v0, GLint v1, GLint v2, GLint v3)
	{ STBGL_ARBIFY(glUniform4i)(loc,v0,v1,v2,v3); }

	#endif