| /* | |
| ** The OpenGL Extension Wrangler Library | |
| ** Copyright (C) 2008-2017, Nigel Stewart <nigels[]users sourceforge net> | |
| ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org> | |
| ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org> | |
| ** Copyright (C) 2002, Lev Povalahev | |
| ** All rights reserved. | |
| ** | |
| ** Redistribution and use in source and binary forms, with or without | |
| ** modification, are permitted provided that the following conditions are met: | |
| ** | |
| ** * Redistributions of source code must retain the above copyright notice, | |
| ** this list of conditions and the following disclaimer. | |
| ** * Redistributions in binary form must reproduce the above copyright notice, | |
| ** this list of conditions and the following disclaimer in the documentation | |
| ** and/or other materials provided with the distribution. | |
| ** * The name of the author may be used to endorse or promote products | |
| ** derived from this software without specific prior written permission. | |
| ** | |
| ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
| ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
| ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
| ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
| ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
| ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | |
| ** THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| #ifndef GLEW_INCLUDE | |
| #include <GL/glew.h> | |
| #else | |
| #include GLEW_INCLUDE | |
| #endif | |
| #if defined(GLEW_OSMESA) | |
| # define GLAPI extern | |
| # include <GL/osmesa.h> | |
| #elif defined(GLEW_EGL) | |
| # include <GL/eglew.h> | |
| #elif defined(_WIN32) | |
| /* | |
| * If NOGDI is defined, wingdi.h won't be included by windows.h, and thus | |
| * wglGetProcAddress won't be declared. It will instead be implicitly declared, | |
| * potentially incorrectly, which we don't want. | |
| */ | |
| # if defined(NOGDI) | |
| # undef NOGDI | |
| # endif | |
| # include <GL/wglew.h> | |
| #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) | |
| # include <GL/glxew.h> | |
| #endif | |
| #include <stddef.h> /* For size_t */ | |
| #if defined(GLEW_EGL) | |
| #elif defined(GLEW_REGAL) | |
| /* In GLEW_REGAL mode we call direcly into the linked | |
| libRegal.so glGetProcAddressREGAL for looking up | |
| the GL function pointers. */ | |
| # undef glGetProcAddressREGAL | |
| # ifdef WIN32 | |
| extern void * __stdcall glGetProcAddressREGAL(const GLchar *name); | |
| static void * (__stdcall * regalGetProcAddress) (const GLchar *) = glGetProcAddressREGAL; | |
| # else | |
| extern void * glGetProcAddressREGAL(const GLchar *name); | |
| static void * (*regalGetProcAddress) (const GLchar *) = glGetProcAddressREGAL; | |
| # endif | |
| # define glGetProcAddressREGAL GLEW_GET_FUN(__glewGetProcAddressREGAL) | |
| #elif defined(__sgi) || defined (__sun) || defined(__HAIKU__) || defined(GLEW_APPLE_GLX) | |
| #include <dlfcn.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| void* dlGetProcAddress (const GLubyte* name) | |
| { | |
| static void* h = NULL; | |
| static void* gpa; | |
| if (h == NULL) | |
| { | |
| if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL; | |
| gpa = dlsym(h, "glXGetProcAddress"); | |
| } | |
| if (gpa != NULL) | |
| return ((void*(*)(const GLubyte*))gpa)(name); | |
| else | |
| return dlsym(h, (const char*)name); | |
| } | |
| #endif /* __sgi || __sun || GLEW_APPLE_GLX */ | |
| #if defined(__APPLE__) | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <AvailabilityMacros.h> | |
| #ifdef MAC_OS_X_VERSION_10_3 | |
| #include <dlfcn.h> | |
| void* NSGLGetProcAddress (const GLubyte *name) | |
| { | |
| static void* image = NULL; | |
| void* addr; | |
| if (NULL == image) | |
| { | |
| image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY); | |
| } | |
| if( !image ) return NULL; | |
| addr = dlsym(image, (const char*)name); | |
| if( addr ) return addr; | |
| #ifdef GLEW_APPLE_GLX | |
| return dlGetProcAddress( name ); // try next for glx symbols | |
| #else | |
| return NULL; | |
| #endif | |
| } | |
| #else | |
| #include <mach-o/dyld.h> | |
| void* NSGLGetProcAddress (const GLubyte *name) | |
| { | |
| static const struct mach_header* image = NULL; | |
| NSSymbol symbol; | |
| char* symbolName; | |
| if (NULL == image) | |
| { | |
| image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); | |
| } | |
| /* prepend a '_' for the Unix C symbol mangling convention */ | |
| symbolName = malloc(strlen((const char*)name) + 2); | |
| strcpy(symbolName+1, (const char*)name); | |
| symbolName[0] = '_'; | |
| symbol = NULL; | |
| /* if (NSIsSymbolNameDefined(symbolName)) | |
| symbol = NSLookupAndBindSymbol(symbolName); */ | |
| symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL; | |
| free(symbolName); | |
| if( symbol ) return NSAddressOfSymbol(symbol); | |
| #ifdef GLEW_APPLE_GLX | |
| return dlGetProcAddress( name ); // try next for glx symbols | |
| #else | |
| return NULL; | |
| #endif | |
| } | |
| #endif /* MAC_OS_X_VERSION_10_3 */ | |
| #endif /* __APPLE__ */ | |
| /* | |
| * Define glewGetProcAddress. | |
| */ | |
| #if defined(GLEW_REGAL) | |
| # define glewGetProcAddress(name) regalGetProcAddress((const GLchar *)name) | |
| #elif defined(GLEW_OSMESA) | |
| # define glewGetProcAddress(name) OSMesaGetProcAddress((const char *)name) | |
| #elif defined(GLEW_EGL) | |
| # define glewGetProcAddress(name) eglGetProcAddress((const char *)name) | |
| #elif defined(_WIN32) | |
| # define glewGetProcAddress(name) wglGetProcAddress((LPCSTR)name) | |
| #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX) | |
| # define glewGetProcAddress(name) NSGLGetProcAddress(name) | |
| #elif defined(__sgi) || defined(__sun) || defined(__HAIKU__) | |
| # define glewGetProcAddress(name) dlGetProcAddress(name) | |
| #elif defined(__ANDROID__) | |
| # define glewGetProcAddress(name) NULL /* TODO */ | |
| #elif defined(__native_client__) | |
| # define glewGetProcAddress(name) NULL /* TODO */ | |
| #else /* __linux */ | |
| # define glewGetProcAddress(name) (*glXGetProcAddressARB)(name) | |
| #endif | |
| /* | |
| * Redefine GLEW_GET_VAR etc without const cast | |
| */ | |
| #undef GLEW_GET_VAR | |
| # define GLEW_GET_VAR(x) (x) | |
| #ifdef WGLEW_GET_VAR | |
| # undef WGLEW_GET_VAR | |
| # define WGLEW_GET_VAR(x) (x) | |
| #endif /* WGLEW_GET_VAR */ | |
| #ifdef GLXEW_GET_VAR | |
| # undef GLXEW_GET_VAR | |
| # define GLXEW_GET_VAR(x) (x) | |
| #endif /* GLXEW_GET_VAR */ | |
| #ifdef EGLEW_GET_VAR | |
| # undef EGLEW_GET_VAR | |
| # define EGLEW_GET_VAR(x) (x) | |
| #endif /* EGLEW_GET_VAR */ | |
| /* | |
| * GLEW, just like OpenGL or GLU, does not rely on the standard C library. | |
| * These functions implement the functionality required in this file. | |
| */ | |
| static GLuint _glewStrLen (const GLubyte* s) | |
| { | |
| GLuint i=0; | |
| if (s == NULL) return 0; | |
| while (s[i] != '\0') i++; | |
| return i; | |
| } | |
| static GLuint _glewStrCLen (const GLubyte* s, GLubyte c) | |
| { | |
| GLuint i=0; | |
| if (s == NULL) return 0; | |
| while (s[i] != '\0' && s[i] != c) i++; | |
| return i; | |
| } | |
| static GLuint _glewStrCopy(char *d, const char *s, char c) | |
| { | |
| GLuint i=0; | |
| if (s == NULL) return 0; | |
| while (s[i] != '\0' && s[i] != c) { d[i] = s[i]; i++; } | |
| d[i] = '\0'; | |
| return i; | |
| } | |
| #if !defined(GLEW_OSMESA) | |
| #if !defined(__APPLE__) || defined(GLEW_APPLE_GLX) | |
| static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n) | |
| { | |
| GLuint i=0; | |
| if(a == NULL || b == NULL) | |
| return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE; | |
| while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++; | |
| return i == n ? GL_TRUE : GL_FALSE; | |
| } | |
| #endif | |
| #endif | |
| static GLboolean _glewStrSame1 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) | |
| { | |
| while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t')) | |
| { | |
| (*a)++; | |
| (*na)--; | |
| } | |
| if(*na >= nb) | |
| { | |
| GLuint i=0; | |
| while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; | |
| if(i == nb) | |
| { | |
| *a = *a + nb; | |
| *na = *na - nb; | |
| return GL_TRUE; | |
| } | |
| } | |
| return GL_FALSE; | |
| } | |
| static GLboolean _glewStrSame2 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) | |
| { | |
| if(*na >= nb) | |
| { | |
| GLuint i=0; | |
| while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; | |
| if(i == nb) | |
| { | |
| *a = *a + nb; | |
| *na = *na - nb; | |
| return GL_TRUE; | |
| } | |
| } | |
| return GL_FALSE; | |
| } | |
| static GLboolean _glewStrSame3 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) | |
| { | |
| if(*na >= nb) | |
| { | |
| GLuint i=0; | |
| while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; | |
| if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t')) | |
| { | |
| *a = *a + nb; | |
| *na = *na - nb; | |
| return GL_TRUE; | |
| } | |
| } | |
| return GL_FALSE; | |
| } | |
| /* | |
| * Search for name in the extensions string. Use of strstr() | |
| * is not sufficient because extension names can be prefixes of | |
| * other extension names. Could use strtok() but the constant | |
| * string returned by glGetString might be in read-only memory. | |
| */ | |
| #if !defined(GLEW_OSMESA) | |
| #if !defined(__APPLE__) || defined(GLEW_APPLE_GLX) | |
| static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end) | |
| { | |
| const GLubyte* p; | |
| GLuint len = _glewStrLen((const GLubyte*)name); | |
| p = start; | |
| while (p < end) | |
| { | |
| GLuint n = _glewStrCLen(p, ' '); | |
| if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE; | |
| p += n+1; | |
| } | |
| return GL_FALSE; | |
| } | |
| #endif | |
| #endif | |
| PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL; | |
| PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL; | |
| PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL; | |
| PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL; | |
| PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL; | |
| PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL; | |
| PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL; | |
| PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL; | |
| PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL; | |
| PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL; | |
| PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL; | |
| PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL; | |
| PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL; | |
| PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL; | |
| PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL; | |
| PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL; | |
| PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL; | |
| PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL; | |
| PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL; | |
| PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL; | |
| PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL; | |
| PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL; | |
| PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL; | |
| PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL; | |
| PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL; | |
| PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL; | |
| PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL; | |
| PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL; | |
| PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL; | |
| PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL; | |
| PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL; | |
| PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL; | |
| PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL; | |
| PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL; | |
| PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL; | |
| PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL; | |
| PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL; | |
| PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL; | |
| PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL; | |
| PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL; | |
| PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL; | |
| PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL; | |
| PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL; | |
| PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL; | |
| PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL; | |
| PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL; | |
| PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL; | |
| PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL; | |
| PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL; | |
| PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL; | |
| PFNGLBLENDCOLORPROC __glewBlendColor = NULL; | |
| PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL; | |
| PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL; | |
| PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL; | |
| PFNGLFOGCOORDDPROC __glewFogCoordd = NULL; | |
| PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL; | |
| PFNGLFOGCOORDFPROC __glewFogCoordf = NULL; | |
| PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL; | |
| PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL; | |
| PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL; | |
| PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL; | |
| PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL; | |
| PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL; | |
| PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL; | |
| PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL; | |
| PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL; | |
| PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL; | |
| PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL; | |
| PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL; | |
| PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL; | |
| PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL; | |
| PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL; | |
| PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL; | |
| PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL; | |
| PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL; | |
| PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL; | |
| PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL; | |
| PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL; | |
| PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL; | |
| PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL; | |
| PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL; | |
| PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL; | |
| PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL; | |
| PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL; | |
| PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL; | |
| PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL; | |
| PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL; | |
| PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL; | |
| PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL; | |
| PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL; | |
| PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL; | |
| PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL; | |
| PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL; | |
| PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL; | |
| PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL; | |
| PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL; | |
| PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL; | |
| PFNGLBEGINQUERYPROC __glewBeginQuery = NULL; | |
| PFNGLBINDBUFFERPROC __glewBindBuffer = NULL; | |
| PFNGLBUFFERDATAPROC __glewBufferData = NULL; | |
| PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL; | |
| PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL; | |
| PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL; | |
| PFNGLENDQUERYPROC __glewEndQuery = NULL; | |
| PFNGLGENBUFFERSPROC __glewGenBuffers = NULL; | |
| PFNGLGENQUERIESPROC __glewGenQueries = NULL; | |
| PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL; | |
| PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL; | |
| PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL; | |
| PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL; | |
| PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL; | |
| PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL; | |
| PFNGLISBUFFERPROC __glewIsBuffer = NULL; | |
| PFNGLISQUERYPROC __glewIsQuery = NULL; | |
| PFNGLMAPBUFFERPROC __glewMapBuffer = NULL; | |
| PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL; | |
| PFNGLATTACHSHADERPROC __glewAttachShader = NULL; | |
| PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL; | |
| PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL; | |
| PFNGLCOMPILESHADERPROC __glewCompileShader = NULL; | |
| PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL; | |
| PFNGLCREATESHADERPROC __glewCreateShader = NULL; | |
| PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL; | |
| PFNGLDELETESHADERPROC __glewDeleteShader = NULL; | |
| PFNGLDETACHSHADERPROC __glewDetachShader = NULL; | |
| PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL; | |
| PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL; | |
| PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL; | |
| PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL; | |
| PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL; | |
| PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL; | |
| PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL; | |
| PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL; | |
| PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL; | |
| PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL; | |
| PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL; | |
| PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL; | |
| PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL; | |
| PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL; | |
| PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL; | |
| PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL; | |
| PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL; | |
| PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL; | |
| PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL; | |
| PFNGLISPROGRAMPROC __glewIsProgram = NULL; | |
| PFNGLISSHADERPROC __glewIsShader = NULL; | |
| PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL; | |
| PFNGLSHADERSOURCEPROC __glewShaderSource = NULL; | |
| PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL; | |
| PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL; | |
| PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL; | |
| PFNGLUNIFORM1FPROC __glewUniform1f = NULL; | |
| PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL; | |
| PFNGLUNIFORM1IPROC __glewUniform1i = NULL; | |
| PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL; | |
| PFNGLUNIFORM2FPROC __glewUniform2f = NULL; | |
| PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL; | |
| PFNGLUNIFORM2IPROC __glewUniform2i = NULL; | |
| PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL; | |
| PFNGLUNIFORM3FPROC __glewUniform3f = NULL; | |
| PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL; | |
| PFNGLUNIFORM3IPROC __glewUniform3i = NULL; | |
| PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL; | |
| PFNGLUNIFORM4FPROC __glewUniform4f = NULL; | |
| PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL; | |
| PFNGLUNIFORM4IPROC __glewUniform4i = NULL; | |
| PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL; | |
| PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL; | |
| PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL; | |
| PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL; | |
| PFNGLUSEPROGRAMPROC __glewUseProgram = NULL; | |
| PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL; | |
| PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL; | |
| PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL; | |
| PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL; | |
| PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL; | |
| PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL; | |
| PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL; | |
| PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL; | |
| PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL; | |
| PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL; | |
| PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL; | |
| PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL; | |
| PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL; | |
| PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL; | |
| PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL; | |
| PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL; | |
| PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL; | |
| PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL; | |
| PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL; | |
| PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL; | |
| PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL; | |
| PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL; | |
| PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL; | |
| PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL; | |
| PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL; | |
| PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL; | |
| PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL; | |
| PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL; | |
| PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL; | |
| PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL; | |
| PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL; | |
| PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL; | |
| PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL; | |
| PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL; | |
| PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL; | |
| PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL; | |
| PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL; | |
| PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL; | |
| PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL; | |
| PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL; | |
| PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL; | |
| PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL; | |
| PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL; | |
| PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL; | |
| PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL; | |
| PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL; | |
| PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL; | |
| PFNGLCLAMPCOLORPROC __glewClampColor = NULL; | |
| PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL; | |
| PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL; | |
| PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL; | |
| PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL; | |
| PFNGLCOLORMASKIPROC __glewColorMaski = NULL; | |
| PFNGLDISABLEIPROC __glewDisablei = NULL; | |
| PFNGLENABLEIPROC __glewEnablei = NULL; | |
| PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL; | |
| PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL; | |
| PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL; | |
| PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL; | |
| PFNGLGETSTRINGIPROC __glewGetStringi = NULL; | |
| PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL; | |
| PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL; | |
| PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL; | |
| PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL; | |
| PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL; | |
| PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL; | |
| PFNGLISENABLEDIPROC __glewIsEnabledi = NULL; | |
| PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL; | |
| PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL; | |
| PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL; | |
| PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL; | |
| PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL; | |
| PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL; | |
| PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL; | |
| PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL; | |
| PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL; | |
| PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL; | |
| PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL; | |
| PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL; | |
| PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL; | |
| PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL; | |
| PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL; | |
| PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL; | |
| PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL; | |
| PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL; | |
| PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL; | |
| PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL; | |
| PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL; | |
| PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL; | |
| PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL; | |
| PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL; | |
| PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL; | |
| PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL; | |
| PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL; | |
| PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL; | |
| PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL; | |
| PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL; | |
| PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL; | |
| PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL; | |
| PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL; | |
| PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL; | |
| PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL; | |
| PFNGLTEXBUFFERPROC __glewTexBuffer = NULL; | |
| PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL; | |
| PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL; | |
| PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL; | |
| PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL; | |
| PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL; | |
| PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL; | |
| PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL; | |
| PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL; | |
| PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL; | |
| PFNGLGETGRAPHICSRESETSTATUSPROC __glewGetGraphicsResetStatus = NULL; | |
| PFNGLGETNCOMPRESSEDTEXIMAGEPROC __glewGetnCompressedTexImage = NULL; | |
| PFNGLGETNTEXIMAGEPROC __glewGetnTexImage = NULL; | |
| PFNGLGETNUNIFORMDVPROC __glewGetnUniformdv = NULL; | |
| PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC __glewMultiDrawArraysIndirectCount = NULL; | |
| PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC __glewMultiDrawElementsIndirectCount = NULL; | |
| PFNGLSPECIALIZESHADERPROC __glewSpecializeShader = NULL; | |
| PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL; | |
| PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL; | |
| PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL; | |
| PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL; | |
| PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL; | |
| PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL; | |
| PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL; | |
| PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL; | |
| PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL; | |
| PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL; | |
| PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL; | |
| PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL; | |
| PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL; | |
| PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL; | |
| PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL; | |
| PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL; | |
| PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL; | |
| PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL; | |
| PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL; | |
| PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL; | |
| PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL; | |
| PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL; | |
| PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL; | |
| PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL; | |
| PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL; | |
| PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL; | |
| PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL; | |
| PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL; | |
| PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL; | |
| PFNGLDELETESYNCPROC __glewDeleteSync = NULL; | |
| PFNGLFENCESYNCPROC __glewFenceSync = NULL; | |
| PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL; | |
| PFNGLGETSYNCIVPROC __glewGetSynciv = NULL; | |
| PFNGLISSYNCPROC __glewIsSync = NULL; | |
| PFNGLWAITSYNCPROC __glewWaitSync = NULL; | |
| PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL; | |
| PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL; | |
| PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL; | |
| PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL; | |
| PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL; | |
| PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL; | |
| PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL; | |
| PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL; | |
| PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL; | |
| PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL; | |
| PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL; | |
| PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL; | |
| PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL; | |
| PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL; | |
| PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL; | |
| PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL; | |
| PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL; | |
| PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL; | |
| PFNGLDEBUGMESSAGECALLBACKPROC __glewDebugMessageCallback = NULL; | |
| PFNGLDEBUGMESSAGECONTROLPROC __glewDebugMessageControl = NULL; | |
| PFNGLDEBUGMESSAGEINSERTPROC __glewDebugMessageInsert = NULL; | |
| PFNGLGETDEBUGMESSAGELOGPROC __glewGetDebugMessageLog = NULL; | |
| PFNGLGETOBJECTLABELPROC __glewGetObjectLabel = NULL; | |
| PFNGLGETOBJECTPTRLABELPROC __glewGetObjectPtrLabel = NULL; | |
| PFNGLOBJECTLABELPROC __glewObjectLabel = NULL; | |
| PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel = NULL; | |
| PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup = NULL; | |
| PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup = NULL; | |
| GLboolean __GLEW_VERSION_1_1 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_1_2 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_1_3 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_1_4 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_1_5 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_2_0 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_2_1 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_3_0 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_3_1 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_3_2 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_3_3 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_0 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_1 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_2 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_3 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_4 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_5 = GL_FALSE; | |
| GLboolean __GLEW_VERSION_4_6 = GL_FALSE; | |
| GLboolean __GLEW_ARB_copy_buffer = GL_FALSE; | |
| GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE; | |
| GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE; | |
| GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE; | |
| GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE; | |
| GLboolean __GLEW_ARB_sync = GL_FALSE; | |
| GLboolean __GLEW_ARB_texture_multisample = GL_FALSE; | |
| GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE; | |
| GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE; | |
| GLboolean __GLEW_KHR_debug = GL_FALSE; | |
| static const char * _glewExtensionLookup[] = { | |
| #ifdef GL_ARB_copy_buffer | |
| "GL_ARB_copy_buffer", | |
| #endif | |
| #ifdef GL_ARB_draw_elements_base_vertex | |
| "GL_ARB_draw_elements_base_vertex", | |
| #endif | |
| #ifdef GL_ARB_framebuffer_object | |
| "GL_ARB_framebuffer_object", | |
| #endif | |
| #ifdef GL_ARB_map_buffer_range | |
| "GL_ARB_map_buffer_range", | |
| #endif | |
| #ifdef GL_ARB_provoking_vertex | |
| "GL_ARB_provoking_vertex", | |
| #endif | |
| #ifdef GL_ARB_sync | |
| "GL_ARB_sync", | |
| #endif | |
| #ifdef GL_ARB_texture_multisample | |
| "GL_ARB_texture_multisample", | |
| #endif | |
| #ifdef GL_ARB_uniform_buffer_object | |
| "GL_ARB_uniform_buffer_object", | |
| #endif | |
| #ifdef GL_ARB_vertex_array_object | |
| "GL_ARB_vertex_array_object", | |
| #endif | |
| #ifdef GL_KHR_debug | |
| "GL_KHR_debug", | |
| #endif | |
| #ifdef GL_VERSION_1_2 | |
| "GL_VERSION_1_2", | |
| #endif | |
| #ifdef GL_VERSION_1_2_1 | |
| "GL_VERSION_1_2_1", | |
| #endif | |
| #ifdef GL_VERSION_1_3 | |
| "GL_VERSION_1_3", | |
| #endif | |
| #ifdef GL_VERSION_1_4 | |
| "GL_VERSION_1_4", | |
| #endif | |
| #ifdef GL_VERSION_1_5 | |
| "GL_VERSION_1_5", | |
| #endif | |
| #ifdef GL_VERSION_2_0 | |
| "GL_VERSION_2_0", | |
| #endif | |
| #ifdef GL_VERSION_2_1 | |
| "GL_VERSION_2_1", | |
| #endif | |
| #ifdef GL_VERSION_3_0 | |
| "GL_VERSION_3_0", | |
| #endif | |
| #ifdef GL_VERSION_3_1 | |
| "GL_VERSION_3_1", | |
| #endif | |
| #ifdef GL_VERSION_3_2 | |
| "GL_VERSION_3_2", | |
| #endif | |
| #ifdef GL_VERSION_3_3 | |
| "GL_VERSION_3_3", | |
| #endif | |
| #ifdef GL_VERSION_4_0 | |
| "GL_VERSION_4_0", | |
| #endif | |
| #ifdef GL_VERSION_4_1 | |
| "GL_VERSION_4_1", | |
| #endif | |
| #ifdef GL_VERSION_4_2 | |
| "GL_VERSION_4_2", | |
| #endif | |
| #ifdef GL_VERSION_4_3 | |
| "GL_VERSION_4_3", | |
| #endif | |
| #ifdef GL_VERSION_4_4 | |
| "GL_VERSION_4_4", | |
| #endif | |
| #ifdef GL_VERSION_4_5 | |
| "GL_VERSION_4_5", | |
| #endif | |
| #ifdef GL_VERSION_4_6 | |
| "GL_VERSION_4_6", | |
| #endif | |
| NULL | |
| }; | |
| /* Detected in the extension string or strings */ | |
| static GLboolean _glewExtensionString[28]; | |
| /* Detected via extension string or experimental mode */ | |
| static GLboolean* _glewExtensionEnabled[] = { | |
| #ifdef GL_ARB_copy_buffer | |
| &__GLEW_ARB_copy_buffer, | |
| #endif | |
| #ifdef GL_ARB_draw_elements_base_vertex | |
| &__GLEW_ARB_draw_elements_base_vertex, | |
| #endif | |
| #ifdef GL_ARB_framebuffer_object | |
| &__GLEW_ARB_framebuffer_object, | |
| #endif | |
| #ifdef GL_ARB_map_buffer_range | |
| &__GLEW_ARB_map_buffer_range, | |
| #endif | |
| #ifdef GL_ARB_provoking_vertex | |
| &__GLEW_ARB_provoking_vertex, | |
| #endif | |
| #ifdef GL_ARB_sync | |
| &__GLEW_ARB_sync, | |
| #endif | |
| #ifdef GL_ARB_texture_multisample | |
| &__GLEW_ARB_texture_multisample, | |
| #endif | |
| #ifdef GL_ARB_uniform_buffer_object | |
| &__GLEW_ARB_uniform_buffer_object, | |
| #endif | |
| #ifdef GL_ARB_vertex_array_object | |
| &__GLEW_ARB_vertex_array_object, | |
| #endif | |
| #ifdef GL_KHR_debug | |
| &__GLEW_KHR_debug, | |
| #endif | |
| #ifdef GL_VERSION_1_2 | |
| &__GLEW_VERSION_1_2, | |
| #endif | |
| #ifdef GL_VERSION_1_2_1 | |
| &__GLEW_VERSION_1_2_1, | |
| #endif | |
| #ifdef GL_VERSION_1_3 | |
| &__GLEW_VERSION_1_3, | |
| #endif | |
| #ifdef GL_VERSION_1_4 | |
| &__GLEW_VERSION_1_4, | |
| #endif | |
| #ifdef GL_VERSION_1_5 | |
| &__GLEW_VERSION_1_5, | |
| #endif | |
| #ifdef GL_VERSION_2_0 | |
| &__GLEW_VERSION_2_0, | |
| #endif | |
| #ifdef GL_VERSION_2_1 | |
| &__GLEW_VERSION_2_1, | |
| #endif | |
| #ifdef GL_VERSION_3_0 | |
| &__GLEW_VERSION_3_0, | |
| #endif | |
| #ifdef GL_VERSION_3_1 | |
| &__GLEW_VERSION_3_1, | |
| #endif | |
| #ifdef GL_VERSION_3_2 | |
| &__GLEW_VERSION_3_2, | |
| #endif | |
| #ifdef GL_VERSION_3_3 | |
| &__GLEW_VERSION_3_3, | |
| #endif | |
| #ifdef GL_VERSION_4_0 | |
| &__GLEW_VERSION_4_0, | |
| #endif | |
| #ifdef GL_VERSION_4_1 | |
| &__GLEW_VERSION_4_1, | |
| #endif | |
| #ifdef GL_VERSION_4_2 | |
| &__GLEW_VERSION_4_2, | |
| #endif | |
| #ifdef GL_VERSION_4_3 | |
| &__GLEW_VERSION_4_3, | |
| #endif | |
| #ifdef GL_VERSION_4_4 | |
| &__GLEW_VERSION_4_4, | |
| #endif | |
| #ifdef GL_VERSION_4_5 | |
| &__GLEW_VERSION_4_5, | |
| #endif | |
| #ifdef GL_VERSION_4_6 | |
| &__GLEW_VERSION_4_6, | |
| #endif | |
| NULL | |
| }; | |
| static GLboolean _glewInit_GL_VERSION_1_2 (); | |
| static GLboolean _glewInit_GL_VERSION_1_3 (); | |
| static GLboolean _glewInit_GL_VERSION_1_4 (); | |
| static GLboolean _glewInit_GL_VERSION_1_5 (); | |
| static GLboolean _glewInit_GL_VERSION_2_0 (); | |
| static GLboolean _glewInit_GL_VERSION_2_1 (); | |
| static GLboolean _glewInit_GL_VERSION_3_0 (); | |
| static GLboolean _glewInit_GL_VERSION_3_1 (); | |
| static GLboolean _glewInit_GL_VERSION_3_2 (); | |
| static GLboolean _glewInit_GL_VERSION_3_3 (); | |
| static GLboolean _glewInit_GL_VERSION_4_0 (); | |
| static GLboolean _glewInit_GL_VERSION_4_5 (); | |
| static GLboolean _glewInit_GL_VERSION_4_6 (); | |
| static GLboolean _glewInit_GL_ARB_copy_buffer (); | |
| static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (); | |
| static GLboolean _glewInit_GL_ARB_framebuffer_object (); | |
| static GLboolean _glewInit_GL_ARB_map_buffer_range (); | |
| static GLboolean _glewInit_GL_ARB_provoking_vertex (); | |
| static GLboolean _glewInit_GL_ARB_sync (); | |
| static GLboolean _glewInit_GL_ARB_texture_multisample (); | |
| static GLboolean _glewInit_GL_ARB_uniform_buffer_object (); | |
| static GLboolean _glewInit_GL_ARB_vertex_array_object (); | |
| static GLboolean _glewInit_GL_KHR_debug (); | |
| #ifdef GL_VERSION_1_2 | |
| static GLboolean _glewInit_GL_VERSION_1_2 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r; | |
| r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r; | |
| r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r; | |
| r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_1_2 */ | |
| #ifdef GL_VERSION_1_3 | |
| static GLboolean _glewInit_GL_VERSION_1_3 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r; | |
| r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r; | |
| r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r; | |
| r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r; | |
| r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r; | |
| r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r; | |
| r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r; | |
| r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r; | |
| r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r; | |
| r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r; | |
| r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r; | |
| r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r; | |
| r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r; | |
| r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r; | |
| r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r; | |
| r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r; | |
| r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r; | |
| r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r; | |
| r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r; | |
| r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r; | |
| r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r; | |
| r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r; | |
| r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r; | |
| r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r; | |
| r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r; | |
| r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r; | |
| r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r; | |
| r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r; | |
| r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r; | |
| r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r; | |
| r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r; | |
| r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r; | |
| r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r; | |
| r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r; | |
| r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r; | |
| r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r; | |
| r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r; | |
| r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r; | |
| r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r; | |
| r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r; | |
| r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r; | |
| r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r; | |
| r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r; | |
| r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r; | |
| r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r; | |
| r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_1_3 */ | |
| #ifdef GL_VERSION_1_4 | |
| static GLboolean _glewInit_GL_VERSION_1_4 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r; | |
| r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; | |
| r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r; | |
| r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r; | |
| r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r; | |
| r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r; | |
| r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r; | |
| r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r; | |
| r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r; | |
| r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r; | |
| r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r; | |
| r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r; | |
| r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r; | |
| r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r; | |
| r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r; | |
| r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r; | |
| r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r; | |
| r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r; | |
| r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r; | |
| r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r; | |
| r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r; | |
| r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r; | |
| r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r; | |
| r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r; | |
| r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r; | |
| r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r; | |
| r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r; | |
| r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r; | |
| r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r; | |
| r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r; | |
| r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r; | |
| r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r; | |
| r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r; | |
| r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r; | |
| r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r; | |
| r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r; | |
| r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r; | |
| r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r; | |
| r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r; | |
| r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r; | |
| r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r; | |
| r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r; | |
| r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r; | |
| r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r; | |
| r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r; | |
| r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r; | |
| r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_1_4 */ | |
| #ifdef GL_VERSION_1_5 | |
| static GLboolean _glewInit_GL_VERSION_1_5 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r; | |
| r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r; | |
| r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r; | |
| r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r; | |
| r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r; | |
| r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r; | |
| r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r; | |
| r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r; | |
| r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r; | |
| r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r; | |
| r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r; | |
| r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r; | |
| r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r; | |
| r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r; | |
| r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r; | |
| r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r; | |
| r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r; | |
| r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r; | |
| r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_1_5 */ | |
| #ifdef GL_VERSION_2_0 | |
| static GLboolean _glewInit_GL_VERSION_2_0 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r; | |
| r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r; | |
| r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r; | |
| r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r; | |
| r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r; | |
| r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r; | |
| r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r; | |
| r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r; | |
| r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r; | |
| r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r; | |
| r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r; | |
| r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r; | |
| r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r; | |
| r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r; | |
| r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r; | |
| r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r; | |
| r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r; | |
| r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r; | |
| r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r; | |
| r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r; | |
| r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r; | |
| r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r; | |
| r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r; | |
| r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r; | |
| r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r; | |
| r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r; | |
| r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r; | |
| r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r; | |
| r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r; | |
| r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r; | |
| r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r; | |
| r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r; | |
| r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r; | |
| r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r; | |
| r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r; | |
| r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r; | |
| r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r; | |
| r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r; | |
| r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r; | |
| r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r; | |
| r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r; | |
| r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r; | |
| r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r; | |
| r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r; | |
| r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r; | |
| r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r; | |
| r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r; | |
| r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r; | |
| r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r; | |
| r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r; | |
| r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r; | |
| r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r; | |
| r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r; | |
| r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r; | |
| r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r; | |
| r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r; | |
| r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r; | |
| r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r; | |
| r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r; | |
| r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r; | |
| r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r; | |
| r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r; | |
| r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r; | |
| r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r; | |
| r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r; | |
| r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r; | |
| r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r; | |
| r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r; | |
| r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r; | |
| r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r; | |
| r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r; | |
| r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r; | |
| r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r; | |
| r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r; | |
| r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r; | |
| r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r; | |
| r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r; | |
| r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r; | |
| r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r; | |
| r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r; | |
| r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r; | |
| r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r; | |
| r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r; | |
| r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r; | |
| r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r; | |
| r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r; | |
| r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r; | |
| r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r; | |
| r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r; | |
| r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r; | |
| r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r; | |
| r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r; | |
| r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_2_0 */ | |
| #ifdef GL_VERSION_2_1 | |
| static GLboolean _glewInit_GL_VERSION_2_1 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r; | |
| r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r; | |
| r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r; | |
| r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r; | |
| r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r; | |
| r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_2_1 */ | |
| #ifdef GL_VERSION_3_0 | |
| static GLboolean _glewInit_GL_VERSION_3_0 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = _glewInit_GL_ARB_framebuffer_object() || r; | |
| r = _glewInit_GL_ARB_map_buffer_range() || r; | |
| r = _glewInit_GL_ARB_uniform_buffer_object() || r; | |
| r = _glewInit_GL_ARB_vertex_array_object() || r; | |
| r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r; | |
| r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r; | |
| r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r; | |
| r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r; | |
| r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r; | |
| r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r; | |
| r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r; | |
| r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r; | |
| r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r; | |
| r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r; | |
| r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r; | |
| r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r; | |
| r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r; | |
| r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r; | |
| r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r; | |
| r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r; | |
| r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r; | |
| r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r; | |
| r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r; | |
| r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r; | |
| r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r; | |
| r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r; | |
| r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r; | |
| r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r; | |
| r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r; | |
| r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r; | |
| r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r; | |
| r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r; | |
| r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r; | |
| r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r; | |
| r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r; | |
| r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r; | |
| r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r; | |
| r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r; | |
| r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r; | |
| r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r; | |
| r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r; | |
| r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r; | |
| r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r; | |
| r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r; | |
| r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r; | |
| r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r; | |
| r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r; | |
| r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r; | |
| r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r; | |
| r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r; | |
| r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r; | |
| r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r; | |
| r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r; | |
| r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r; | |
| r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r; | |
| r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r; | |
| r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r; | |
| r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r; | |
| r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_3_0 */ | |
| #ifdef GL_VERSION_3_1 | |
| static GLboolean _glewInit_GL_VERSION_3_1 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = _glewInit_GL_ARB_copy_buffer() || r; | |
| r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r; | |
| r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r; | |
| r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r; | |
| r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_3_1 */ | |
| #ifdef GL_VERSION_3_2 | |
| static GLboolean _glewInit_GL_VERSION_3_2 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = _glewInit_GL_ARB_draw_elements_base_vertex() || r; | |
| r = _glewInit_GL_ARB_provoking_vertex() || r; | |
| r = _glewInit_GL_ARB_sync() || r; | |
| r = _glewInit_GL_ARB_texture_multisample() || r; | |
| r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r; | |
| r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r; | |
| r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_3_2 */ | |
| #ifdef GL_VERSION_3_3 | |
| static GLboolean _glewInit_GL_VERSION_3_3 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_3_3 */ | |
| #ifdef GL_VERSION_4_0 | |
| static GLboolean _glewInit_GL_VERSION_4_0 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r; | |
| r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r; | |
| r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r; | |
| r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r; | |
| r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_4_0 */ | |
| #ifdef GL_VERSION_4_5 | |
| static GLboolean _glewInit_GL_VERSION_4_5 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glGetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatus")) == NULL) || r; | |
| r = ((glGetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImage")) == NULL) || r; | |
| r = ((glGetnTexImage = (PFNGLGETNTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImage")) == NULL) || r; | |
| r = ((glGetnUniformdv = (PFNGLGETNUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdv")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_4_5 */ | |
| #ifdef GL_VERSION_4_6 | |
| static GLboolean _glewInit_GL_VERSION_4_6 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glMultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectCount")) == NULL) || r; | |
| r = ((glMultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectCount")) == NULL) || r; | |
| r = ((glSpecializeShader = (PFNGLSPECIALIZESHADERPROC)glewGetProcAddress((const GLubyte*)"glSpecializeShader")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_VERSION_4_6 */ | |
| #ifdef GL_ARB_copy_buffer | |
| static GLboolean _glewInit_GL_ARB_copy_buffer () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_copy_buffer */ | |
| #ifdef GL_ARB_draw_elements_base_vertex | |
| static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r; | |
| r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r; | |
| r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r; | |
| r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_draw_elements_base_vertex */ | |
| #ifdef GL_ARB_framebuffer_object | |
| static GLboolean _glewInit_GL_ARB_framebuffer_object () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r; | |
| r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r; | |
| r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r; | |
| r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r; | |
| r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r; | |
| r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r; | |
| r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r; | |
| r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r; | |
| r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r; | |
| r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r; | |
| r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r; | |
| r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r; | |
| r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r; | |
| r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r; | |
| r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r; | |
| r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r; | |
| r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r; | |
| r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r; | |
| r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r; | |
| r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_framebuffer_object */ | |
| #ifdef GL_ARB_map_buffer_range | |
| static GLboolean _glewInit_GL_ARB_map_buffer_range () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r; | |
| r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_map_buffer_range */ | |
| #ifdef GL_ARB_provoking_vertex | |
| static GLboolean _glewInit_GL_ARB_provoking_vertex () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_provoking_vertex */ | |
| #ifdef GL_ARB_sync | |
| static GLboolean _glewInit_GL_ARB_sync () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r; | |
| r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r; | |
| r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r; | |
| r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r; | |
| r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r; | |
| r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r; | |
| r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_sync */ | |
| #ifdef GL_ARB_texture_multisample | |
| static GLboolean _glewInit_GL_ARB_texture_multisample () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r; | |
| r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r; | |
| r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r; | |
| r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_texture_multisample */ | |
| #ifdef GL_ARB_uniform_buffer_object | |
| static GLboolean _glewInit_GL_ARB_uniform_buffer_object () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r; | |
| r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r; | |
| r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r; | |
| r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r; | |
| r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r; | |
| r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r; | |
| r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r; | |
| r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r; | |
| r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r; | |
| r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_uniform_buffer_object */ | |
| #ifdef GL_ARB_vertex_array_object | |
| static GLboolean _glewInit_GL_ARB_vertex_array_object () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r; | |
| r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r; | |
| r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r; | |
| r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_ARB_vertex_array_object */ | |
| #ifdef GL_KHR_debug | |
| static GLboolean _glewInit_GL_KHR_debug () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallback")) == NULL) || r; | |
| r = ((glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControl")) == NULL) || r; | |
| r = ((glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsert")) == NULL) || r; | |
| r = ((glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLog")) == NULL) || r; | |
| r = ((glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabel")) == NULL) || r; | |
| r = ((glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectPtrLabel")) == NULL) || r; | |
| r = ((glObjectLabel = (PFNGLOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectLabel")) == NULL) || r; | |
| r = ((glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectPtrLabel")) == NULL) || r; | |
| r = ((glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPopDebugGroup")) == NULL) || r; | |
| r = ((glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPushDebugGroup")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GL_KHR_debug */ | |
| /* ------------------------------------------------------------------------- */ | |
| static int _glewExtensionCompare(const char *s1, const char *s2) | |
| { | |
| /* http://www.chanduthedev.com/2012/07/strcmp-implementation-in-c.html */ | |
| while (*s1 || *s2) | |
| { | |
| if (*s1 > *s2) | |
| return 1; | |
| if (*s1 < *s2) | |
| return -1; | |
| s1++; | |
| s2++; | |
| } | |
| return 0; | |
| } | |
| static ptrdiff_t _glewBsearchExtension(const char* name) | |
| { | |
| ptrdiff_t lo = 0, hi = sizeof(_glewExtensionLookup) / sizeof(char*) - 2; | |
| while (lo <= hi) | |
| { | |
| ptrdiff_t mid = (lo + hi) / 2; | |
| const int cmp = _glewExtensionCompare(name, _glewExtensionLookup[mid]); | |
| if (cmp < 0) hi = mid - 1; | |
| else if (cmp > 0) lo = mid + 1; | |
| else return mid; | |
| } | |
| return -1; | |
| } | |
| static GLboolean *_glewGetExtensionString(const char *name) | |
| { | |
| ptrdiff_t n = _glewBsearchExtension(name); | |
| if (n >= 0) return &_glewExtensionString[n]; | |
| return NULL; | |
| } | |
| static GLboolean *_glewGetExtensionEnable(const char *name) | |
| { | |
| ptrdiff_t n = _glewBsearchExtension(name); | |
| if (n >= 0) return _glewExtensionEnabled[n]; | |
| return NULL; | |
| } | |
| static const char *_glewNextSpace(const char *i) | |
| { | |
| const char *j = i; | |
| if (j) | |
| while (*j!=' ' && *j) ++j; | |
| return j; | |
| } | |
| static const char *_glewNextNonSpace(const char *i) | |
| { | |
| const char *j = i; | |
| if (j) | |
| while (*j==' ') ++j; | |
| return j; | |
| } | |
| GLboolean GLEWAPIENTRY glewGetExtension (const char* name) | |
| { | |
| GLboolean *enable = _glewGetExtensionString(name); | |
| if (enable) | |
| return *enable; | |
| return GL_FALSE; | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGPROC) (GLenum name); | |
| typedef void (GLAPIENTRY * PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params); | |
| static GLenum GLEWAPIENTRY glewContextInit () | |
| { | |
| PFNGLGETSTRINGPROC getString; | |
| const GLubyte* s; | |
| GLuint dot; | |
| GLint major, minor; | |
| size_t n; | |
| #ifdef _WIN32 | |
| getString = glGetString; | |
| #else | |
| getString = (PFNGLGETSTRINGPROC) glewGetProcAddress((const GLubyte*)"glGetString"); | |
| if (!getString) | |
| return GLEW_ERROR_NO_GL_VERSION; | |
| #endif | |
| /* query opengl version */ | |
| s = getString(GL_VERSION); | |
| dot = _glewStrCLen(s, '.'); | |
| if (dot == 0) | |
| return GLEW_ERROR_NO_GL_VERSION; | |
| major = s[dot-1]-'0'; | |
| minor = s[dot+1]-'0'; | |
| if (minor < 0 || minor > 9) | |
| minor = 0; | |
| if (major<0 || major>9) | |
| return GLEW_ERROR_NO_GL_VERSION; | |
| if (major == 1 && minor == 0) | |
| { | |
| return GLEW_ERROR_GL_VERSION_10_ONLY; | |
| } | |
| else | |
| { | |
| GLEW_VERSION_4_6 = ( major > 4 ) || ( major == 4 && minor >= 6 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_4_5 = GLEW_VERSION_4_6 == GL_TRUE || ( major == 4 && minor >= 5 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_4_4 = GLEW_VERSION_4_5 == GL_TRUE || ( major == 4 && minor >= 4 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_4_3 = GLEW_VERSION_4_4 == GL_TRUE || ( major == 4 && minor >= 3 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_4_2 = GLEW_VERSION_4_3 == GL_TRUE || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_4_1 = GLEW_VERSION_4_2 == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_4_0 = GLEW_VERSION_4_1 == GL_TRUE || ( major == 4 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_3_3 = GLEW_VERSION_4_0 == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_3_2 = GLEW_VERSION_3_3 == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_3_1 = GLEW_VERSION_3_2 == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_3_0 = GLEW_VERSION_3_1 == GL_TRUE || ( major == 3 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_2_1 = GLEW_VERSION_3_0 == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_2_0 = GLEW_VERSION_2_1 == GL_TRUE || ( major == 2 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_1_5 = GLEW_VERSION_2_0 == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_1_4 = GLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_1_3 = GLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_1_2_1 = GLEW_VERSION_1_3 == GL_TRUE ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_1_2 = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE; | |
| GLEW_VERSION_1_1 = GLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE; | |
| } | |
| for (n = 0; n < sizeof(_glewExtensionString) / sizeof(_glewExtensionString[0]); ++n) | |
| _glewExtensionString[n] = GL_FALSE; | |
| if (GLEW_VERSION_3_0) | |
| { | |
| GLint n = 0; | |
| GLint i; | |
| PFNGLGETINTEGERVPROC getIntegerv; | |
| PFNGLGETSTRINGIPROC getStringi; | |
| const char *ext; | |
| GLboolean *enable; | |
| #ifdef _WIN32 | |
| getIntegerv = glGetIntegerv; | |
| #else | |
| getIntegerv = (PFNGLGETINTEGERVPROC) glewGetProcAddress((const GLubyte*)"glGetIntegerv"); | |
| #endif | |
| if (getIntegerv) | |
| getIntegerv(GL_NUM_EXTENSIONS, &n); | |
| /* glGetStringi is OpenGL 3.0 */ | |
| getStringi = (PFNGLGETSTRINGIPROC) glewGetProcAddress((const GLubyte*)"glGetStringi"); | |
| if (getStringi) | |
| for (i = 0; i<n; ++i) | |
| { | |
| ext = (const char *) getStringi(GL_EXTENSIONS, i); | |
| /* Based on extension string(s), glewGetExtension purposes */ | |
| enable = _glewGetExtensionString(ext); | |
| if (enable) | |
| *enable = GL_TRUE; | |
| /* Based on extension string(s), experimental mode, glewIsSupported purposes */ | |
| enable = _glewGetExtensionEnable(ext); | |
| if (enable) | |
| *enable = GL_TRUE; | |
| } | |
| } | |
| else | |
| { | |
| const char *extensions; | |
| const char *end; | |
| const char *i; | |
| const char *j; | |
| char ext[128]; | |
| GLboolean *enable; | |
| extensions = (const char *) getString(GL_EXTENSIONS); | |
| if (extensions) | |
| { | |
| end = extensions + _glewStrLen((const GLubyte *) extensions); | |
| for (i=extensions; i<end; i = j + 1) | |
| { | |
| i = _glewNextNonSpace(i); | |
| j = _glewNextSpace(i); | |
| /* Copy extension into NUL terminated string */ | |
| if (j-i >= (ptrdiff_t) sizeof(ext)) | |
| continue; | |
| _glewStrCopy(ext, i, ' '); | |
| /* Based on extension string(s), glewGetExtension purposes */ | |
| enable = _glewGetExtensionString(ext); | |
| if (enable) | |
| *enable = GL_TRUE; | |
| /* Based on extension string(s), experimental mode, glewIsSupported purposes */ | |
| enable = _glewGetExtensionEnable(ext); | |
| if (enable) | |
| *enable = GL_TRUE; | |
| } | |
| } | |
| } | |
| #ifdef GL_VERSION_1_2 | |
| if (glewExperimental || GLEW_VERSION_1_2) GLEW_VERSION_1_2 = !_glewInit_GL_VERSION_1_2(); | |
| #endif /* GL_VERSION_1_2 */ | |
| #ifdef GL_VERSION_1_3 | |
| if (glewExperimental || GLEW_VERSION_1_3) GLEW_VERSION_1_3 = !_glewInit_GL_VERSION_1_3(); | |
| #endif /* GL_VERSION_1_3 */ | |
| #ifdef GL_VERSION_1_4 | |
| if (glewExperimental || GLEW_VERSION_1_4) GLEW_VERSION_1_4 = !_glewInit_GL_VERSION_1_4(); | |
| #endif /* GL_VERSION_1_4 */ | |
| #ifdef GL_VERSION_1_5 | |
| if (glewExperimental || GLEW_VERSION_1_5) GLEW_VERSION_1_5 = !_glewInit_GL_VERSION_1_5(); | |
| #endif /* GL_VERSION_1_5 */ | |
| #ifdef GL_VERSION_2_0 | |
| if (glewExperimental || GLEW_VERSION_2_0) GLEW_VERSION_2_0 = !_glewInit_GL_VERSION_2_0(); | |
| #endif /* GL_VERSION_2_0 */ | |
| #ifdef GL_VERSION_2_1 | |
| if (glewExperimental || GLEW_VERSION_2_1) GLEW_VERSION_2_1 = !_glewInit_GL_VERSION_2_1(); | |
| #endif /* GL_VERSION_2_1 */ | |
| #ifdef GL_VERSION_3_0 | |
| if (glewExperimental || GLEW_VERSION_3_0) GLEW_VERSION_3_0 = !_glewInit_GL_VERSION_3_0(); | |
| #endif /* GL_VERSION_3_0 */ | |
| #ifdef GL_VERSION_3_1 | |
| if (glewExperimental || GLEW_VERSION_3_1) GLEW_VERSION_3_1 = !_glewInit_GL_VERSION_3_1(); | |
| #endif /* GL_VERSION_3_1 */ | |
| #ifdef GL_VERSION_3_2 | |
| if (glewExperimental || GLEW_VERSION_3_2) GLEW_VERSION_3_2 = !_glewInit_GL_VERSION_3_2(); | |
| #endif /* GL_VERSION_3_2 */ | |
| #ifdef GL_VERSION_3_3 | |
| if (glewExperimental || GLEW_VERSION_3_3) GLEW_VERSION_3_3 = !_glewInit_GL_VERSION_3_3(); | |
| #endif /* GL_VERSION_3_3 */ | |
| #ifdef GL_VERSION_4_0 | |
| if (glewExperimental || GLEW_VERSION_4_0) GLEW_VERSION_4_0 = !_glewInit_GL_VERSION_4_0(); | |
| #endif /* GL_VERSION_4_0 */ | |
| #ifdef GL_VERSION_4_5 | |
| if (glewExperimental || GLEW_VERSION_4_5) GLEW_VERSION_4_5 = !_glewInit_GL_VERSION_4_5(); | |
| #endif /* GL_VERSION_4_5 */ | |
| #ifdef GL_VERSION_4_6 | |
| if (glewExperimental || GLEW_VERSION_4_6) GLEW_VERSION_4_6 = !_glewInit_GL_VERSION_4_6(); | |
| #endif /* GL_VERSION_4_6 */ | |
| #ifdef GL_ARB_copy_buffer | |
| if (glewExperimental || GLEW_ARB_copy_buffer) GLEW_ARB_copy_buffer = !_glewInit_GL_ARB_copy_buffer(); | |
| #endif /* GL_ARB_copy_buffer */ | |
| #ifdef GL_ARB_draw_elements_base_vertex | |
| if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) GLEW_ARB_draw_elements_base_vertex = !_glewInit_GL_ARB_draw_elements_base_vertex(); | |
| #endif /* GL_ARB_draw_elements_base_vertex */ | |
| #ifdef GL_ARB_framebuffer_object | |
| if (glewExperimental || GLEW_ARB_framebuffer_object) GLEW_ARB_framebuffer_object = !_glewInit_GL_ARB_framebuffer_object(); | |
| #endif /* GL_ARB_framebuffer_object */ | |
| #ifdef GL_ARB_map_buffer_range | |
| if (glewExperimental || GLEW_ARB_map_buffer_range) GLEW_ARB_map_buffer_range = !_glewInit_GL_ARB_map_buffer_range(); | |
| #endif /* GL_ARB_map_buffer_range */ | |
| #ifdef GL_ARB_provoking_vertex | |
| if (glewExperimental || GLEW_ARB_provoking_vertex) GLEW_ARB_provoking_vertex = !_glewInit_GL_ARB_provoking_vertex(); | |
| #endif /* GL_ARB_provoking_vertex */ | |
| #ifdef GL_ARB_sync | |
| if (glewExperimental || GLEW_ARB_sync) GLEW_ARB_sync = !_glewInit_GL_ARB_sync(); | |
| #endif /* GL_ARB_sync */ | |
| #ifdef GL_ARB_texture_multisample | |
| if (glewExperimental || GLEW_ARB_texture_multisample) GLEW_ARB_texture_multisample = !_glewInit_GL_ARB_texture_multisample(); | |
| #endif /* GL_ARB_texture_multisample */ | |
| #ifdef GL_ARB_uniform_buffer_object | |
| if (glewExperimental || GLEW_ARB_uniform_buffer_object) GLEW_ARB_uniform_buffer_object = !_glewInit_GL_ARB_uniform_buffer_object(); | |
| #endif /* GL_ARB_uniform_buffer_object */ | |
| #ifdef GL_ARB_vertex_array_object | |
| if (glewExperimental || GLEW_ARB_vertex_array_object) GLEW_ARB_vertex_array_object = !_glewInit_GL_ARB_vertex_array_object(); | |
| #endif /* GL_ARB_vertex_array_object */ | |
| #ifdef GL_KHR_debug | |
| if (glewExperimental || GLEW_KHR_debug) GLEW_KHR_debug = !_glewInit_GL_KHR_debug(); | |
| #endif /* GL_KHR_debug */ | |
| return GLEW_OK; | |
| } | |
| #if defined(GLEW_OSMESA) | |
| #elif defined(GLEW_EGL) | |
| PFNEGLCHOOSECONFIGPROC __eglewChooseConfig = NULL; | |
| PFNEGLCOPYBUFFERSPROC __eglewCopyBuffers = NULL; | |
| PFNEGLCREATECONTEXTPROC __eglewCreateContext = NULL; | |
| PFNEGLCREATEPBUFFERSURFACEPROC __eglewCreatePbufferSurface = NULL; | |
| PFNEGLCREATEPIXMAPSURFACEPROC __eglewCreatePixmapSurface = NULL; | |
| PFNEGLCREATEWINDOWSURFACEPROC __eglewCreateWindowSurface = NULL; | |
| PFNEGLDESTROYCONTEXTPROC __eglewDestroyContext = NULL; | |
| PFNEGLDESTROYSURFACEPROC __eglewDestroySurface = NULL; | |
| PFNEGLGETCONFIGATTRIBPROC __eglewGetConfigAttrib = NULL; | |
| PFNEGLGETCONFIGSPROC __eglewGetConfigs = NULL; | |
| PFNEGLGETCURRENTDISPLAYPROC __eglewGetCurrentDisplay = NULL; | |
| PFNEGLGETCURRENTSURFACEPROC __eglewGetCurrentSurface = NULL; | |
| PFNEGLGETDISPLAYPROC __eglewGetDisplay = NULL; | |
| PFNEGLGETERRORPROC __eglewGetError = NULL; | |
| PFNEGLINITIALIZEPROC __eglewInitialize = NULL; | |
| PFNEGLMAKECURRENTPROC __eglewMakeCurrent = NULL; | |
| PFNEGLQUERYCONTEXTPROC __eglewQueryContext = NULL; | |
| PFNEGLQUERYSTRINGPROC __eglewQueryString = NULL; | |
| PFNEGLQUERYSURFACEPROC __eglewQuerySurface = NULL; | |
| PFNEGLSWAPBUFFERSPROC __eglewSwapBuffers = NULL; | |
| PFNEGLTERMINATEPROC __eglewTerminate = NULL; | |
| PFNEGLWAITGLPROC __eglewWaitGL = NULL; | |
| PFNEGLWAITNATIVEPROC __eglewWaitNative = NULL; | |
| PFNEGLBINDTEXIMAGEPROC __eglewBindTexImage = NULL; | |
| PFNEGLRELEASETEXIMAGEPROC __eglewReleaseTexImage = NULL; | |
| PFNEGLSURFACEATTRIBPROC __eglewSurfaceAttrib = NULL; | |
| PFNEGLSWAPINTERVALPROC __eglewSwapInterval = NULL; | |
| PFNEGLBINDAPIPROC __eglewBindAPI = NULL; | |
| PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC __eglewCreatePbufferFromClientBuffer = NULL; | |
| PFNEGLQUERYAPIPROC __eglewQueryAPI = NULL; | |
| PFNEGLRELEASETHREADPROC __eglewReleaseThread = NULL; | |
| PFNEGLWAITCLIENTPROC __eglewWaitClient = NULL; | |
| PFNEGLGETCURRENTCONTEXTPROC __eglewGetCurrentContext = NULL; | |
| PFNEGLCLIENTWAITSYNCPROC __eglewClientWaitSync = NULL; | |
| PFNEGLCREATEIMAGEPROC __eglewCreateImage = NULL; | |
| PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC __eglewCreatePlatformPixmapSurface = NULL; | |
| PFNEGLCREATEPLATFORMWINDOWSURFACEPROC __eglewCreatePlatformWindowSurface = NULL; | |
| PFNEGLCREATESYNCPROC __eglewCreateSync = NULL; | |
| PFNEGLDESTROYIMAGEPROC __eglewDestroyImage = NULL; | |
| PFNEGLDESTROYSYNCPROC __eglewDestroySync = NULL; | |
| PFNEGLGETPLATFORMDISPLAYPROC __eglewGetPlatformDisplay = NULL; | |
| PFNEGLGETSYNCATTRIBPROC __eglewGetSyncAttrib = NULL; | |
| PFNEGLWAITSYNCPROC __eglewWaitSync = NULL; | |
| GLboolean __EGLEW_VERSION_1_0 = GL_FALSE; | |
| GLboolean __EGLEW_VERSION_1_1 = GL_FALSE; | |
| GLboolean __EGLEW_VERSION_1_2 = GL_FALSE; | |
| GLboolean __EGLEW_VERSION_1_3 = GL_FALSE; | |
| GLboolean __EGLEW_VERSION_1_4 = GL_FALSE; | |
| GLboolean __EGLEW_VERSION_1_5 = GL_FALSE; | |
| #ifdef EGL_VERSION_1_0 | |
| static GLboolean _glewInit_EGL_VERSION_1_0 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((eglChooseConfig = (PFNEGLCHOOSECONFIGPROC)glewGetProcAddress((const GLubyte*)"eglChooseConfig")) == NULL) || r; | |
| r = ((eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC)glewGetProcAddress((const GLubyte*)"eglCopyBuffers")) == NULL) || r; | |
| r = ((eglCreateContext = (PFNEGLCREATECONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglCreateContext")) == NULL) || r; | |
| r = ((eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePbufferSurface")) == NULL) || r; | |
| r = ((eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePixmapSurface")) == NULL) || r; | |
| r = ((eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreateWindowSurface")) == NULL) || r; | |
| r = ((eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglDestroyContext")) == NULL) || r; | |
| r = ((eglDestroySurface = (PFNEGLDESTROYSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglDestroySurface")) == NULL) || r; | |
| r = ((eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"eglGetConfigAttrib")) == NULL) || r; | |
| r = ((eglGetConfigs = (PFNEGLGETCONFIGSPROC)glewGetProcAddress((const GLubyte*)"eglGetConfigs")) == NULL) || r; | |
| r = ((eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"eglGetCurrentDisplay")) == NULL) || r; | |
| r = ((eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglGetCurrentSurface")) == NULL) || r; | |
| r = ((eglGetDisplay = (PFNEGLGETDISPLAYPROC)glewGetProcAddress((const GLubyte*)"eglGetDisplay")) == NULL) || r; | |
| r = ((eglGetError = (PFNEGLGETERRORPROC)glewGetProcAddress((const GLubyte*)"eglGetError")) == NULL) || r; | |
| r = ((eglInitialize = (PFNEGLINITIALIZEPROC)glewGetProcAddress((const GLubyte*)"eglInitialize")) == NULL) || r; | |
| r = ((eglMakeCurrent = (PFNEGLMAKECURRENTPROC)glewGetProcAddress((const GLubyte*)"eglMakeCurrent")) == NULL) || r; | |
| r = ((eglQueryContext = (PFNEGLQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryContext")) == NULL) || r; | |
| r = ((eglQueryString = (PFNEGLQUERYSTRINGPROC)glewGetProcAddress((const GLubyte*)"eglQueryString")) == NULL) || r; | |
| r = ((eglQuerySurface = (PFNEGLQUERYSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglQuerySurface")) == NULL) || r; | |
| r = ((eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC)glewGetProcAddress((const GLubyte*)"eglSwapBuffers")) == NULL) || r; | |
| r = ((eglTerminate = (PFNEGLTERMINATEPROC)glewGetProcAddress((const GLubyte*)"eglTerminate")) == NULL) || r; | |
| r = ((eglWaitGL = (PFNEGLWAITGLPROC)glewGetProcAddress((const GLubyte*)"eglWaitGL")) == NULL) || r; | |
| r = ((eglWaitNative = (PFNEGLWAITNATIVEPROC)glewGetProcAddress((const GLubyte*)"eglWaitNative")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* EGL_VERSION_1_0 */ | |
| #ifdef EGL_VERSION_1_1 | |
| static GLboolean _glewInit_EGL_VERSION_1_1 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglBindTexImage")) == NULL) || r; | |
| r = ((eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglReleaseTexImage")) == NULL) || r; | |
| r = ((eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC)glewGetProcAddress((const GLubyte*)"eglSurfaceAttrib")) == NULL) || r; | |
| r = ((eglSwapInterval = (PFNEGLSWAPINTERVALPROC)glewGetProcAddress((const GLubyte*)"eglSwapInterval")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* EGL_VERSION_1_1 */ | |
| #ifdef EGL_VERSION_1_2 | |
| static GLboolean _glewInit_EGL_VERSION_1_2 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((eglBindAPI = (PFNEGLBINDAPIPROC)glewGetProcAddress((const GLubyte*)"eglBindAPI")) == NULL) || r; | |
| r = ((eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)glewGetProcAddress((const GLubyte*)"eglCreatePbufferFromClientBuffer")) == NULL) || r; | |
| r = ((eglQueryAPI = (PFNEGLQUERYAPIPROC)glewGetProcAddress((const GLubyte*)"eglQueryAPI")) == NULL) || r; | |
| r = ((eglReleaseThread = (PFNEGLRELEASETHREADPROC)glewGetProcAddress((const GLubyte*)"eglReleaseThread")) == NULL) || r; | |
| r = ((eglWaitClient = (PFNEGLWAITCLIENTPROC)glewGetProcAddress((const GLubyte*)"eglWaitClient")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* EGL_VERSION_1_2 */ | |
| #ifdef EGL_VERSION_1_4 | |
| static GLboolean _glewInit_EGL_VERSION_1_4 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglGetCurrentContext")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* EGL_VERSION_1_4 */ | |
| #ifdef EGL_VERSION_1_5 | |
| static GLboolean _glewInit_EGL_VERSION_1_5 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"eglClientWaitSync")) == NULL) || r; | |
| r = ((eglCreateImage = (PFNEGLCREATEIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglCreateImage")) == NULL) || r; | |
| r = ((eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePlatformPixmapSurface")) == NULL) || r; | |
| r = ((eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePlatformWindowSurface")) == NULL) || r; | |
| r = ((eglCreateSync = (PFNEGLCREATESYNCPROC)glewGetProcAddress((const GLubyte*)"eglCreateSync")) == NULL) || r; | |
| r = ((eglDestroyImage = (PFNEGLDESTROYIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglDestroyImage")) == NULL) || r; | |
| r = ((eglDestroySync = (PFNEGLDESTROYSYNCPROC)glewGetProcAddress((const GLubyte*)"eglDestroySync")) == NULL) || r; | |
| r = ((eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC)glewGetProcAddress((const GLubyte*)"eglGetPlatformDisplay")) == NULL) || r; | |
| r = ((eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC)glewGetProcAddress((const GLubyte*)"eglGetSyncAttrib")) == NULL) || r; | |
| r = ((eglWaitSync = (PFNEGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"eglWaitSync")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* EGL_VERSION_1_5 */ | |
| /* ------------------------------------------------------------------------ */ | |
| GLboolean eglewGetExtension (const char* name) | |
| { | |
| const GLubyte* start; | |
| const GLubyte* end; | |
| start = (const GLubyte*) eglQueryString(eglGetCurrentDisplay(), EGL_EXTENSIONS); | |
| if (0 == start) return GL_FALSE; | |
| end = start + _glewStrLen(start); | |
| return _glewSearchExtension(name, start, end); | |
| } | |
| GLenum eglewInit (EGLDisplay display) | |
| { | |
| EGLint major, minor; | |
| const GLubyte* extStart; | |
| const GLubyte* extEnd; | |
| PFNEGLINITIALIZEPROC initialize = NULL; | |
| PFNEGLQUERYSTRINGPROC queryString = NULL; | |
| /* Load necessary entry points */ | |
| initialize = (PFNEGLINITIALIZEPROC) glewGetProcAddress("eglInitialize"); | |
| queryString = (PFNEGLQUERYSTRINGPROC) glewGetProcAddress("eglQueryString"); | |
| if (!initialize || !queryString) | |
| return 1; | |
| /* query EGK version */ | |
| if (initialize(display, &major, &minor) != EGL_TRUE) | |
| return 1; | |
| EGLEW_VERSION_1_5 = ( major > 1 ) || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE; | |
| EGLEW_VERSION_1_4 = EGLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE; | |
| EGLEW_VERSION_1_3 = EGLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE; | |
| EGLEW_VERSION_1_2 = EGLEW_VERSION_1_3 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE; | |
| EGLEW_VERSION_1_1 = EGLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE; | |
| EGLEW_VERSION_1_0 = EGLEW_VERSION_1_1 == GL_TRUE || ( major == 1 && minor >= 0 ) ? GL_TRUE : GL_FALSE; | |
| /* query EGL extension string */ | |
| extStart = (const GLubyte*) queryString(display, EGL_EXTENSIONS); | |
| if (extStart == 0) | |
| extStart = (const GLubyte *)""; | |
| extEnd = extStart + _glewStrLen(extStart); | |
| /* initialize extensions */ | |
| #ifdef EGL_VERSION_1_0 | |
| if (glewExperimental || EGLEW_VERSION_1_0) EGLEW_VERSION_1_0 = !_glewInit_EGL_VERSION_1_0(); | |
| #endif /* EGL_VERSION_1_0 */ | |
| #ifdef EGL_VERSION_1_1 | |
| if (glewExperimental || EGLEW_VERSION_1_1) EGLEW_VERSION_1_1 = !_glewInit_EGL_VERSION_1_1(); | |
| #endif /* EGL_VERSION_1_1 */ | |
| #ifdef EGL_VERSION_1_2 | |
| if (glewExperimental || EGLEW_VERSION_1_2) EGLEW_VERSION_1_2 = !_glewInit_EGL_VERSION_1_2(); | |
| #endif /* EGL_VERSION_1_2 */ | |
| #ifdef EGL_VERSION_1_4 | |
| if (glewExperimental || EGLEW_VERSION_1_4) EGLEW_VERSION_1_4 = !_glewInit_EGL_VERSION_1_4(); | |
| #endif /* EGL_VERSION_1_4 */ | |
| #ifdef EGL_VERSION_1_5 | |
| if (glewExperimental || EGLEW_VERSION_1_5) EGLEW_VERSION_1_5 = !_glewInit_EGL_VERSION_1_5(); | |
| #endif /* EGL_VERSION_1_5 */ | |
| return GLEW_OK; | |
| } | |
| #elif defined(_WIN32) | |
| /* ------------------------------------------------------------------------- */ | |
| static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL; | |
| static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL; | |
| GLboolean GLEWAPIENTRY wglewGetExtension (const char* name) | |
| { | |
| const GLubyte* start; | |
| const GLubyte* end; | |
| if (_wglewGetExtensionsStringARB == NULL) | |
| if (_wglewGetExtensionsStringEXT == NULL) | |
| return GL_FALSE; | |
| else | |
| start = (const GLubyte*)_wglewGetExtensionsStringEXT(); | |
| else | |
| start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); | |
| if (start == 0) | |
| return GL_FALSE; | |
| end = start + _glewStrLen(start); | |
| return _glewSearchExtension(name, start, end); | |
| } | |
| GLenum GLEWAPIENTRY wglewInit () | |
| { | |
| GLboolean crippled; | |
| const GLubyte* extStart; | |
| const GLubyte* extEnd; | |
| /* find wgl extension string query functions */ | |
| _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB"); | |
| _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT"); | |
| /* query wgl extension string */ | |
| if (_wglewGetExtensionsStringARB == NULL) | |
| if (_wglewGetExtensionsStringEXT == NULL) | |
| extStart = (const GLubyte*)""; | |
| else | |
| extStart = (const GLubyte*)_wglewGetExtensionsStringEXT(); | |
| else | |
| extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); | |
| extEnd = extStart + _glewStrLen(extStart); | |
| /* initialize extensions */ | |
| crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL; | |
| return GLEW_OK; | |
| } | |
| #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) | |
| PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL; | |
| PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL; | |
| PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL; | |
| PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL; | |
| PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL; | |
| PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL; | |
| PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL; | |
| PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL; | |
| PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL; | |
| PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL; | |
| PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL; | |
| PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL; | |
| PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL; | |
| PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL; | |
| PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL; | |
| PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL; | |
| PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL; | |
| PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL; | |
| GLboolean __GLXEW_VERSION_1_0 = GL_FALSE; | |
| GLboolean __GLXEW_VERSION_1_1 = GL_FALSE; | |
| GLboolean __GLXEW_VERSION_1_2 = GL_FALSE; | |
| GLboolean __GLXEW_VERSION_1_3 = GL_FALSE; | |
| GLboolean __GLXEW_VERSION_1_4 = GL_FALSE; | |
| GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE; | |
| #ifdef GLX_VERSION_1_2 | |
| static GLboolean _glewInit_GLX_VERSION_1_2 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GLX_VERSION_1_2 */ | |
| #ifdef GLX_VERSION_1_3 | |
| static GLboolean _glewInit_GLX_VERSION_1_3 () | |
| { | |
| GLboolean r = GL_FALSE; | |
| r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r; | |
| r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r; | |
| r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r; | |
| r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r; | |
| r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r; | |
| r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r; | |
| r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r; | |
| r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r; | |
| r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r; | |
| r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r; | |
| r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r; | |
| r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r; | |
| r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r; | |
| r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r; | |
| r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r; | |
| r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r; | |
| r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r; | |
| return r; | |
| } | |
| #endif /* GLX_VERSION_1_3 */ | |
| /* ------------------------------------------------------------------------ */ | |
| GLboolean glxewGetExtension (const char* name) | |
| { | |
| const GLubyte* start; | |
| const GLubyte* end; | |
| if (glXGetCurrentDisplay == NULL) return GL_FALSE; | |
| start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); | |
| if (0 == start) return GL_FALSE; | |
| end = start + _glewStrLen(start); | |
| return _glewSearchExtension(name, start, end); | |
| } | |
| GLenum glxewInit () | |
| { | |
| Display* display; | |
| int major, minor; | |
| const GLubyte* extStart; | |
| const GLubyte* extEnd; | |
| /* initialize core GLX 1.2 */ | |
| if (_glewInit_GLX_VERSION_1_2()) return GLEW_ERROR_GLX_VERSION_11_ONLY; | |
| /* check for a display */ | |
| display = glXGetCurrentDisplay(); | |
| if (display == NULL) return GLEW_ERROR_NO_GLX_DISPLAY; | |
| /* initialize flags */ | |
| GLXEW_VERSION_1_0 = GL_TRUE; | |
| GLXEW_VERSION_1_1 = GL_TRUE; | |
| GLXEW_VERSION_1_2 = GL_TRUE; | |
| GLXEW_VERSION_1_3 = GL_TRUE; | |
| GLXEW_VERSION_1_4 = GL_TRUE; | |
| /* query GLX version */ | |
| glXQueryVersion(display, &major, &minor); | |
| if (major == 1 && minor <= 3) | |
| { | |
| switch (minor) | |
| { | |
| case 3: | |
| GLXEW_VERSION_1_4 = GL_FALSE; | |
| break; | |
| case 2: | |
| GLXEW_VERSION_1_4 = GL_FALSE; | |
| GLXEW_VERSION_1_3 = GL_FALSE; | |
| break; | |
| default: | |
| return GLEW_ERROR_GLX_VERSION_11_ONLY; | |
| break; | |
| } | |
| } | |
| /* query GLX extension string */ | |
| extStart = 0; | |
| if (glXGetCurrentDisplay != NULL) | |
| extStart = (const GLubyte*)glXGetClientString(display, GLX_EXTENSIONS); | |
| if (extStart == 0) | |
| extStart = (const GLubyte *)""; | |
| extEnd = extStart + _glewStrLen(extStart); | |
| /* initialize extensions */ | |
| #ifdef GLX_VERSION_1_3 | |
| if (glewExperimental || GLXEW_VERSION_1_3) GLXEW_VERSION_1_3 = !_glewInit_GLX_VERSION_1_3(); | |
| #endif /* GLX_VERSION_1_3 */ | |
| #ifdef GLX_ARB_get_proc_address | |
| GLXEW_ARB_get_proc_address = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd); | |
| #endif /* GLX_ARB_get_proc_address */ | |
| return GLEW_OK; | |
| } | |
| #endif /* !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) */ | |
| /* ------------------------------------------------------------------------ */ | |
| const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error) | |
| { | |
| static const GLubyte* _glewErrorString[] = | |
| { | |
| (const GLubyte*)"No error", | |
| (const GLubyte*)"Missing GL version", | |
| (const GLubyte*)"GL 1.1 and up are not supported", | |
| (const GLubyte*)"GLX 1.2 and up are not supported", | |
| (const GLubyte*)"Unknown error" | |
| }; | |
| const size_t max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1; | |
| return _glewErrorString[(size_t)error > max_error ? max_error : (size_t)error]; | |
| } | |
| const GLubyte * GLEWAPIENTRY glewGetString (GLenum name) | |
| { | |
| static const GLubyte* _glewString[] = | |
| { | |
| (const GLubyte*)NULL, | |
| (const GLubyte*)"2.2.0", | |
| (const GLubyte*)"2", | |
| (const GLubyte*)"2", | |
| (const GLubyte*)"0" | |
| }; | |
| const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; | |
| return _glewString[(size_t)name > max_string ? 0 : (size_t)name]; | |
| } | |
| /* ------------------------------------------------------------------------ */ | |
| GLboolean glewExperimental = GL_FALSE; | |
| GLenum GLEWAPIENTRY glewInit (void) | |
| { | |
| GLenum r; | |
| #if defined(GLEW_EGL) | |
| PFNEGLGETCURRENTDISPLAYPROC getCurrentDisplay = NULL; | |
| #endif | |
| r = glewContextInit(); | |
| if ( r != 0 ) return r; | |
| #if defined(GLEW_EGL) | |
| getCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) glewGetProcAddress("eglGetCurrentDisplay"); | |
| return eglewInit(getCurrentDisplay()); | |
| #elif defined(GLEW_OSMESA) || defined(__ANDROID__) || defined(__native_client__) || defined(__HAIKU__) | |
| return r; | |
| #elif defined(_WIN32) | |
| return wglewInit(); | |
| #elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */ | |
| return glxewInit(); | |
| #else | |
| return r; | |
| #endif /* _WIN32 */ | |
| } | |
| #if defined(_WIN32) && defined(GLEW_BUILD) && defined(__GNUC__) | |
| /* GCC requires a DLL entry point even without any standard library included. */ | |
| /* Types extracted from windows.h to avoid polluting the rest of the file. */ | |
| int __stdcall DllMainCRTStartup(void* instance, unsigned reason, void* reserved) | |
| { | |
| (void) instance; | |
| (void) reason; | |
| (void) reserved; | |
| return 1; | |
| } | |
| #endif | |
| GLboolean GLEWAPIENTRY glewIsSupported (const char* name) | |
| { | |
| const GLubyte* pos = (const GLubyte*)name; | |
| GLuint len = _glewStrLen(pos); | |
| GLboolean ret = GL_TRUE; | |
| while (ret && len > 0) | |
| { | |
| if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3)) | |
| { | |
| if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) | |
| { | |
| #ifdef GL_VERSION_1_2 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) | |
| { | |
| ret = GLEW_VERSION_1_2; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_1_2_1 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5)) | |
| { | |
| ret = GLEW_VERSION_1_2_1; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_1_3 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) | |
| { | |
| ret = GLEW_VERSION_1_3; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_1_4 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) | |
| { | |
| ret = GLEW_VERSION_1_4; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_1_5 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3)) | |
| { | |
| ret = GLEW_VERSION_1_5; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_2_0 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3)) | |
| { | |
| ret = GLEW_VERSION_2_0; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_2_1 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3)) | |
| { | |
| ret = GLEW_VERSION_2_1; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_3_0 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3)) | |
| { | |
| ret = GLEW_VERSION_3_0; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_3_1 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3)) | |
| { | |
| ret = GLEW_VERSION_3_1; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_3_2 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3)) | |
| { | |
| ret = GLEW_VERSION_3_2; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_3_3 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3)) | |
| { | |
| ret = GLEW_VERSION_3_3; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_0 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3)) | |
| { | |
| ret = GLEW_VERSION_4_0; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_1 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3)) | |
| { | |
| ret = GLEW_VERSION_4_1; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_2 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3)) | |
| { | |
| ret = GLEW_VERSION_4_2; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_3 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_3", 3)) | |
| { | |
| ret = GLEW_VERSION_4_3; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_4 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_4", 3)) | |
| { | |
| ret = GLEW_VERSION_4_4; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_5 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_5", 3)) | |
| { | |
| ret = GLEW_VERSION_4_5; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_VERSION_4_6 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_6", 3)) | |
| { | |
| ret = GLEW_VERSION_4_6; | |
| continue; | |
| } | |
| #endif | |
| } | |
| if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) | |
| { | |
| #ifdef GL_ARB_copy_buffer | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11)) | |
| { | |
| ret = GLEW_ARB_copy_buffer; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_draw_elements_base_vertex | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25)) | |
| { | |
| ret = GLEW_ARB_draw_elements_base_vertex; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_framebuffer_object | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) | |
| { | |
| ret = GLEW_ARB_framebuffer_object; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_map_buffer_range | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16)) | |
| { | |
| ret = GLEW_ARB_map_buffer_range; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_provoking_vertex | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16)) | |
| { | |
| ret = GLEW_ARB_provoking_vertex; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_sync | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4)) | |
| { | |
| ret = GLEW_ARB_sync; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_texture_multisample | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19)) | |
| { | |
| ret = GLEW_ARB_texture_multisample; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_uniform_buffer_object | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21)) | |
| { | |
| ret = GLEW_ARB_uniform_buffer_object; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GL_ARB_vertex_array_object | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) | |
| { | |
| ret = GLEW_ARB_vertex_array_object; | |
| continue; | |
| } | |
| #endif | |
| } | |
| if (_glewStrSame2(&pos, &len, (const GLubyte*)"KHR_", 4)) | |
| { | |
| #ifdef GL_KHR_debug | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug", 5)) | |
| { | |
| ret = GLEW_KHR_debug; | |
| continue; | |
| } | |
| #endif | |
| } | |
| } | |
| ret = (len == 0); | |
| } | |
| return ret; | |
| } | |
| #if defined(_WIN32) && !defined(GLEW_EGL) && !defined(GLEW_OSMESA) | |
| GLboolean GLEWAPIENTRY wglewIsSupported (const char* name) | |
| { | |
| const GLubyte* pos = (const GLubyte*)name; | |
| GLuint len = _glewStrLen(pos); | |
| GLboolean ret = GL_TRUE; | |
| while (ret && len > 0) | |
| { | |
| if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4)) | |
| { | |
| } | |
| ret = (len == 0); | |
| } | |
| return ret; | |
| } | |
| #elif !defined(GLEW_OSMESA) && !defined(GLEW_EGL) && !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX) | |
| GLboolean glxewIsSupported (const char* name) | |
| { | |
| const GLubyte* pos = (const GLubyte*)name; | |
| GLuint len = _glewStrLen(pos); | |
| GLboolean ret = GL_TRUE; | |
| while (ret && len > 0) | |
| { | |
| if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4)) | |
| { | |
| if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) | |
| { | |
| #ifdef GLX_VERSION_1_2 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) | |
| { | |
| ret = GLXEW_VERSION_1_2; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GLX_VERSION_1_3 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) | |
| { | |
| ret = GLXEW_VERSION_1_3; | |
| continue; | |
| } | |
| #endif | |
| #ifdef GLX_VERSION_1_4 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) | |
| { | |
| ret = GLXEW_VERSION_1_4; | |
| continue; | |
| } | |
| #endif | |
| } | |
| if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) | |
| { | |
| #ifdef GLX_ARB_get_proc_address | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16)) | |
| { | |
| ret = GLXEW_ARB_get_proc_address; | |
| continue; | |
| } | |
| #endif | |
| } | |
| } | |
| ret = (len == 0); | |
| } | |
| return ret; | |
| } | |
| #elif defined(GLEW_EGL) | |
| GLboolean eglewIsSupported (const char* name) | |
| { | |
| const GLubyte* pos = (const GLubyte*)name; | |
| GLuint len = _glewStrLen(pos); | |
| GLboolean ret = GL_TRUE; | |
| while (ret && len > 0) | |
| { | |
| if(_glewStrSame1(&pos, &len, (const GLubyte*)"EGL_", 4)) | |
| { | |
| if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) | |
| { | |
| #ifdef EGL_VERSION_1_0 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_0", 3)) | |
| { | |
| ret = EGLEW_VERSION_1_0; | |
| continue; | |
| } | |
| #endif | |
| #ifdef EGL_VERSION_1_1 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_1", 3)) | |
| { | |
| ret = EGLEW_VERSION_1_1; | |
| continue; | |
| } | |
| #endif | |
| #ifdef EGL_VERSION_1_2 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) | |
| { | |
| ret = EGLEW_VERSION_1_2; | |
| continue; | |
| } | |
| #endif | |
| #ifdef EGL_VERSION_1_3 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) | |
| { | |
| ret = EGLEW_VERSION_1_3; | |
| continue; | |
| } | |
| #endif | |
| #ifdef EGL_VERSION_1_4 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) | |
| { | |
| ret = EGLEW_VERSION_1_4; | |
| continue; | |
| } | |
| #endif | |
| #ifdef EGL_VERSION_1_5 | |
| if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3)) | |
| { | |
| ret = EGLEW_VERSION_1_5; | |
| continue; | |
| } | |
| #endif | |
| } | |
| } | |
| ret = (len == 0); | |
| } | |
| return ret; | |
| } | |
| #endif /* _WIN32 */ |