// This file was generated automatically by "glapi2go" and contains functions to // open the platform's OpenGL dll/shared library and to load all OpenGL function // pointers for an specified OpenGL version described by the header file "glcorearb.h", // from "https://www.khronos.org/registry/OpenGL/api/GL/glcorearb.h". // // As Go cgo cannot call directly to C pointers it also creates C function wrappers // for all loaded OpenGL pointers. // The code was heavily based on "https://github.com/skaslev/gl3w" #include #include #include "glapi.h" // // OpenGL function loader for Windows // #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN 1 #include #undef near #undef far static HMODULE libgl; // open_libgl opens the OpenGL dll for Windows static int open_libgl(void) { libgl = LoadLibraryA("opengl32.dll"); if (libgl == NULL) { return -1; } return 0; } // close_libgl closes the OpenGL dll object for Windows static void close_libgl(void) { FreeLibrary(libgl); } // get_proc gets the pointer for an OpenGL function for Windows static void* get_proc(const char *proc) { void* res; res = (void*)wglGetProcAddress(proc); if (!res) { res = (void*)GetProcAddress(libgl, proc); } return res; } // // OpenGL function loader for Mac OS // #elif defined(__APPLE__) #include static void *libgl; static int open_libgl(void) { libgl = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_GLOBAL); if (!libgl) { return -1; } return 0; } static void close_libgl(void) { dlclose(libgl); } static void* get_proc(const char *proc) { void* res; *(void **)(&res) = dlsym(libgl, proc); return res; } // // OpenGL function loader for Linux, Unix* // #else #include #include static void *libgl; static PFNGLXGETPROCADDRESSPROC glx_get_proc_address; // open_libgl opens the OpenGL shared object for Linux/Freebsd static int open_libgl(void) { libgl = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL); if (libgl == NULL) { return -1; } *(void **)(&glx_get_proc_address) = dlsym(libgl, "glXGetProcAddressARB"); if (glx_get_proc_address == NULL) { return -1; } return 0; } // close_libgl closes the OpenGL shared object for Linux/Freebsd static void close_libgl(void) { dlclose(libgl); } // get_proc gets the pointer for an OpenGL function for Linux/Freebsd static void* get_proc(const char *proc) { void* res; res = glx_get_proc_address((const GLubyte *)proc); if (!res) { *(void **)(&res) = dlsym(libgl, proc); } return res; } #endif // Internal global flag to check error from OpenGL functions static int checkError = 1; // Declaration of internal function for loading OpenGL function pointers static void load_procs(); // // glapiLoad() tries to load functions addresses from the OpenGL library // int glapiLoad(void) { int res = open_libgl(); if (res != 0) { return res; } load_procs(); close_libgl(); return 0; } // // glapiCheckError sets the state of the internal flag which determines // if error checking must be done for OpenGL calls // void glapiCheckError(int check) { checkError = check; } // Internal function to abort process when error static void panic(GLenum err, const char* fname) { const char *msg; switch(err) { case GL_NO_ERROR: msg = "No error"; break; case GL_INVALID_ENUM: msg = "An unacceptable value is specified for an enumerated argument"; break; case GL_INVALID_VALUE: msg = "A numeric argument is out of range"; break; case GL_INVALID_OPERATION: msg = "The specified operation is not allowed in the current state"; break; case GL_INVALID_FRAMEBUFFER_OPERATION: msg = "The framebuffer object is not complete"; break; case GL_OUT_OF_MEMORY: msg = "There is not enough memory left to execute the command"; break; case GL_STACK_UNDERFLOW: msg = "An attempt has been made to perform an operation that would cause an internal stack to underflow"; break; case GL_STACK_OVERFLOW: msg = "An attempt has been made to perform an operation that would cause an internal stack to overflow"; break; default: msg = "Unexpected error"; break; } printf("\nGLAPI Error: %s (%d) calling: %s\n", msg, err, fname); exit(1); } // // Definitions of function pointers variables // static PFNGLCULLFACEPROC pglCullFace; static PFNGLFRONTFACEPROC pglFrontFace; static PFNGLHINTPROC pglHint; static PFNGLLINEWIDTHPROC pglLineWidth; static PFNGLPOINTSIZEPROC pglPointSize; static PFNGLPOLYGONMODEPROC pglPolygonMode; static PFNGLSCISSORPROC pglScissor; static PFNGLTEXPARAMETERFPROC pglTexParameterf; static PFNGLTEXPARAMETERFVPROC pglTexParameterfv; static PFNGLTEXPARAMETERIPROC pglTexParameteri; static PFNGLTEXPARAMETERIVPROC pglTexParameteriv; static PFNGLTEXIMAGE1DPROC pglTexImage1D; static PFNGLTEXIMAGE2DPROC pglTexImage2D; static PFNGLDRAWBUFFERPROC pglDrawBuffer; static PFNGLCLEARPROC pglClear; static PFNGLCLEARCOLORPROC pglClearColor; static PFNGLCLEARSTENCILPROC pglClearStencil; static PFNGLCLEARDEPTHPROC pglClearDepth; static PFNGLSTENCILMASKPROC pglStencilMask; static PFNGLCOLORMASKPROC pglColorMask; static PFNGLDEPTHMASKPROC pglDepthMask; static PFNGLDISABLEPROC pglDisable; static PFNGLENABLEPROC pglEnable; static PFNGLFINISHPROC pglFinish; static PFNGLFLUSHPROC pglFlush; static PFNGLBLENDFUNCPROC pglBlendFunc; static PFNGLLOGICOPPROC pglLogicOp; static PFNGLSTENCILFUNCPROC pglStencilFunc; static PFNGLSTENCILOPPROC pglStencilOp; static PFNGLDEPTHFUNCPROC pglDepthFunc; static PFNGLPIXELSTOREFPROC pglPixelStoref; static PFNGLPIXELSTOREIPROC pglPixelStorei; static PFNGLREADBUFFERPROC pglReadBuffer; static PFNGLREADPIXELSPROC pglReadPixels; static PFNGLGETBOOLEANVPROC pglGetBooleanv; static PFNGLGETDOUBLEVPROC pglGetDoublev; static PFNGLGETERRORPROC pglGetError; static PFNGLGETFLOATVPROC pglGetFloatv; static PFNGLGETINTEGERVPROC pglGetIntegerv; static PFNGLGETSTRINGPROC pglGetString; static PFNGLGETTEXIMAGEPROC pglGetTexImage; static PFNGLGETTEXPARAMETERFVPROC pglGetTexParameterfv; static PFNGLGETTEXPARAMETERIVPROC pglGetTexParameteriv; static PFNGLGETTEXLEVELPARAMETERFVPROC pglGetTexLevelParameterfv; static PFNGLGETTEXLEVELPARAMETERIVPROC pglGetTexLevelParameteriv; static PFNGLISENABLEDPROC pglIsEnabled; static PFNGLDEPTHRANGEPROC pglDepthRange; static PFNGLVIEWPORTPROC pglViewport; static PFNGLDRAWARRAYSPROC pglDrawArrays; static PFNGLDRAWELEMENTSPROC pglDrawElements; static PFNGLGETPOINTERVPROC pglGetPointerv; static PFNGLPOLYGONOFFSETPROC pglPolygonOffset; static PFNGLCOPYTEXIMAGE1DPROC pglCopyTexImage1D; static PFNGLCOPYTEXIMAGE2DPROC pglCopyTexImage2D; static PFNGLCOPYTEXSUBIMAGE1DPROC pglCopyTexSubImage1D; static PFNGLCOPYTEXSUBIMAGE2DPROC pglCopyTexSubImage2D; static PFNGLTEXSUBIMAGE1DPROC pglTexSubImage1D; static PFNGLTEXSUBIMAGE2DPROC pglTexSubImage2D; static PFNGLBINDTEXTUREPROC pglBindTexture; static PFNGLDELETETEXTURESPROC pglDeleteTextures; static PFNGLGENTEXTURESPROC pglGenTextures; static PFNGLISTEXTUREPROC pglIsTexture; static PFNGLDRAWRANGEELEMENTSPROC pglDrawRangeElements; static PFNGLTEXIMAGE3DPROC pglTexImage3D; static PFNGLTEXSUBIMAGE3DPROC pglTexSubImage3D; static PFNGLCOPYTEXSUBIMAGE3DPROC pglCopyTexSubImage3D; static PFNGLACTIVETEXTUREPROC pglActiveTexture; static PFNGLSAMPLECOVERAGEPROC pglSampleCoverage; static PFNGLCOMPRESSEDTEXIMAGE3DPROC pglCompressedTexImage3D; static PFNGLCOMPRESSEDTEXIMAGE2DPROC pglCompressedTexImage2D; static PFNGLCOMPRESSEDTEXIMAGE1DPROC pglCompressedTexImage1D; static PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC pglCompressedTexSubImage3D; static PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC pglCompressedTexSubImage2D; static PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC pglCompressedTexSubImage1D; static PFNGLGETCOMPRESSEDTEXIMAGEPROC pglGetCompressedTexImage; static PFNGLBLENDFUNCSEPARATEPROC pglBlendFuncSeparate; static PFNGLMULTIDRAWARRAYSPROC pglMultiDrawArrays; static PFNGLMULTIDRAWELEMENTSPROC pglMultiDrawElements; static PFNGLPOINTPARAMETERFPROC pglPointParameterf; static PFNGLPOINTPARAMETERFVPROC pglPointParameterfv; static PFNGLPOINTPARAMETERIPROC pglPointParameteri; static PFNGLPOINTPARAMETERIVPROC pglPointParameteriv; static PFNGLBLENDCOLORPROC pglBlendColor; static PFNGLBLENDEQUATIONPROC pglBlendEquation; static PFNGLGENQUERIESPROC pglGenQueries; static PFNGLDELETEQUERIESPROC pglDeleteQueries; static PFNGLISQUERYPROC pglIsQuery; static PFNGLBEGINQUERYPROC pglBeginQuery; static PFNGLENDQUERYPROC pglEndQuery; static PFNGLGETQUERYIVPROC pglGetQueryiv; static PFNGLGETQUERYOBJECTIVPROC pglGetQueryObjectiv; static PFNGLGETQUERYOBJECTUIVPROC pglGetQueryObjectuiv; static PFNGLBINDBUFFERPROC pglBindBuffer; static PFNGLDELETEBUFFERSPROC pglDeleteBuffers; static PFNGLGENBUFFERSPROC pglGenBuffers; static PFNGLISBUFFERPROC pglIsBuffer; static PFNGLBUFFERDATAPROC pglBufferData; static PFNGLBUFFERSUBDATAPROC pglBufferSubData; static PFNGLGETBUFFERSUBDATAPROC pglGetBufferSubData; static PFNGLMAPBUFFERPROC pglMapBuffer; static PFNGLUNMAPBUFFERPROC pglUnmapBuffer; static PFNGLGETBUFFERPARAMETERIVPROC pglGetBufferParameteriv; static PFNGLGETBUFFERPOINTERVPROC pglGetBufferPointerv; static PFNGLBLENDEQUATIONSEPARATEPROC pglBlendEquationSeparate; static PFNGLDRAWBUFFERSPROC pglDrawBuffers; static PFNGLSTENCILOPSEPARATEPROC pglStencilOpSeparate; static PFNGLSTENCILFUNCSEPARATEPROC pglStencilFuncSeparate; static PFNGLSTENCILMASKSEPARATEPROC pglStencilMaskSeparate; static PFNGLATTACHSHADERPROC pglAttachShader; static PFNGLBINDATTRIBLOCATIONPROC pglBindAttribLocation; static PFNGLCOMPILESHADERPROC pglCompileShader; static PFNGLCREATEPROGRAMPROC pglCreateProgram; static PFNGLCREATESHADERPROC pglCreateShader; static PFNGLDELETEPROGRAMPROC pglDeleteProgram; static PFNGLDELETESHADERPROC pglDeleteShader; static PFNGLDETACHSHADERPROC pglDetachShader; static PFNGLDISABLEVERTEXATTRIBARRAYPROC pglDisableVertexAttribArray; static PFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray; static PFNGLGETACTIVEATTRIBPROC pglGetActiveAttrib; static PFNGLGETACTIVEUNIFORMPROC pglGetActiveUniform; static PFNGLGETATTACHEDSHADERSPROC pglGetAttachedShaders; static PFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation; static PFNGLGETPROGRAMIVPROC pglGetProgramiv; static PFNGLGETPROGRAMINFOLOGPROC pglGetProgramInfoLog; static PFNGLGETSHADERIVPROC pglGetShaderiv; static PFNGLGETSHADERINFOLOGPROC pglGetShaderInfoLog; static PFNGLGETSHADERSOURCEPROC pglGetShaderSource; static PFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation; static PFNGLGETUNIFORMFVPROC pglGetUniformfv; static PFNGLGETUNIFORMIVPROC pglGetUniformiv; static PFNGLGETVERTEXATTRIBDVPROC pglGetVertexAttribdv; static PFNGLGETVERTEXATTRIBFVPROC pglGetVertexAttribfv; static PFNGLGETVERTEXATTRIBIVPROC pglGetVertexAttribiv; static PFNGLGETVERTEXATTRIBPOINTERVPROC pglGetVertexAttribPointerv; static PFNGLISPROGRAMPROC pglIsProgram; static PFNGLISSHADERPROC pglIsShader; static PFNGLLINKPROGRAMPROC pglLinkProgram; static PFNGLSHADERSOURCEPROC pglShaderSource; static PFNGLUSEPROGRAMPROC pglUseProgram; static PFNGLUNIFORM1FPROC pglUniform1f; static PFNGLUNIFORM2FPROC pglUniform2f; static PFNGLUNIFORM3FPROC pglUniform3f; static PFNGLUNIFORM4FPROC pglUniform4f; static PFNGLUNIFORM1IPROC pglUniform1i; static PFNGLUNIFORM2IPROC pglUniform2i; static PFNGLUNIFORM3IPROC pglUniform3i; static PFNGLUNIFORM4IPROC pglUniform4i; static PFNGLUNIFORM1FVPROC pglUniform1fv; static PFNGLUNIFORM2FVPROC pglUniform2fv; static PFNGLUNIFORM3FVPROC pglUniform3fv; static PFNGLUNIFORM4FVPROC pglUniform4fv; static PFNGLUNIFORM1IVPROC pglUniform1iv; static PFNGLUNIFORM2IVPROC pglUniform2iv; static PFNGLUNIFORM3IVPROC pglUniform3iv; static PFNGLUNIFORM4IVPROC pglUniform4iv; static PFNGLUNIFORMMATRIX2FVPROC pglUniformMatrix2fv; static PFNGLUNIFORMMATRIX3FVPROC pglUniformMatrix3fv; static PFNGLUNIFORMMATRIX4FVPROC pglUniformMatrix4fv; static PFNGLVALIDATEPROGRAMPROC pglValidateProgram; static PFNGLVERTEXATTRIB1DPROC pglVertexAttrib1d; static PFNGLVERTEXATTRIB1DVPROC pglVertexAttrib1dv; static PFNGLVERTEXATTRIB1FPROC pglVertexAttrib1f; static PFNGLVERTEXATTRIB1FVPROC pglVertexAttrib1fv; static PFNGLVERTEXATTRIB1SPROC pglVertexAttrib1s; static PFNGLVERTEXATTRIB1SVPROC pglVertexAttrib1sv; static PFNGLVERTEXATTRIB2DPROC pglVertexAttrib2d; static PFNGLVERTEXATTRIB2DVPROC pglVertexAttrib2dv; static PFNGLVERTEXATTRIB2FPROC pglVertexAttrib2f; static PFNGLVERTEXATTRIB2FVPROC pglVertexAttrib2fv; static PFNGLVERTEXATTRIB2SPROC pglVertexAttrib2s; static PFNGLVERTEXATTRIB2SVPROC pglVertexAttrib2sv; static PFNGLVERTEXATTRIB3DPROC pglVertexAttrib3d; static PFNGLVERTEXATTRIB3DVPROC pglVertexAttrib3dv; static PFNGLVERTEXATTRIB3FPROC pglVertexAttrib3f; static PFNGLVERTEXATTRIB3FVPROC pglVertexAttrib3fv; static PFNGLVERTEXATTRIB3SPROC pglVertexAttrib3s; static PFNGLVERTEXATTRIB3SVPROC pglVertexAttrib3sv; static PFNGLVERTEXATTRIB4NBVPROC pglVertexAttrib4Nbv; static PFNGLVERTEXATTRIB4NIVPROC pglVertexAttrib4Niv; static PFNGLVERTEXATTRIB4NSVPROC pglVertexAttrib4Nsv; static PFNGLVERTEXATTRIB4NUBPROC pglVertexAttrib4Nub; static PFNGLVERTEXATTRIB4NUBVPROC pglVertexAttrib4Nubv; static PFNGLVERTEXATTRIB4NUIVPROC pglVertexAttrib4Nuiv; static PFNGLVERTEXATTRIB4NUSVPROC pglVertexAttrib4Nusv; static PFNGLVERTEXATTRIB4BVPROC pglVertexAttrib4bv; static PFNGLVERTEXATTRIB4DPROC pglVertexAttrib4d; static PFNGLVERTEXATTRIB4DVPROC pglVertexAttrib4dv; static PFNGLVERTEXATTRIB4FPROC pglVertexAttrib4f; static PFNGLVERTEXATTRIB4FVPROC pglVertexAttrib4fv; static PFNGLVERTEXATTRIB4IVPROC pglVertexAttrib4iv; static PFNGLVERTEXATTRIB4SPROC pglVertexAttrib4s; static PFNGLVERTEXATTRIB4SVPROC pglVertexAttrib4sv; static PFNGLVERTEXATTRIB4UBVPROC pglVertexAttrib4ubv; static PFNGLVERTEXATTRIB4UIVPROC pglVertexAttrib4uiv; static PFNGLVERTEXATTRIB4USVPROC pglVertexAttrib4usv; static PFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer; static PFNGLUNIFORMMATRIX2X3FVPROC pglUniformMatrix2x3fv; static PFNGLUNIFORMMATRIX3X2FVPROC pglUniformMatrix3x2fv; static PFNGLUNIFORMMATRIX2X4FVPROC pglUniformMatrix2x4fv; static PFNGLUNIFORMMATRIX4X2FVPROC pglUniformMatrix4x2fv; static PFNGLUNIFORMMATRIX3X4FVPROC pglUniformMatrix3x4fv; static PFNGLUNIFORMMATRIX4X3FVPROC pglUniformMatrix4x3fv; static PFNGLCOLORMASKIPROC pglColorMaski; static PFNGLGETBOOLEANI_VPROC pglGetBooleani_v; static PFNGLGETINTEGERI_VPROC pglGetIntegeri_v; static PFNGLENABLEIPROC pglEnablei; static PFNGLDISABLEIPROC pglDisablei; static PFNGLISENABLEDIPROC pglIsEnabledi; static PFNGLBEGINTRANSFORMFEEDBACKPROC pglBeginTransformFeedback; static PFNGLENDTRANSFORMFEEDBACKPROC pglEndTransformFeedback; static PFNGLBINDBUFFERRANGEPROC pglBindBufferRange; static PFNGLBINDBUFFERBASEPROC pglBindBufferBase; static PFNGLTRANSFORMFEEDBACKVARYINGSPROC pglTransformFeedbackVaryings; static PFNGLGETTRANSFORMFEEDBACKVARYINGPROC pglGetTransformFeedbackVarying; static PFNGLCLAMPCOLORPROC pglClampColor; static PFNGLBEGINCONDITIONALRENDERPROC pglBeginConditionalRender; static PFNGLENDCONDITIONALRENDERPROC pglEndConditionalRender; static PFNGLVERTEXATTRIBIPOINTERPROC pglVertexAttribIPointer; static PFNGLGETVERTEXATTRIBIIVPROC pglGetVertexAttribIiv; static PFNGLGETVERTEXATTRIBIUIVPROC pglGetVertexAttribIuiv; static PFNGLVERTEXATTRIBI1IPROC pglVertexAttribI1i; static PFNGLVERTEXATTRIBI2IPROC pglVertexAttribI2i; static PFNGLVERTEXATTRIBI3IPROC pglVertexAttribI3i; static PFNGLVERTEXATTRIBI4IPROC pglVertexAttribI4i; static PFNGLVERTEXATTRIBI1UIPROC pglVertexAttribI1ui; static PFNGLVERTEXATTRIBI2UIPROC pglVertexAttribI2ui; static PFNGLVERTEXATTRIBI3UIPROC pglVertexAttribI3ui; static PFNGLVERTEXATTRIBI4UIPROC pglVertexAttribI4ui; static PFNGLVERTEXATTRIBI1IVPROC pglVertexAttribI1iv; static PFNGLVERTEXATTRIBI2IVPROC pglVertexAttribI2iv; static PFNGLVERTEXATTRIBI3IVPROC pglVertexAttribI3iv; static PFNGLVERTEXATTRIBI4IVPROC pglVertexAttribI4iv; static PFNGLVERTEXATTRIBI1UIVPROC pglVertexAttribI1uiv; static PFNGLVERTEXATTRIBI2UIVPROC pglVertexAttribI2uiv; static PFNGLVERTEXATTRIBI3UIVPROC pglVertexAttribI3uiv; static PFNGLVERTEXATTRIBI4UIVPROC pglVertexAttribI4uiv; static PFNGLVERTEXATTRIBI4BVPROC pglVertexAttribI4bv; static PFNGLVERTEXATTRIBI4SVPROC pglVertexAttribI4sv; static PFNGLVERTEXATTRIBI4UBVPROC pglVertexAttribI4ubv; static PFNGLVERTEXATTRIBI4USVPROC pglVertexAttribI4usv; static PFNGLGETUNIFORMUIVPROC pglGetUniformuiv; static PFNGLBINDFRAGDATALOCATIONPROC pglBindFragDataLocation; static PFNGLGETFRAGDATALOCATIONPROC pglGetFragDataLocation; static PFNGLUNIFORM1UIPROC pglUniform1ui; static PFNGLUNIFORM2UIPROC pglUniform2ui; static PFNGLUNIFORM3UIPROC pglUniform3ui; static PFNGLUNIFORM4UIPROC pglUniform4ui; static PFNGLUNIFORM1UIVPROC pglUniform1uiv; static PFNGLUNIFORM2UIVPROC pglUniform2uiv; static PFNGLUNIFORM3UIVPROC pglUniform3uiv; static PFNGLUNIFORM4UIVPROC pglUniform4uiv; static PFNGLTEXPARAMETERIIVPROC pglTexParameterIiv; static PFNGLTEXPARAMETERIUIVPROC pglTexParameterIuiv; static PFNGLGETTEXPARAMETERIIVPROC pglGetTexParameterIiv; static PFNGLGETTEXPARAMETERIUIVPROC pglGetTexParameterIuiv; static PFNGLCLEARBUFFERIVPROC pglClearBufferiv; static PFNGLCLEARBUFFERUIVPROC pglClearBufferuiv; static PFNGLCLEARBUFFERFVPROC pglClearBufferfv; static PFNGLCLEARBUFFERFIPROC pglClearBufferfi; static PFNGLGETSTRINGIPROC pglGetStringi; static PFNGLISRENDERBUFFERPROC pglIsRenderbuffer; static PFNGLBINDRENDERBUFFERPROC pglBindRenderbuffer; static PFNGLDELETERENDERBUFFERSPROC pglDeleteRenderbuffers; static PFNGLGENRENDERBUFFERSPROC pglGenRenderbuffers; static PFNGLRENDERBUFFERSTORAGEPROC pglRenderbufferStorage; static PFNGLGETRENDERBUFFERPARAMETERIVPROC pglGetRenderbufferParameteriv; static PFNGLISFRAMEBUFFERPROC pglIsFramebuffer; static PFNGLBINDFRAMEBUFFERPROC pglBindFramebuffer; static PFNGLDELETEFRAMEBUFFERSPROC pglDeleteFramebuffers; static PFNGLGENFRAMEBUFFERSPROC pglGenFramebuffers; static PFNGLCHECKFRAMEBUFFERSTATUSPROC pglCheckFramebufferStatus; static PFNGLFRAMEBUFFERTEXTURE1DPROC pglFramebufferTexture1D; static PFNGLFRAMEBUFFERTEXTURE2DPROC pglFramebufferTexture2D; static PFNGLFRAMEBUFFERTEXTURE3DPROC pglFramebufferTexture3D; static PFNGLFRAMEBUFFERRENDERBUFFERPROC pglFramebufferRenderbuffer; static PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC pglGetFramebufferAttachmentParameteriv; static PFNGLGENERATEMIPMAPPROC pglGenerateMipmap; static PFNGLBLITFRAMEBUFFERPROC pglBlitFramebuffer; static PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC pglRenderbufferStorageMultisample; static PFNGLFRAMEBUFFERTEXTURELAYERPROC pglFramebufferTextureLayer; static PFNGLMAPBUFFERRANGEPROC pglMapBufferRange; static PFNGLFLUSHMAPPEDBUFFERRANGEPROC pglFlushMappedBufferRange; static PFNGLBINDVERTEXARRAYPROC pglBindVertexArray; static PFNGLDELETEVERTEXARRAYSPROC pglDeleteVertexArrays; static PFNGLGENVERTEXARRAYSPROC pglGenVertexArrays; static PFNGLISVERTEXARRAYPROC pglIsVertexArray; static PFNGLDRAWARRAYSINSTANCEDPROC pglDrawArraysInstanced; static PFNGLDRAWELEMENTSINSTANCEDPROC pglDrawElementsInstanced; static PFNGLTEXBUFFERPROC pglTexBuffer; static PFNGLPRIMITIVERESTARTINDEXPROC pglPrimitiveRestartIndex; static PFNGLCOPYBUFFERSUBDATAPROC pglCopyBufferSubData; static PFNGLGETUNIFORMINDICESPROC pglGetUniformIndices; static PFNGLGETACTIVEUNIFORMSIVPROC pglGetActiveUniformsiv; static PFNGLGETACTIVEUNIFORMNAMEPROC pglGetActiveUniformName; static PFNGLGETUNIFORMBLOCKINDEXPROC pglGetUniformBlockIndex; static PFNGLGETACTIVEUNIFORMBLOCKIVPROC pglGetActiveUniformBlockiv; static PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC pglGetActiveUniformBlockName; static PFNGLUNIFORMBLOCKBINDINGPROC pglUniformBlockBinding; static PFNGLDRAWELEMENTSBASEVERTEXPROC pglDrawElementsBaseVertex; static PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC pglDrawRangeElementsBaseVertex; static PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC pglDrawElementsInstancedBaseVertex; static PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC pglMultiDrawElementsBaseVertex; static PFNGLPROVOKINGVERTEXPROC pglProvokingVertex; static PFNGLFENCESYNCPROC pglFenceSync; static PFNGLISSYNCPROC pglIsSync; static PFNGLDELETESYNCPROC pglDeleteSync; static PFNGLCLIENTWAITSYNCPROC pglClientWaitSync; static PFNGLWAITSYNCPROC pglWaitSync; static PFNGLGETINTEGER64VPROC pglGetInteger64v; static PFNGLGETSYNCIVPROC pglGetSynciv; static PFNGLGETINTEGER64I_VPROC pglGetInteger64i_v; static PFNGLGETBUFFERPARAMETERI64VPROC pglGetBufferParameteri64v; static PFNGLFRAMEBUFFERTEXTUREPROC pglFramebufferTexture; static PFNGLTEXIMAGE2DMULTISAMPLEPROC pglTexImage2DMultisample; static PFNGLTEXIMAGE3DMULTISAMPLEPROC pglTexImage3DMultisample; static PFNGLGETMULTISAMPLEFVPROC pglGetMultisamplefv; static PFNGLSAMPLEMASKIPROC pglSampleMaski; static PFNGLBINDFRAGDATALOCATIONINDEXEDPROC pglBindFragDataLocationIndexed; static PFNGLGETFRAGDATAINDEXPROC pglGetFragDataIndex; static PFNGLGENSAMPLERSPROC pglGenSamplers; static PFNGLDELETESAMPLERSPROC pglDeleteSamplers; static PFNGLISSAMPLERPROC pglIsSampler; static PFNGLBINDSAMPLERPROC pglBindSampler; static PFNGLSAMPLERPARAMETERIPROC pglSamplerParameteri; static PFNGLSAMPLERPARAMETERIVPROC pglSamplerParameteriv; static PFNGLSAMPLERPARAMETERFPROC pglSamplerParameterf; static PFNGLSAMPLERPARAMETERFVPROC pglSamplerParameterfv; static PFNGLSAMPLERPARAMETERIIVPROC pglSamplerParameterIiv; static PFNGLSAMPLERPARAMETERIUIVPROC pglSamplerParameterIuiv; static PFNGLGETSAMPLERPARAMETERIVPROC pglGetSamplerParameteriv; static PFNGLGETSAMPLERPARAMETERIIVPROC pglGetSamplerParameterIiv; static PFNGLGETSAMPLERPARAMETERFVPROC pglGetSamplerParameterfv; static PFNGLGETSAMPLERPARAMETERIUIVPROC pglGetSamplerParameterIuiv; static PFNGLQUERYCOUNTERPROC pglQueryCounter; static PFNGLGETQUERYOBJECTI64VPROC pglGetQueryObjecti64v; static PFNGLGETQUERYOBJECTUI64VPROC pglGetQueryObjectui64v; static PFNGLVERTEXATTRIBDIVISORPROC pglVertexAttribDivisor; static PFNGLVERTEXATTRIBP1UIPROC pglVertexAttribP1ui; static PFNGLVERTEXATTRIBP1UIVPROC pglVertexAttribP1uiv; static PFNGLVERTEXATTRIBP2UIPROC pglVertexAttribP2ui; static PFNGLVERTEXATTRIBP2UIVPROC pglVertexAttribP2uiv; static PFNGLVERTEXATTRIBP3UIPROC pglVertexAttribP3ui; static PFNGLVERTEXATTRIBP3UIVPROC pglVertexAttribP3uiv; static PFNGLVERTEXATTRIBP4UIPROC pglVertexAttribP4ui; static PFNGLVERTEXATTRIBP4UIVPROC pglVertexAttribP4uiv; // // load_procs loads all gl functions addresses into the pointers // static void load_procs() { pglCullFace = (PFNGLCULLFACEPROC)get_proc("glCullFace"); pglFrontFace = (PFNGLFRONTFACEPROC)get_proc("glFrontFace"); pglHint = (PFNGLHINTPROC)get_proc("glHint"); pglLineWidth = (PFNGLLINEWIDTHPROC)get_proc("glLineWidth"); pglPointSize = (PFNGLPOINTSIZEPROC)get_proc("glPointSize"); pglPolygonMode = (PFNGLPOLYGONMODEPROC)get_proc("glPolygonMode"); pglScissor = (PFNGLSCISSORPROC)get_proc("glScissor"); pglTexParameterf = (PFNGLTEXPARAMETERFPROC)get_proc("glTexParameterf"); pglTexParameterfv = (PFNGLTEXPARAMETERFVPROC)get_proc("glTexParameterfv"); pglTexParameteri = (PFNGLTEXPARAMETERIPROC)get_proc("glTexParameteri"); pglTexParameteriv = (PFNGLTEXPARAMETERIVPROC)get_proc("glTexParameteriv"); pglTexImage1D = (PFNGLTEXIMAGE1DPROC)get_proc("glTexImage1D"); pglTexImage2D = (PFNGLTEXIMAGE2DPROC)get_proc("glTexImage2D"); pglDrawBuffer = (PFNGLDRAWBUFFERPROC)get_proc("glDrawBuffer"); pglClear = (PFNGLCLEARPROC)get_proc("glClear"); pglClearColor = (PFNGLCLEARCOLORPROC)get_proc("glClearColor"); pglClearStencil = (PFNGLCLEARSTENCILPROC)get_proc("glClearStencil"); pglClearDepth = (PFNGLCLEARDEPTHPROC)get_proc("glClearDepth"); pglStencilMask = (PFNGLSTENCILMASKPROC)get_proc("glStencilMask"); pglColorMask = (PFNGLCOLORMASKPROC)get_proc("glColorMask"); pglDepthMask = (PFNGLDEPTHMASKPROC)get_proc("glDepthMask"); pglDisable = (PFNGLDISABLEPROC)get_proc("glDisable"); pglEnable = (PFNGLENABLEPROC)get_proc("glEnable"); pglFinish = (PFNGLFINISHPROC)get_proc("glFinish"); pglFlush = (PFNGLFLUSHPROC)get_proc("glFlush"); pglBlendFunc = (PFNGLBLENDFUNCPROC)get_proc("glBlendFunc"); pglLogicOp = (PFNGLLOGICOPPROC)get_proc("glLogicOp"); pglStencilFunc = (PFNGLSTENCILFUNCPROC)get_proc("glStencilFunc"); pglStencilOp = (PFNGLSTENCILOPPROC)get_proc("glStencilOp"); pglDepthFunc = (PFNGLDEPTHFUNCPROC)get_proc("glDepthFunc"); pglPixelStoref = (PFNGLPIXELSTOREFPROC)get_proc("glPixelStoref"); pglPixelStorei = (PFNGLPIXELSTOREIPROC)get_proc("glPixelStorei"); pglReadBuffer = (PFNGLREADBUFFERPROC)get_proc("glReadBuffer"); pglReadPixels = (PFNGLREADPIXELSPROC)get_proc("glReadPixels"); pglGetBooleanv = (PFNGLGETBOOLEANVPROC)get_proc("glGetBooleanv"); pglGetDoublev = (PFNGLGETDOUBLEVPROC)get_proc("glGetDoublev"); pglGetError = (PFNGLGETERRORPROC)get_proc("glGetError"); pglGetFloatv = (PFNGLGETFLOATVPROC)get_proc("glGetFloatv"); pglGetIntegerv = (PFNGLGETINTEGERVPROC)get_proc("glGetIntegerv"); pglGetString = (PFNGLGETSTRINGPROC)get_proc("glGetString"); pglGetTexImage = (PFNGLGETTEXIMAGEPROC)get_proc("glGetTexImage"); pglGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)get_proc("glGetTexParameterfv"); pglGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)get_proc("glGetTexParameteriv"); pglGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)get_proc("glGetTexLevelParameterfv"); pglGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)get_proc("glGetTexLevelParameteriv"); pglIsEnabled = (PFNGLISENABLEDPROC)get_proc("glIsEnabled"); pglDepthRange = (PFNGLDEPTHRANGEPROC)get_proc("glDepthRange"); pglViewport = (PFNGLVIEWPORTPROC)get_proc("glViewport"); pglDrawArrays = (PFNGLDRAWARRAYSPROC)get_proc("glDrawArrays"); pglDrawElements = (PFNGLDRAWELEMENTSPROC)get_proc("glDrawElements"); pglGetPointerv = (PFNGLGETPOINTERVPROC)get_proc("glGetPointerv"); pglPolygonOffset = (PFNGLPOLYGONOFFSETPROC)get_proc("glPolygonOffset"); pglCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)get_proc("glCopyTexImage1D"); pglCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)get_proc("glCopyTexImage2D"); pglCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)get_proc("glCopyTexSubImage1D"); pglCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)get_proc("glCopyTexSubImage2D"); pglTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)get_proc("glTexSubImage1D"); pglTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)get_proc("glTexSubImage2D"); pglBindTexture = (PFNGLBINDTEXTUREPROC)get_proc("glBindTexture"); pglDeleteTextures = (PFNGLDELETETEXTURESPROC)get_proc("glDeleteTextures"); pglGenTextures = (PFNGLGENTEXTURESPROC)get_proc("glGenTextures"); pglIsTexture = (PFNGLISTEXTUREPROC)get_proc("glIsTexture"); pglDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)get_proc("glDrawRangeElements"); pglTexImage3D = (PFNGLTEXIMAGE3DPROC)get_proc("glTexImage3D"); pglTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)get_proc("glTexSubImage3D"); pglCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)get_proc("glCopyTexSubImage3D"); pglActiveTexture = (PFNGLACTIVETEXTUREPROC)get_proc("glActiveTexture"); pglSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)get_proc("glSampleCoverage"); pglCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)get_proc("glCompressedTexImage3D"); pglCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)get_proc("glCompressedTexImage2D"); pglCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)get_proc("glCompressedTexImage1D"); pglCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)get_proc("glCompressedTexSubImage3D"); pglCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)get_proc("glCompressedTexSubImage2D"); pglCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)get_proc("glCompressedTexSubImage1D"); pglGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)get_proc("glGetCompressedTexImage"); pglBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)get_proc("glBlendFuncSeparate"); pglMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)get_proc("glMultiDrawArrays"); pglMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)get_proc("glMultiDrawElements"); pglPointParameterf = (PFNGLPOINTPARAMETERFPROC)get_proc("glPointParameterf"); pglPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)get_proc("glPointParameterfv"); pglPointParameteri = (PFNGLPOINTPARAMETERIPROC)get_proc("glPointParameteri"); pglPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)get_proc("glPointParameteriv"); pglBlendColor = (PFNGLBLENDCOLORPROC)get_proc("glBlendColor"); pglBlendEquation = (PFNGLBLENDEQUATIONPROC)get_proc("glBlendEquation"); pglGenQueries = (PFNGLGENQUERIESPROC)get_proc("glGenQueries"); pglDeleteQueries = (PFNGLDELETEQUERIESPROC)get_proc("glDeleteQueries"); pglIsQuery = (PFNGLISQUERYPROC)get_proc("glIsQuery"); pglBeginQuery = (PFNGLBEGINQUERYPROC)get_proc("glBeginQuery"); pglEndQuery = (PFNGLENDQUERYPROC)get_proc("glEndQuery"); pglGetQueryiv = (PFNGLGETQUERYIVPROC)get_proc("glGetQueryiv"); pglGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)get_proc("glGetQueryObjectiv"); pglGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)get_proc("glGetQueryObjectuiv"); pglBindBuffer = (PFNGLBINDBUFFERPROC)get_proc("glBindBuffer"); pglDeleteBuffers = (PFNGLDELETEBUFFERSPROC)get_proc("glDeleteBuffers"); pglGenBuffers = (PFNGLGENBUFFERSPROC)get_proc("glGenBuffers"); pglIsBuffer = (PFNGLISBUFFERPROC)get_proc("glIsBuffer"); pglBufferData = (PFNGLBUFFERDATAPROC)get_proc("glBufferData"); pglBufferSubData = (PFNGLBUFFERSUBDATAPROC)get_proc("glBufferSubData"); pglGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)get_proc("glGetBufferSubData"); pglMapBuffer = (PFNGLMAPBUFFERPROC)get_proc("glMapBuffer"); pglUnmapBuffer = (PFNGLUNMAPBUFFERPROC)get_proc("glUnmapBuffer"); pglGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)get_proc("glGetBufferParameteriv"); pglGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)get_proc("glGetBufferPointerv"); pglBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)get_proc("glBlendEquationSeparate"); pglDrawBuffers = (PFNGLDRAWBUFFERSPROC)get_proc("glDrawBuffers"); pglStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)get_proc("glStencilOpSeparate"); pglStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)get_proc("glStencilFuncSeparate"); pglStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)get_proc("glStencilMaskSeparate"); pglAttachShader = (PFNGLATTACHSHADERPROC)get_proc("glAttachShader"); pglBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)get_proc("glBindAttribLocation"); pglCompileShader = (PFNGLCOMPILESHADERPROC)get_proc("glCompileShader"); pglCreateProgram = (PFNGLCREATEPROGRAMPROC)get_proc("glCreateProgram"); pglCreateShader = (PFNGLCREATESHADERPROC)get_proc("glCreateShader"); pglDeleteProgram = (PFNGLDELETEPROGRAMPROC)get_proc("glDeleteProgram"); pglDeleteShader = (PFNGLDELETESHADERPROC)get_proc("glDeleteShader"); pglDetachShader = (PFNGLDETACHSHADERPROC)get_proc("glDetachShader"); pglDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)get_proc("glDisableVertexAttribArray"); pglEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)get_proc("glEnableVertexAttribArray"); pglGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)get_proc("glGetActiveAttrib"); pglGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)get_proc("glGetActiveUniform"); pglGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)get_proc("glGetAttachedShaders"); pglGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)get_proc("glGetAttribLocation"); pglGetProgramiv = (PFNGLGETPROGRAMIVPROC)get_proc("glGetProgramiv"); pglGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)get_proc("glGetProgramInfoLog"); pglGetShaderiv = (PFNGLGETSHADERIVPROC)get_proc("glGetShaderiv"); pglGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)get_proc("glGetShaderInfoLog"); pglGetShaderSource = (PFNGLGETSHADERSOURCEPROC)get_proc("glGetShaderSource"); pglGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)get_proc("glGetUniformLocation"); pglGetUniformfv = (PFNGLGETUNIFORMFVPROC)get_proc("glGetUniformfv"); pglGetUniformiv = (PFNGLGETUNIFORMIVPROC)get_proc("glGetUniformiv"); pglGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)get_proc("glGetVertexAttribdv"); pglGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)get_proc("glGetVertexAttribfv"); pglGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)get_proc("glGetVertexAttribiv"); pglGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)get_proc("glGetVertexAttribPointerv"); pglIsProgram = (PFNGLISPROGRAMPROC)get_proc("glIsProgram"); pglIsShader = (PFNGLISSHADERPROC)get_proc("glIsShader"); pglLinkProgram = (PFNGLLINKPROGRAMPROC)get_proc("glLinkProgram"); pglShaderSource = (PFNGLSHADERSOURCEPROC)get_proc("glShaderSource"); pglUseProgram = (PFNGLUSEPROGRAMPROC)get_proc("glUseProgram"); pglUniform1f = (PFNGLUNIFORM1FPROC)get_proc("glUniform1f"); pglUniform2f = (PFNGLUNIFORM2FPROC)get_proc("glUniform2f"); pglUniform3f = (PFNGLUNIFORM3FPROC)get_proc("glUniform3f"); pglUniform4f = (PFNGLUNIFORM4FPROC)get_proc("glUniform4f"); pglUniform1i = (PFNGLUNIFORM1IPROC)get_proc("glUniform1i"); pglUniform2i = (PFNGLUNIFORM2IPROC)get_proc("glUniform2i"); pglUniform3i = (PFNGLUNIFORM3IPROC)get_proc("glUniform3i"); pglUniform4i = (PFNGLUNIFORM4IPROC)get_proc("glUniform4i"); pglUniform1fv = (PFNGLUNIFORM1FVPROC)get_proc("glUniform1fv"); pglUniform2fv = (PFNGLUNIFORM2FVPROC)get_proc("glUniform2fv"); pglUniform3fv = (PFNGLUNIFORM3FVPROC)get_proc("glUniform3fv"); pglUniform4fv = (PFNGLUNIFORM4FVPROC)get_proc("glUniform4fv"); pglUniform1iv = (PFNGLUNIFORM1IVPROC)get_proc("glUniform1iv"); pglUniform2iv = (PFNGLUNIFORM2IVPROC)get_proc("glUniform2iv"); pglUniform3iv = (PFNGLUNIFORM3IVPROC)get_proc("glUniform3iv"); pglUniform4iv = (PFNGLUNIFORM4IVPROC)get_proc("glUniform4iv"); pglUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)get_proc("glUniformMatrix2fv"); pglUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)get_proc("glUniformMatrix3fv"); pglUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)get_proc("glUniformMatrix4fv"); pglValidateProgram = (PFNGLVALIDATEPROGRAMPROC)get_proc("glValidateProgram"); pglVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)get_proc("glVertexAttrib1d"); pglVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)get_proc("glVertexAttrib1dv"); pglVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)get_proc("glVertexAttrib1f"); pglVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)get_proc("glVertexAttrib1fv"); pglVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)get_proc("glVertexAttrib1s"); pglVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)get_proc("glVertexAttrib1sv"); pglVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)get_proc("glVertexAttrib2d"); pglVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)get_proc("glVertexAttrib2dv"); pglVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)get_proc("glVertexAttrib2f"); pglVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)get_proc("glVertexAttrib2fv"); pglVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)get_proc("glVertexAttrib2s"); pglVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)get_proc("glVertexAttrib2sv"); pglVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)get_proc("glVertexAttrib3d"); pglVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)get_proc("glVertexAttrib3dv"); pglVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)get_proc("glVertexAttrib3f"); pglVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)get_proc("glVertexAttrib3fv"); pglVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)get_proc("glVertexAttrib3s"); pglVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)get_proc("glVertexAttrib3sv"); pglVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)get_proc("glVertexAttrib4Nbv"); pglVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)get_proc("glVertexAttrib4Niv"); pglVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)get_proc("glVertexAttrib4Nsv"); pglVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)get_proc("glVertexAttrib4Nub"); pglVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)get_proc("glVertexAttrib4Nubv"); pglVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)get_proc("glVertexAttrib4Nuiv"); pglVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)get_proc("glVertexAttrib4Nusv"); pglVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)get_proc("glVertexAttrib4bv"); pglVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)get_proc("glVertexAttrib4d"); pglVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)get_proc("glVertexAttrib4dv"); pglVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)get_proc("glVertexAttrib4f"); pglVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)get_proc("glVertexAttrib4fv"); pglVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)get_proc("glVertexAttrib4iv"); pglVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)get_proc("glVertexAttrib4s"); pglVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)get_proc("glVertexAttrib4sv"); pglVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)get_proc("glVertexAttrib4ubv"); pglVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)get_proc("glVertexAttrib4uiv"); pglVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)get_proc("glVertexAttrib4usv"); pglVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)get_proc("glVertexAttribPointer"); pglUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)get_proc("glUniformMatrix2x3fv"); pglUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)get_proc("glUniformMatrix3x2fv"); pglUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)get_proc("glUniformMatrix2x4fv"); pglUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)get_proc("glUniformMatrix4x2fv"); pglUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)get_proc("glUniformMatrix3x4fv"); pglUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)get_proc("glUniformMatrix4x3fv"); pglColorMaski = (PFNGLCOLORMASKIPROC)get_proc("glColorMaski"); pglGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)get_proc("glGetBooleani_v"); pglGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)get_proc("glGetIntegeri_v"); pglEnablei = (PFNGLENABLEIPROC)get_proc("glEnablei"); pglDisablei = (PFNGLDISABLEIPROC)get_proc("glDisablei"); pglIsEnabledi = (PFNGLISENABLEDIPROC)get_proc("glIsEnabledi"); pglBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)get_proc("glBeginTransformFeedback"); pglEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)get_proc("glEndTransformFeedback"); pglBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)get_proc("glBindBufferRange"); pglBindBufferBase = (PFNGLBINDBUFFERBASEPROC)get_proc("glBindBufferBase"); pglTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)get_proc("glTransformFeedbackVaryings"); pglGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)get_proc("glGetTransformFeedbackVarying"); pglClampColor = (PFNGLCLAMPCOLORPROC)get_proc("glClampColor"); pglBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)get_proc("glBeginConditionalRender"); pglEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)get_proc("glEndConditionalRender"); pglVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)get_proc("glVertexAttribIPointer"); pglGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)get_proc("glGetVertexAttribIiv"); pglGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)get_proc("glGetVertexAttribIuiv"); pglVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)get_proc("glVertexAttribI1i"); pglVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)get_proc("glVertexAttribI2i"); pglVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)get_proc("glVertexAttribI3i"); pglVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)get_proc("glVertexAttribI4i"); pglVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)get_proc("glVertexAttribI1ui"); pglVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)get_proc("glVertexAttribI2ui"); pglVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)get_proc("glVertexAttribI3ui"); pglVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)get_proc("glVertexAttribI4ui"); pglVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)get_proc("glVertexAttribI1iv"); pglVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)get_proc("glVertexAttribI2iv"); pglVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)get_proc("glVertexAttribI3iv"); pglVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)get_proc("glVertexAttribI4iv"); pglVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)get_proc("glVertexAttribI1uiv"); pglVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)get_proc("glVertexAttribI2uiv"); pglVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)get_proc("glVertexAttribI3uiv"); pglVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)get_proc("glVertexAttribI4uiv"); pglVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)get_proc("glVertexAttribI4bv"); pglVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)get_proc("glVertexAttribI4sv"); pglVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)get_proc("glVertexAttribI4ubv"); pglVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)get_proc("glVertexAttribI4usv"); pglGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)get_proc("glGetUniformuiv"); pglBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)get_proc("glBindFragDataLocation"); pglGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)get_proc("glGetFragDataLocation"); pglUniform1ui = (PFNGLUNIFORM1UIPROC)get_proc("glUniform1ui"); pglUniform2ui = (PFNGLUNIFORM2UIPROC)get_proc("glUniform2ui"); pglUniform3ui = (PFNGLUNIFORM3UIPROC)get_proc("glUniform3ui"); pglUniform4ui = (PFNGLUNIFORM4UIPROC)get_proc("glUniform4ui"); pglUniform1uiv = (PFNGLUNIFORM1UIVPROC)get_proc("glUniform1uiv"); pglUniform2uiv = (PFNGLUNIFORM2UIVPROC)get_proc("glUniform2uiv"); pglUniform3uiv = (PFNGLUNIFORM3UIVPROC)get_proc("glUniform3uiv"); pglUniform4uiv = (PFNGLUNIFORM4UIVPROC)get_proc("glUniform4uiv"); pglTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)get_proc("glTexParameterIiv"); pglTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)get_proc("glTexParameterIuiv"); pglGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)get_proc("glGetTexParameterIiv"); pglGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)get_proc("glGetTexParameterIuiv"); pglClearBufferiv = (PFNGLCLEARBUFFERIVPROC)get_proc("glClearBufferiv"); pglClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)get_proc("glClearBufferuiv"); pglClearBufferfv = (PFNGLCLEARBUFFERFVPROC)get_proc("glClearBufferfv"); pglClearBufferfi = (PFNGLCLEARBUFFERFIPROC)get_proc("glClearBufferfi"); pglGetStringi = (PFNGLGETSTRINGIPROC)get_proc("glGetStringi"); pglIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)get_proc("glIsRenderbuffer"); pglBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)get_proc("glBindRenderbuffer"); pglDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)get_proc("glDeleteRenderbuffers"); pglGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)get_proc("glGenRenderbuffers"); pglRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)get_proc("glRenderbufferStorage"); pglGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)get_proc("glGetRenderbufferParameteriv"); pglIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)get_proc("glIsFramebuffer"); pglBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)get_proc("glBindFramebuffer"); pglDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)get_proc("glDeleteFramebuffers"); pglGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)get_proc("glGenFramebuffers"); pglCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)get_proc("glCheckFramebufferStatus"); pglFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)get_proc("glFramebufferTexture1D"); pglFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)get_proc("glFramebufferTexture2D"); pglFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)get_proc("glFramebufferTexture3D"); pglFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)get_proc("glFramebufferRenderbuffer"); pglGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)get_proc("glGetFramebufferAttachmentParameteriv"); pglGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)get_proc("glGenerateMipmap"); pglBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)get_proc("glBlitFramebuffer"); pglRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)get_proc("glRenderbufferStorageMultisample"); pglFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)get_proc("glFramebufferTextureLayer"); pglMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)get_proc("glMapBufferRange"); pglFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)get_proc("glFlushMappedBufferRange"); pglBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)get_proc("glBindVertexArray"); pglDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)get_proc("glDeleteVertexArrays"); pglGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)get_proc("glGenVertexArrays"); pglIsVertexArray = (PFNGLISVERTEXARRAYPROC)get_proc("glIsVertexArray"); pglDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)get_proc("glDrawArraysInstanced"); pglDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)get_proc("glDrawElementsInstanced"); pglTexBuffer = (PFNGLTEXBUFFERPROC)get_proc("glTexBuffer"); pglPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)get_proc("glPrimitiveRestartIndex"); pglCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)get_proc("glCopyBufferSubData"); pglGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)get_proc("glGetUniformIndices"); pglGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)get_proc("glGetActiveUniformsiv"); pglGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)get_proc("glGetActiveUniformName"); pglGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)get_proc("glGetUniformBlockIndex"); pglGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)get_proc("glGetActiveUniformBlockiv"); pglGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)get_proc("glGetActiveUniformBlockName"); pglUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)get_proc("glUniformBlockBinding"); pglDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)get_proc("glDrawElementsBaseVertex"); pglDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)get_proc("glDrawRangeElementsBaseVertex"); pglDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)get_proc("glDrawElementsInstancedBaseVertex"); pglMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)get_proc("glMultiDrawElementsBaseVertex"); pglProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)get_proc("glProvokingVertex"); pglFenceSync = (PFNGLFENCESYNCPROC)get_proc("glFenceSync"); pglIsSync = (PFNGLISSYNCPROC)get_proc("glIsSync"); pglDeleteSync = (PFNGLDELETESYNCPROC)get_proc("glDeleteSync"); pglClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)get_proc("glClientWaitSync"); pglWaitSync = (PFNGLWAITSYNCPROC)get_proc("glWaitSync"); pglGetInteger64v = (PFNGLGETINTEGER64VPROC)get_proc("glGetInteger64v"); pglGetSynciv = (PFNGLGETSYNCIVPROC)get_proc("glGetSynciv"); pglGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)get_proc("glGetInteger64i_v"); pglGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)get_proc("glGetBufferParameteri64v"); pglFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)get_proc("glFramebufferTexture"); pglTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)get_proc("glTexImage2DMultisample"); pglTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)get_proc("glTexImage3DMultisample"); pglGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)get_proc("glGetMultisamplefv"); pglSampleMaski = (PFNGLSAMPLEMASKIPROC)get_proc("glSampleMaski"); pglBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)get_proc("glBindFragDataLocationIndexed"); pglGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)get_proc("glGetFragDataIndex"); pglGenSamplers = (PFNGLGENSAMPLERSPROC)get_proc("glGenSamplers"); pglDeleteSamplers = (PFNGLDELETESAMPLERSPROC)get_proc("glDeleteSamplers"); pglIsSampler = (PFNGLISSAMPLERPROC)get_proc("glIsSampler"); pglBindSampler = (PFNGLBINDSAMPLERPROC)get_proc("glBindSampler"); pglSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)get_proc("glSamplerParameteri"); pglSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)get_proc("glSamplerParameteriv"); pglSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)get_proc("glSamplerParameterf"); pglSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)get_proc("glSamplerParameterfv"); pglSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)get_proc("glSamplerParameterIiv"); pglSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)get_proc("glSamplerParameterIuiv"); pglGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)get_proc("glGetSamplerParameteriv"); pglGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)get_proc("glGetSamplerParameterIiv"); pglGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)get_proc("glGetSamplerParameterfv"); pglGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)get_proc("glGetSamplerParameterIuiv"); pglQueryCounter = (PFNGLQUERYCOUNTERPROC)get_proc("glQueryCounter"); pglGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)get_proc("glGetQueryObjecti64v"); pglGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)get_proc("glGetQueryObjectui64v"); pglVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)get_proc("glVertexAttribDivisor"); pglVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)get_proc("glVertexAttribP1ui"); pglVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)get_proc("glVertexAttribP1uiv"); pglVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)get_proc("glVertexAttribP2ui"); pglVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)get_proc("glVertexAttribP2uiv"); pglVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)get_proc("glVertexAttribP3ui"); pglVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)get_proc("glVertexAttribP3uiv"); pglVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)get_proc("glVertexAttribP4ui"); pglVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)get_proc("glVertexAttribP4uiv"); } // // Definitions of C wrapper functions for all OpenGL loaded pointers // which call the pointer and optionally cals glGetError() to check // for OpenGL errors. // void glCullFace(GLenum mode) { pglCullFace(mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCullFace"); } } } void glFrontFace(GLenum mode) { pglFrontFace(mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFrontFace"); } } } void glHint(GLenum target, GLenum mode) { pglHint(target, mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glHint"); } } } void glLineWidth(GLfloat width) { pglLineWidth(width); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glLineWidth"); } } } void glPointSize(GLfloat size) { pglPointSize(size); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPointSize"); } } } void glPolygonMode(GLenum face, GLenum mode) { pglPolygonMode(face, mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPolygonMode"); } } } void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { pglScissor(x, y, width, height); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glScissor"); } } } void glTexParameterf(GLenum target, GLenum pname, GLfloat param) { pglTexParameterf(target, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexParameterf"); } } } void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { pglTexParameterfv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexParameterfv"); } } } void glTexParameteri(GLenum target, GLenum pname, GLint param) { pglTexParameteri(target, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexParameteri"); } } } void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) { pglTexParameteriv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexParameteriv"); } } } void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) { pglTexImage1D(target, level, internalformat, width, border, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexImage1D"); } } } void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { pglTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexImage2D"); } } } void glDrawBuffer(GLenum buf) { pglDrawBuffer(buf); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawBuffer"); } } } void glClear(GLbitfield mask) { pglClear(mask); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClear"); } } } void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { pglClearColor(red, green, blue, alpha); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearColor"); } } } void glClearStencil(GLint s) { pglClearStencil(s); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearStencil"); } } } void glClearDepth(GLdouble depth) { pglClearDepth(depth); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearDepth"); } } } void glStencilMask(GLuint mask) { pglStencilMask(mask); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glStencilMask"); } } } void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { pglColorMask(red, green, blue, alpha); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glColorMask"); } } } void glDepthMask(GLboolean flag) { pglDepthMask(flag); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDepthMask"); } } } void glDisable(GLenum cap) { pglDisable(cap); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDisable"); } } } void glEnable(GLenum cap) { pglEnable(cap); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glEnable"); } } } void glFinish(void) { pglFinish(); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFinish"); } } } void glFlush(void) { pglFlush(); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFlush"); } } } void glBlendFunc(GLenum sfactor, GLenum dfactor) { pglBlendFunc(sfactor, dfactor); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBlendFunc"); } } } void glLogicOp(GLenum opcode) { pglLogicOp(opcode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glLogicOp"); } } } void glStencilFunc(GLenum func, GLint ref, GLuint mask) { pglStencilFunc(func, ref, mask); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glStencilFunc"); } } } void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { pglStencilOp(fail, zfail, zpass); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glStencilOp"); } } } void glDepthFunc(GLenum func) { pglDepthFunc(func); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDepthFunc"); } } } void glPixelStoref(GLenum pname, GLfloat param) { pglPixelStoref(pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPixelStoref"); } } } void glPixelStorei(GLenum pname, GLint param) { pglPixelStorei(pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPixelStorei"); } } } void glReadBuffer(GLenum src) { pglReadBuffer(src); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glReadBuffer"); } } } void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) { pglReadPixels(x, y, width, height, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glReadPixels"); } } } void glGetBooleanv(GLenum pname, GLboolean *data) { pglGetBooleanv(pname, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetBooleanv"); } } } void glGetDoublev(GLenum pname, GLdouble *data) { pglGetDoublev(pname, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetDoublev"); } } } GLenum glGetError(void) { GLenum res = pglGetError(); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetError"); } } return res; } void glGetFloatv(GLenum pname, GLfloat *data) { pglGetFloatv(pname, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetFloatv"); } } } void glGetIntegerv(GLenum pname, GLint *data) { pglGetIntegerv(pname, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetIntegerv"); } } } const GLubyte * glGetString(GLenum name) { const GLubyte * res = pglGetString(name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetString"); } } return res; } void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) { pglGetTexImage(target, level, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexImage"); } } } void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) { pglGetTexParameterfv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexParameterfv"); } } } void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) { pglGetTexParameteriv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexParameteriv"); } } } void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) { pglGetTexLevelParameterfv(target, level, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexLevelParameterfv"); } } } void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) { pglGetTexLevelParameteriv(target, level, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexLevelParameteriv"); } } } GLboolean glIsEnabled(GLenum cap) { GLboolean res = pglIsEnabled(cap); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsEnabled"); } } return res; } void glDepthRange(GLdouble near, GLdouble far) { pglDepthRange(near, far); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDepthRange"); } } } void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { pglViewport(x, y, width, height); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glViewport"); } } } void glDrawArrays(GLenum mode, GLint first, GLsizei count) { pglDrawArrays(mode, first, count); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawArrays"); } } } void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { pglDrawElements(mode, count, type, indices); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawElements"); } } } void glGetPointerv(GLenum pname, void **params) { pglGetPointerv(pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetPointerv"); } } } void glPolygonOffset(GLfloat factor, GLfloat units) { pglPolygonOffset(factor, units); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPolygonOffset"); } } } void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { pglCopyTexImage1D(target, level, internalformat, x, y, width, border); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCopyTexImage1D"); } } } void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { pglCopyTexImage2D(target, level, internalformat, x, y, width, height, border); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCopyTexImage2D"); } } } void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { pglCopyTexSubImage1D(target, level, xoffset, x, y, width); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCopyTexSubImage1D"); } } } void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { pglCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCopyTexSubImage2D"); } } } void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { pglTexSubImage1D(target, level, xoffset, width, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexSubImage1D"); } } } void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { pglTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexSubImage2D"); } } } void glBindTexture(GLenum target, GLuint texture) { pglBindTexture(target, texture); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindTexture"); } } } void glDeleteTextures(GLsizei n, const GLuint *textures) { pglDeleteTextures(n, textures); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteTextures"); } } } void glGenTextures(GLsizei n, GLuint *textures) { pglGenTextures(n, textures); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenTextures"); } } } GLboolean glIsTexture(GLuint texture) { GLboolean res = pglIsTexture(texture); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsTexture"); } } return res; } void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) { pglDrawRangeElements(mode, start, end, count, type, indices); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawRangeElements"); } } } void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) { pglTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexImage3D"); } } } void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { pglTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexSubImage3D"); } } } void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { pglCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCopyTexSubImage3D"); } } } void glActiveTexture(GLenum texture) { pglActiveTexture(texture); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glActiveTexture"); } } } void glSampleCoverage(GLfloat value, GLboolean invert) { pglSampleCoverage(value, invert); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSampleCoverage"); } } } void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) { pglCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompressedTexImage3D"); } } } void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) { pglCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompressedTexImage2D"); } } } void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data) { pglCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompressedTexImage1D"); } } } void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) { pglCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompressedTexSubImage3D"); } } } void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) { pglCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompressedTexSubImage2D"); } } } void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) { pglCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompressedTexSubImage1D"); } } } void glGetCompressedTexImage(GLenum target, GLint level, void *img) { pglGetCompressedTexImage(target, level, img); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetCompressedTexImage"); } } } void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { pglBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBlendFuncSeparate"); } } } void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) { pglMultiDrawArrays(mode, first, count, drawcount); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glMultiDrawArrays"); } } } void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount) { pglMultiDrawElements(mode, count, type, indices, drawcount); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glMultiDrawElements"); } } } void glPointParameterf(GLenum pname, GLfloat param) { pglPointParameterf(pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPointParameterf"); } } } void glPointParameterfv(GLenum pname, const GLfloat *params) { pglPointParameterfv(pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPointParameterfv"); } } } void glPointParameteri(GLenum pname, GLint param) { pglPointParameteri(pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPointParameteri"); } } } void glPointParameteriv(GLenum pname, const GLint *params) { pglPointParameteriv(pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPointParameteriv"); } } } void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { pglBlendColor(red, green, blue, alpha); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBlendColor"); } } } void glBlendEquation(GLenum mode) { pglBlendEquation(mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBlendEquation"); } } } void glGenQueries(GLsizei n, GLuint *ids) { pglGenQueries(n, ids); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenQueries"); } } } void glDeleteQueries(GLsizei n, const GLuint *ids) { pglDeleteQueries(n, ids); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteQueries"); } } } GLboolean glIsQuery(GLuint id) { GLboolean res = pglIsQuery(id); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsQuery"); } } return res; } void glBeginQuery(GLenum target, GLuint id) { pglBeginQuery(target, id); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBeginQuery"); } } } void glEndQuery(GLenum target) { pglEndQuery(target); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glEndQuery"); } } } void glGetQueryiv(GLenum target, GLenum pname, GLint *params) { pglGetQueryiv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetQueryiv"); } } } void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) { pglGetQueryObjectiv(id, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetQueryObjectiv"); } } } void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) { pglGetQueryObjectuiv(id, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetQueryObjectuiv"); } } } void glBindBuffer(GLenum target, GLuint buffer) { pglBindBuffer(target, buffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindBuffer"); } } } void glDeleteBuffers(GLsizei n, const GLuint *buffers) { pglDeleteBuffers(n, buffers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteBuffers"); } } } void glGenBuffers(GLsizei n, GLuint *buffers) { pglGenBuffers(n, buffers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenBuffers"); } } } GLboolean glIsBuffer(GLuint buffer) { GLboolean res = pglIsBuffer(buffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsBuffer"); } } return res; } void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) { pglBufferData(target, size, data, usage); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBufferData"); } } } void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) { pglBufferSubData(target, offset, size, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBufferSubData"); } } } void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) { pglGetBufferSubData(target, offset, size, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetBufferSubData"); } } } void * glMapBuffer(GLenum target, GLenum access) { void * res = pglMapBuffer(target, access); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glMapBuffer"); } } return res; } GLboolean glUnmapBuffer(GLenum target) { GLboolean res = pglUnmapBuffer(target); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUnmapBuffer"); } } return res; } void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) { pglGetBufferParameteriv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetBufferParameteriv"); } } } void glGetBufferPointerv(GLenum target, GLenum pname, void **params) { pglGetBufferPointerv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetBufferPointerv"); } } } void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { pglBlendEquationSeparate(modeRGB, modeAlpha); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBlendEquationSeparate"); } } } void glDrawBuffers(GLsizei n, const GLenum *bufs) { pglDrawBuffers(n, bufs); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawBuffers"); } } } void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) { pglStencilOpSeparate(face, sfail, dpfail, dppass); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glStencilOpSeparate"); } } } void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { pglStencilFuncSeparate(face, func, ref, mask); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glStencilFuncSeparate"); } } } void glStencilMaskSeparate(GLenum face, GLuint mask) { pglStencilMaskSeparate(face, mask); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glStencilMaskSeparate"); } } } void glAttachShader(GLuint program, GLuint shader) { pglAttachShader(program, shader); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glAttachShader"); } } } void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name) { pglBindAttribLocation(program, index, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindAttribLocation"); } } } void glCompileShader(GLuint shader) { pglCompileShader(shader); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCompileShader"); } } } GLuint glCreateProgram(void) { GLuint res = pglCreateProgram(); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCreateProgram"); } } return res; } GLuint glCreateShader(GLenum type) { GLuint res = pglCreateShader(type); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCreateShader"); } } return res; } void glDeleteProgram(GLuint program) { pglDeleteProgram(program); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteProgram"); } } } void glDeleteShader(GLuint shader) { pglDeleteShader(shader); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteShader"); } } } void glDetachShader(GLuint program, GLuint shader) { pglDetachShader(program, shader); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDetachShader"); } } } void glDisableVertexAttribArray(GLuint index) { pglDisableVertexAttribArray(index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDisableVertexAttribArray"); } } } void glEnableVertexAttribArray(GLuint index) { pglEnableVertexAttribArray(index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glEnableVertexAttribArray"); } } } void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) { pglGetActiveAttrib(program, index, bufSize, length, size, type, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetActiveAttrib"); } } } void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) { pglGetActiveUniform(program, index, bufSize, length, size, type, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetActiveUniform"); } } } void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) { pglGetAttachedShaders(program, maxCount, count, shaders); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetAttachedShaders"); } } } GLint glGetAttribLocation(GLuint program, const GLchar *name) { GLint res = pglGetAttribLocation(program, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetAttribLocation"); } } return res; } void glGetProgramiv(GLuint program, GLenum pname, GLint *params) { pglGetProgramiv(program, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetProgramiv"); } } } void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { pglGetProgramInfoLog(program, bufSize, length, infoLog); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetProgramInfoLog"); } } } void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) { pglGetShaderiv(shader, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetShaderiv"); } } } void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { pglGetShaderInfoLog(shader, bufSize, length, infoLog); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetShaderInfoLog"); } } } void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) { pglGetShaderSource(shader, bufSize, length, source); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetShaderSource"); } } } GLint glGetUniformLocation(GLuint program, const GLchar *name) { GLint res = pglGetUniformLocation(program, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetUniformLocation"); } } return res; } void glGetUniformfv(GLuint program, GLint location, GLfloat *params) { pglGetUniformfv(program, location, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetUniformfv"); } } } void glGetUniformiv(GLuint program, GLint location, GLint *params) { pglGetUniformiv(program, location, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetUniformiv"); } } } void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) { pglGetVertexAttribdv(index, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetVertexAttribdv"); } } } void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) { pglGetVertexAttribfv(index, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetVertexAttribfv"); } } } void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) { pglGetVertexAttribiv(index, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetVertexAttribiv"); } } } void glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer) { pglGetVertexAttribPointerv(index, pname, pointer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetVertexAttribPointerv"); } } } GLboolean glIsProgram(GLuint program) { GLboolean res = pglIsProgram(program); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsProgram"); } } return res; } GLboolean glIsShader(GLuint shader) { GLboolean res = pglIsShader(shader); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsShader"); } } return res; } void glLinkProgram(GLuint program) { pglLinkProgram(program); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glLinkProgram"); } } } void glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) { pglShaderSource(shader, count, string, length); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glShaderSource"); } } } void glUseProgram(GLuint program) { pglUseProgram(program); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUseProgram"); } } } void glUniform1f(GLint location, GLfloat v0) { pglUniform1f(location, v0); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform1f"); } } } void glUniform2f(GLint location, GLfloat v0, GLfloat v1) { pglUniform2f(location, v0, v1); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform2f"); } } } void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { pglUniform3f(location, v0, v1, v2); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform3f"); } } } void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { pglUniform4f(location, v0, v1, v2, v3); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform4f"); } } } void glUniform1i(GLint location, GLint v0) { pglUniform1i(location, v0); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform1i"); } } } void glUniform2i(GLint location, GLint v0, GLint v1) { pglUniform2i(location, v0, v1); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform2i"); } } } void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) { pglUniform3i(location, v0, v1, v2); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform3i"); } } } void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { pglUniform4i(location, v0, v1, v2, v3); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform4i"); } } } void glUniform1fv(GLint location, GLsizei count, const GLfloat *value) { pglUniform1fv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform1fv"); } } } void glUniform2fv(GLint location, GLsizei count, const GLfloat *value) { pglUniform2fv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform2fv"); } } } void glUniform3fv(GLint location, GLsizei count, const GLfloat *value) { pglUniform3fv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform3fv"); } } } void glUniform4fv(GLint location, GLsizei count, const GLfloat *value) { pglUniform4fv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform4fv"); } } } void glUniform1iv(GLint location, GLsizei count, const GLint *value) { pglUniform1iv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform1iv"); } } } void glUniform2iv(GLint location, GLsizei count, const GLint *value) { pglUniform2iv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform2iv"); } } } void glUniform3iv(GLint location, GLsizei count, const GLint *value) { pglUniform3iv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform3iv"); } } } void glUniform4iv(GLint location, GLsizei count, const GLint *value) { pglUniform4iv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform4iv"); } } } void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix2fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix2fv"); } } } void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix3fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix3fv"); } } } void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix4fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix4fv"); } } } void glValidateProgram(GLuint program) { pglValidateProgram(program); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glValidateProgram"); } } } void glVertexAttrib1d(GLuint index, GLdouble x) { pglVertexAttrib1d(index, x); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib1d"); } } } void glVertexAttrib1dv(GLuint index, const GLdouble *v) { pglVertexAttrib1dv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib1dv"); } } } void glVertexAttrib1f(GLuint index, GLfloat x) { pglVertexAttrib1f(index, x); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib1f"); } } } void glVertexAttrib1fv(GLuint index, const GLfloat *v) { pglVertexAttrib1fv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib1fv"); } } } void glVertexAttrib1s(GLuint index, GLshort x) { pglVertexAttrib1s(index, x); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib1s"); } } } void glVertexAttrib1sv(GLuint index, const GLshort *v) { pglVertexAttrib1sv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib1sv"); } } } void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) { pglVertexAttrib2d(index, x, y); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib2d"); } } } void glVertexAttrib2dv(GLuint index, const GLdouble *v) { pglVertexAttrib2dv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib2dv"); } } } void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) { pglVertexAttrib2f(index, x, y); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib2f"); } } } void glVertexAttrib2fv(GLuint index, const GLfloat *v) { pglVertexAttrib2fv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib2fv"); } } } void glVertexAttrib2s(GLuint index, GLshort x, GLshort y) { pglVertexAttrib2s(index, x, y); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib2s"); } } } void glVertexAttrib2sv(GLuint index, const GLshort *v) { pglVertexAttrib2sv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib2sv"); } } } void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) { pglVertexAttrib3d(index, x, y, z); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib3d"); } } } void glVertexAttrib3dv(GLuint index, const GLdouble *v) { pglVertexAttrib3dv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib3dv"); } } } void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) { pglVertexAttrib3f(index, x, y, z); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib3f"); } } } void glVertexAttrib3fv(GLuint index, const GLfloat *v) { pglVertexAttrib3fv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib3fv"); } } } void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) { pglVertexAttrib3s(index, x, y, z); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib3s"); } } } void glVertexAttrib3sv(GLuint index, const GLshort *v) { pglVertexAttrib3sv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib3sv"); } } } void glVertexAttrib4Nbv(GLuint index, const GLbyte *v) { pglVertexAttrib4Nbv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Nbv"); } } } void glVertexAttrib4Niv(GLuint index, const GLint *v) { pglVertexAttrib4Niv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Niv"); } } } void glVertexAttrib4Nsv(GLuint index, const GLshort *v) { pglVertexAttrib4Nsv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Nsv"); } } } void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { pglVertexAttrib4Nub(index, x, y, z, w); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Nub"); } } } void glVertexAttrib4Nubv(GLuint index, const GLubyte *v) { pglVertexAttrib4Nubv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Nubv"); } } } void glVertexAttrib4Nuiv(GLuint index, const GLuint *v) { pglVertexAttrib4Nuiv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Nuiv"); } } } void glVertexAttrib4Nusv(GLuint index, const GLushort *v) { pglVertexAttrib4Nusv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4Nusv"); } } } void glVertexAttrib4bv(GLuint index, const GLbyte *v) { pglVertexAttrib4bv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4bv"); } } } void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { pglVertexAttrib4d(index, x, y, z, w); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4d"); } } } void glVertexAttrib4dv(GLuint index, const GLdouble *v) { pglVertexAttrib4dv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4dv"); } } } void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { pglVertexAttrib4f(index, x, y, z, w); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4f"); } } } void glVertexAttrib4fv(GLuint index, const GLfloat *v) { pglVertexAttrib4fv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4fv"); } } } void glVertexAttrib4iv(GLuint index, const GLint *v) { pglVertexAttrib4iv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4iv"); } } } void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { pglVertexAttrib4s(index, x, y, z, w); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4s"); } } } void glVertexAttrib4sv(GLuint index, const GLshort *v) { pglVertexAttrib4sv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4sv"); } } } void glVertexAttrib4ubv(GLuint index, const GLubyte *v) { pglVertexAttrib4ubv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4ubv"); } } } void glVertexAttrib4uiv(GLuint index, const GLuint *v) { pglVertexAttrib4uiv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4uiv"); } } } void glVertexAttrib4usv(GLuint index, const GLushort *v) { pglVertexAttrib4usv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttrib4usv"); } } } void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) { pglVertexAttribPointer(index, size, type, normalized, stride, pointer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribPointer"); } } } void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix2x3fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix2x3fv"); } } } void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix3x2fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix3x2fv"); } } } void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix2x4fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix2x4fv"); } } } void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix4x2fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix4x2fv"); } } } void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix3x4fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix3x4fv"); } } } void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { pglUniformMatrix4x3fv(location, count, transpose, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformMatrix4x3fv"); } } } void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) { pglColorMaski(index, r, g, b, a); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glColorMaski"); } } } void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data) { pglGetBooleani_v(target, index, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetBooleani_v"); } } } void glGetIntegeri_v(GLenum target, GLuint index, GLint *data) { pglGetIntegeri_v(target, index, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetIntegeri_v"); } } } void glEnablei(GLenum target, GLuint index) { pglEnablei(target, index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glEnablei"); } } } void glDisablei(GLenum target, GLuint index) { pglDisablei(target, index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDisablei"); } } } GLboolean glIsEnabledi(GLenum target, GLuint index) { GLboolean res = pglIsEnabledi(target, index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsEnabledi"); } } return res; } void glBeginTransformFeedback(GLenum primitiveMode) { pglBeginTransformFeedback(primitiveMode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBeginTransformFeedback"); } } } void glEndTransformFeedback(void) { pglEndTransformFeedback(); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glEndTransformFeedback"); } } } void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) { pglBindBufferRange(target, index, buffer, offset, size); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindBufferRange"); } } } void glBindBufferBase(GLenum target, GLuint index, GLuint buffer) { pglBindBufferBase(target, index, buffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindBufferBase"); } } } void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode) { pglTransformFeedbackVaryings(program, count, varyings, bufferMode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTransformFeedbackVaryings"); } } } void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) { pglGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTransformFeedbackVarying"); } } } void glClampColor(GLenum target, GLenum clamp) { pglClampColor(target, clamp); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClampColor"); } } } void glBeginConditionalRender(GLuint id, GLenum mode) { pglBeginConditionalRender(id, mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBeginConditionalRender"); } } } void glEndConditionalRender(void) { pglEndConditionalRender(); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glEndConditionalRender"); } } } void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) { pglVertexAttribIPointer(index, size, type, stride, pointer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribIPointer"); } } } void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) { pglGetVertexAttribIiv(index, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetVertexAttribIiv"); } } } void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) { pglGetVertexAttribIuiv(index, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetVertexAttribIuiv"); } } } void glVertexAttribI1i(GLuint index, GLint x) { pglVertexAttribI1i(index, x); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI1i"); } } } void glVertexAttribI2i(GLuint index, GLint x, GLint y) { pglVertexAttribI2i(index, x, y); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI2i"); } } } void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z) { pglVertexAttribI3i(index, x, y, z); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI3i"); } } } void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) { pglVertexAttribI4i(index, x, y, z, w); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4i"); } } } void glVertexAttribI1ui(GLuint index, GLuint x) { pglVertexAttribI1ui(index, x); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI1ui"); } } } void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y) { pglVertexAttribI2ui(index, x, y); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI2ui"); } } } void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z) { pglVertexAttribI3ui(index, x, y, z); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI3ui"); } } } void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) { pglVertexAttribI4ui(index, x, y, z, w); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4ui"); } } } void glVertexAttribI1iv(GLuint index, const GLint *v) { pglVertexAttribI1iv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI1iv"); } } } void glVertexAttribI2iv(GLuint index, const GLint *v) { pglVertexAttribI2iv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI2iv"); } } } void glVertexAttribI3iv(GLuint index, const GLint *v) { pglVertexAttribI3iv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI3iv"); } } } void glVertexAttribI4iv(GLuint index, const GLint *v) { pglVertexAttribI4iv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4iv"); } } } void glVertexAttribI1uiv(GLuint index, const GLuint *v) { pglVertexAttribI1uiv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI1uiv"); } } } void glVertexAttribI2uiv(GLuint index, const GLuint *v) { pglVertexAttribI2uiv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI2uiv"); } } } void glVertexAttribI3uiv(GLuint index, const GLuint *v) { pglVertexAttribI3uiv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI3uiv"); } } } void glVertexAttribI4uiv(GLuint index, const GLuint *v) { pglVertexAttribI4uiv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4uiv"); } } } void glVertexAttribI4bv(GLuint index, const GLbyte *v) { pglVertexAttribI4bv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4bv"); } } } void glVertexAttribI4sv(GLuint index, const GLshort *v) { pglVertexAttribI4sv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4sv"); } } } void glVertexAttribI4ubv(GLuint index, const GLubyte *v) { pglVertexAttribI4ubv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4ubv"); } } } void glVertexAttribI4usv(GLuint index, const GLushort *v) { pglVertexAttribI4usv(index, v); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribI4usv"); } } } void glGetUniformuiv(GLuint program, GLint location, GLuint *params) { pglGetUniformuiv(program, location, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetUniformuiv"); } } } void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) { pglBindFragDataLocation(program, color, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindFragDataLocation"); } } } GLint glGetFragDataLocation(GLuint program, const GLchar *name) { GLint res = pglGetFragDataLocation(program, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetFragDataLocation"); } } return res; } void glUniform1ui(GLint location, GLuint v0) { pglUniform1ui(location, v0); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform1ui"); } } } void glUniform2ui(GLint location, GLuint v0, GLuint v1) { pglUniform2ui(location, v0, v1); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform2ui"); } } } void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) { pglUniform3ui(location, v0, v1, v2); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform3ui"); } } } void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) { pglUniform4ui(location, v0, v1, v2, v3); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform4ui"); } } } void glUniform1uiv(GLint location, GLsizei count, const GLuint *value) { pglUniform1uiv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform1uiv"); } } } void glUniform2uiv(GLint location, GLsizei count, const GLuint *value) { pglUniform2uiv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform2uiv"); } } } void glUniform3uiv(GLint location, GLsizei count, const GLuint *value) { pglUniform3uiv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform3uiv"); } } } void glUniform4uiv(GLint location, GLsizei count, const GLuint *value) { pglUniform4uiv(location, count, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniform4uiv"); } } } void glTexParameterIiv(GLenum target, GLenum pname, const GLint *params) { pglTexParameterIiv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexParameterIiv"); } } } void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) { pglTexParameterIuiv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexParameterIuiv"); } } } void glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params) { pglGetTexParameterIiv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexParameterIiv"); } } } void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params) { pglGetTexParameterIuiv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetTexParameterIuiv"); } } } void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) { pglClearBufferiv(buffer, drawbuffer, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearBufferiv"); } } } void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) { pglClearBufferuiv(buffer, drawbuffer, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearBufferuiv"); } } } void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) { pglClearBufferfv(buffer, drawbuffer, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearBufferfv"); } } } void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) { pglClearBufferfi(buffer, drawbuffer, depth, stencil); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClearBufferfi"); } } } const GLubyte * glGetStringi(GLenum name, GLuint index) { const GLubyte * res = pglGetStringi(name, index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetStringi"); } } return res; } GLboolean glIsRenderbuffer(GLuint renderbuffer) { GLboolean res = pglIsRenderbuffer(renderbuffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsRenderbuffer"); } } return res; } void glBindRenderbuffer(GLenum target, GLuint renderbuffer) { pglBindRenderbuffer(target, renderbuffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindRenderbuffer"); } } } void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) { pglDeleteRenderbuffers(n, renderbuffers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteRenderbuffers"); } } } void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) { pglGenRenderbuffers(n, renderbuffers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenRenderbuffers"); } } } void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { pglRenderbufferStorage(target, internalformat, width, height); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glRenderbufferStorage"); } } } void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) { pglGetRenderbufferParameteriv(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetRenderbufferParameteriv"); } } } GLboolean glIsFramebuffer(GLuint framebuffer) { GLboolean res = pglIsFramebuffer(framebuffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsFramebuffer"); } } return res; } void glBindFramebuffer(GLenum target, GLuint framebuffer) { pglBindFramebuffer(target, framebuffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindFramebuffer"); } } } void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) { pglDeleteFramebuffers(n, framebuffers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteFramebuffers"); } } } void glGenFramebuffers(GLsizei n, GLuint *framebuffers) { pglGenFramebuffers(n, framebuffers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenFramebuffers"); } } } GLenum glCheckFramebufferStatus(GLenum target) { GLenum res = pglCheckFramebufferStatus(target); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCheckFramebufferStatus"); } } return res; } void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { pglFramebufferTexture1D(target, attachment, textarget, texture, level); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFramebufferTexture1D"); } } } void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { pglFramebufferTexture2D(target, attachment, textarget, texture, level); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFramebufferTexture2D"); } } } void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { pglFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFramebufferTexture3D"); } } } void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { pglFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFramebufferRenderbuffer"); } } } void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) { pglGetFramebufferAttachmentParameteriv(target, attachment, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetFramebufferAttachmentParameteriv"); } } } void glGenerateMipmap(GLenum target) { pglGenerateMipmap(target); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenerateMipmap"); } } } void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { pglBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBlitFramebuffer"); } } } void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { pglRenderbufferStorageMultisample(target, samples, internalformat, width, height); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glRenderbufferStorageMultisample"); } } } void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { pglFramebufferTextureLayer(target, attachment, texture, level, layer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFramebufferTextureLayer"); } } } void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { void * res = pglMapBufferRange(target, offset, length, access); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glMapBufferRange"); } } return res; } void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) { pglFlushMappedBufferRange(target, offset, length); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFlushMappedBufferRange"); } } } void glBindVertexArray(GLuint array) { pglBindVertexArray(array); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindVertexArray"); } } } void glDeleteVertexArrays(GLsizei n, const GLuint *arrays) { pglDeleteVertexArrays(n, arrays); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteVertexArrays"); } } } void glGenVertexArrays(GLsizei n, GLuint *arrays) { pglGenVertexArrays(n, arrays); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenVertexArrays"); } } } GLboolean glIsVertexArray(GLuint array) { GLboolean res = pglIsVertexArray(array); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsVertexArray"); } } return res; } void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) { pglDrawArraysInstanced(mode, first, count, instancecount); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawArraysInstanced"); } } } void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) { pglDrawElementsInstanced(mode, count, type, indices, instancecount); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawElementsInstanced"); } } } void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer) { pglTexBuffer(target, internalformat, buffer); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexBuffer"); } } } void glPrimitiveRestartIndex(GLuint index) { pglPrimitiveRestartIndex(index); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glPrimitiveRestartIndex"); } } } void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { pglCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glCopyBufferSubData"); } } } void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) { pglGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetUniformIndices"); } } } void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) { pglGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetActiveUniformsiv"); } } } void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName) { pglGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetActiveUniformName"); } } } GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) { GLuint res = pglGetUniformBlockIndex(program, uniformBlockName); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetUniformBlockIndex"); } } return res; } void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) { pglGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetActiveUniformBlockiv"); } } } void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) { pglGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetActiveUniformBlockName"); } } } void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { pglUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glUniformBlockBinding"); } } } void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) { pglDrawElementsBaseVertex(mode, count, type, indices, basevertex); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawElementsBaseVertex"); } } } void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex) { pglDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawRangeElementsBaseVertex"); } } } void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) { pglDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDrawElementsInstancedBaseVertex"); } } } void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex) { pglMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glMultiDrawElementsBaseVertex"); } } } void glProvokingVertex(GLenum mode) { pglProvokingVertex(mode); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glProvokingVertex"); } } } GLsync glFenceSync(GLenum condition, GLbitfield flags) { GLsync res = pglFenceSync(condition, flags); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFenceSync"); } } return res; } GLboolean glIsSync(GLsync sync) { GLboolean res = pglIsSync(sync); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsSync"); } } return res; } void glDeleteSync(GLsync sync) { pglDeleteSync(sync); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteSync"); } } } GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) { GLenum res = pglClientWaitSync(sync, flags, timeout); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glClientWaitSync"); } } return res; } void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) { pglWaitSync(sync, flags, timeout); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glWaitSync"); } } } void glGetInteger64v(GLenum pname, GLint64 *data) { pglGetInteger64v(pname, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetInteger64v"); } } } void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values) { pglGetSynciv(sync, pname, bufSize, length, values); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetSynciv"); } } } void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data) { pglGetInteger64i_v(target, index, data); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetInteger64i_v"); } } } void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params) { pglGetBufferParameteri64v(target, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetBufferParameteri64v"); } } } void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) { pglFramebufferTexture(target, attachment, texture, level); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glFramebufferTexture"); } } } void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { pglTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexImage2DMultisample"); } } } void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { pglTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glTexImage3DMultisample"); } } } void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val) { pglGetMultisamplefv(pname, index, val); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetMultisamplefv"); } } } void glSampleMaski(GLuint maskNumber, GLbitfield mask) { pglSampleMaski(maskNumber, mask); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSampleMaski"); } } } void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name) { pglBindFragDataLocationIndexed(program, colorNumber, index, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindFragDataLocationIndexed"); } } } GLint glGetFragDataIndex(GLuint program, const GLchar *name) { GLint res = pglGetFragDataIndex(program, name); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetFragDataIndex"); } } return res; } void glGenSamplers(GLsizei count, GLuint *samplers) { pglGenSamplers(count, samplers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGenSamplers"); } } } void glDeleteSamplers(GLsizei count, const GLuint *samplers) { pglDeleteSamplers(count, samplers); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glDeleteSamplers"); } } } GLboolean glIsSampler(GLuint sampler) { GLboolean res = pglIsSampler(sampler); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glIsSampler"); } } return res; } void glBindSampler(GLuint unit, GLuint sampler) { pglBindSampler(unit, sampler); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glBindSampler"); } } } void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) { pglSamplerParameteri(sampler, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSamplerParameteri"); } } } void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param) { pglSamplerParameteriv(sampler, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSamplerParameteriv"); } } } void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) { pglSamplerParameterf(sampler, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSamplerParameterf"); } } } void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param) { pglSamplerParameterfv(sampler, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSamplerParameterfv"); } } } void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param) { pglSamplerParameterIiv(sampler, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSamplerParameterIiv"); } } } void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param) { pglSamplerParameterIuiv(sampler, pname, param); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glSamplerParameterIuiv"); } } } void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params) { pglGetSamplerParameteriv(sampler, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetSamplerParameteriv"); } } } void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params) { pglGetSamplerParameterIiv(sampler, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetSamplerParameterIiv"); } } } void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params) { pglGetSamplerParameterfv(sampler, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetSamplerParameterfv"); } } } void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params) { pglGetSamplerParameterIuiv(sampler, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetSamplerParameterIuiv"); } } } void glQueryCounter(GLuint id, GLenum target) { pglQueryCounter(id, target); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glQueryCounter"); } } } void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params) { pglGetQueryObjecti64v(id, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetQueryObjecti64v"); } } } void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params) { pglGetQueryObjectui64v(id, pname, params); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glGetQueryObjectui64v"); } } } void glVertexAttribDivisor(GLuint index, GLuint divisor) { pglVertexAttribDivisor(index, divisor); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribDivisor"); } } } void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) { pglVertexAttribP1ui(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP1ui"); } } } void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value) { pglVertexAttribP1uiv(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP1uiv"); } } } void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) { pglVertexAttribP2ui(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP2ui"); } } } void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value) { pglVertexAttribP2uiv(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP2uiv"); } } } void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) { pglVertexAttribP3ui(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP3ui"); } } } void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value) { pglVertexAttribP3uiv(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP3uiv"); } } } void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) { pglVertexAttribP4ui(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP4ui"); } } } void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value) { pglVertexAttribP4uiv(index, type, normalized, value); if (checkError) { GLenum err = pglGetError(); if (err != GL_NO_ERROR) { panic(err, "glVertexAttribP4uiv"); } } }