// 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 // #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 // 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