mirror of https://github.com/nothings/stb.git
505 lines
20 KiB
C
505 lines
20 KiB
C
// 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
|