Subversion Repositories gelsvn

Rev

Rev 599 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
599 jab 1
/*
2
** The OpenGL Extension Wrangler Library
3
** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
4
** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
5
** Copyright (C) 2002, Lev Povalahev
6
** All rights reserved.
7
** 
8
** Redistribution and use in source and binary forms, with or without 
9
** modification, are permitted provided that the following conditions are met:
10
** 
11
** * Redistributions of source code must retain the above copyright notice, 
12
**   this list of conditions and the following disclaimer.
13
** * Redistributions in binary form must reproduce the above copyright notice, 
14
**   this list of conditions and the following disclaimer in the documentation 
15
**   and/or other materials provided with the distribution.
16
** * The name of the author may be used to endorse or promote products 
17
**   derived from this software without specific prior written permission.
18
**
19
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
20
** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
21
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
23
** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
24
** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
25
** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26
** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27
** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28
** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
29
** THE POSSIBILITY OF SUCH DAMAGE.
30
*/
31
 
601 jab 32
#include "../GL/glew.h"
599 jab 33
 
34
#if defined(_WIN32)
601 jab 35
#  include "../GL/wglew.h"
599 jab 36
#elif !defined(__ANDROID__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))
601 jab 37
#  include "../GL/glxew.h"
599 jab 38
#endif
39
 
40
/*
41
 * Define glewGetContext and related helper macros.
42
 */
43
#ifdef GLEW_MX
44
#  define glewGetContext() ctx
45
#  ifdef _WIN32
46
#    define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx
47
#    define GLEW_CONTEXT_ARG_VAR_INIT ctx
48
#    define wglewGetContext() ctx
49
#    define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx
50
#    define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx
51
#  else /* _WIN32 */
52
#    define GLEW_CONTEXT_ARG_DEF_INIT void
53
#    define GLEW_CONTEXT_ARG_VAR_INIT
54
#    define glxewGetContext() ctx
55
#    define GLXEW_CONTEXT_ARG_DEF_INIT void
56
#    define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx
57
#  endif /* _WIN32 */
58
#  define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx
59
#else /* GLEW_MX */
60
#  define GLEW_CONTEXT_ARG_DEF_INIT void
61
#  define GLEW_CONTEXT_ARG_VAR_INIT
62
#  define GLEW_CONTEXT_ARG_DEF_LIST void
63
#  define WGLEW_CONTEXT_ARG_DEF_INIT void
64
#  define WGLEW_CONTEXT_ARG_DEF_LIST void
65
#  define GLXEW_CONTEXT_ARG_DEF_INIT void
66
#  define GLXEW_CONTEXT_ARG_DEF_LIST void
67
#endif /* GLEW_MX */
68
 
69
#if defined(__sgi) || defined (__sun) || defined(GLEW_APPLE_GLX)
70
#include <dlfcn.h>
71
#include <stdio.h>
72
#include <stdlib.h>
73
 
74
void* dlGetProcAddress (const GLubyte* name)
75
{
76
  static void* h = NULL;
77
  static void* gpa;
78
 
79
  if (h == NULL)
80
  {
81
    if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;
82
    gpa = dlsym(h, "glXGetProcAddress");
83
  }
84
 
85
  if (gpa != NULL)
86
    return ((void*(*)(const GLubyte*))gpa)(name);
87
  else
88
    return dlsym(h, (const char*)name);
89
}
90
#endif /* __sgi || __sun || GLEW_APPLE_GLX */
91
 
92
#if defined(__APPLE__)
93
#include <stdlib.h>
94
#include <string.h>
95
#include <AvailabilityMacros.h>
96
 
97
#ifdef MAC_OS_X_VERSION_10_3
98
 
99
#include <dlfcn.h>
100
 
101
void* NSGLGetProcAddress (const GLubyte *name)
102
{
103
  static void* image = NULL;
104
  void* addr;
105
  if (NULL == image) 
106
  {
107
#ifdef GLEW_REGAL
108
    image = dlopen("libRegal.dylib", RTLD_LAZY);
109
#else
110
    image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
111
#endif
112
  }
113
  if( !image ) return NULL;
114
  addr = dlsym(image, (const char*)name);
115
  if( addr ) return addr;
116
#ifdef GLEW_APPLE_GLX
117
  return dlGetProcAddress( name ); // try next for glx symbols
118
#else
119
  return NULL;
120
#endif
121
}
122
#else
123
 
124
#include <mach-o/dyld.h>
125
 
126
void* NSGLGetProcAddress (const GLubyte *name)
127
{
128
  static const struct mach_header* image = NULL;
129
  NSSymbol symbol;
130
  char* symbolName;
131
  if (NULL == image)
132
  {
133
#ifdef GLEW_REGAL
134
    image = NSAddImage("libRegal.dylib", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
135
#else
136
    image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
137
#endif
138
  }
139
  /* prepend a '_' for the Unix C symbol mangling convention */
140
  symbolName = malloc(strlen((const char*)name) + 2);
141
  strcpy(symbolName+1, (const char*)name);
142
  symbolName[0] = '_';
143
  symbol = NULL;
144
  /* if (NSIsSymbolNameDefined(symbolName))
145
	 symbol = NSLookupAndBindSymbol(symbolName); */
146
  symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL;
147
  free(symbolName);
148
  if( symbol ) return NSAddressOfSymbol(symbol);
149
#ifdef GLEW_APPLE_GLX
150
  return dlGetProcAddress( name ); // try next for glx symbols
151
#else
152
  return NULL;
153
#endif
154
}
155
#endif /* MAC_OS_X_VERSION_10_3 */
156
#endif /* __APPLE__ */
157
 
158
/*
159
 * Define glewGetProcAddress.
160
 */
161
#if defined(_WIN32)
162
#  define glewGetProcAddress(name) wglGetProcAddress((LPCSTR)name)
163
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
164
#  define glewGetProcAddress(name) NSGLGetProcAddress(name)
165
#elif defined(__sgi) || defined(__sun)
166
#  define glewGetProcAddress(name) dlGetProcAddress(name)
167
#elif defined(__ANDROID__)
168
#  define glewGetProcAddress(name) NULL /* TODO */
169
#else /* __linux */
170
#  define glewGetProcAddress(name) (*glXGetProcAddressARB)(name)
171
#endif
172
 
173
/*
174
 * Define GLboolean const cast.
175
 */
176
#define CONST_CAST(x) (*(GLboolean*)&x)
177
 
178
/*
179
 * GLEW, just like OpenGL or GLU, does not rely on the standard C library.
180
 * These functions implement the functionality required in this file.
181
 */
182
static GLuint _glewStrLen (const GLubyte* s)
183
{
184
  GLuint i=0;
185
  if (s == NULL) return 0;
186
  while (s[i] != '\0') i++;
187
  return i;
188
}
189
 
190
static GLuint _glewStrCLen (const GLubyte* s, GLubyte c)
191
{
192
  GLuint i=0;
193
  if (s == NULL) return 0;
194
  while (s[i] != '\0' && s[i] != c) i++;
195
  return (s[i] == '\0' || s[i] == c) ? i : 0;
196
}
197
 
198
static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n)
199
{
200
  GLuint i=0;
201
  if(a == NULL || b == NULL)
202
    return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE;
203
  while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++;
204
  return i == n ? GL_TRUE : GL_FALSE;
205
}
206
 
207
static GLboolean _glewStrSame1 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
208
{
209
  while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t'))
210
  {
211
    (*a)++;
212
    (*na)--;
213
  }
214
  if(*na >= nb)
215
  {
216
    GLuint i=0;
217
    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
218
    if(i == nb)
219
    {
220
      *a = *a + nb;
221
      *na = *na - nb;
222
      return GL_TRUE;
223
    }
224
  }
225
  return GL_FALSE;
226
}
227
 
228
static GLboolean _glewStrSame2 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
229
{
230
  if(*na >= nb)
231
  {
232
    GLuint i=0;
233
    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
234
    if(i == nb)
235
    {
236
      *a = *a + nb;
237
      *na = *na - nb;
238
      return GL_TRUE;
239
    }
240
  }
241
  return GL_FALSE;
242
}
243
 
244
static GLboolean _glewStrSame3 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
245
{
246
  if(*na >= nb)
247
  {
248
    GLuint i=0;
249
    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
250
    if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t'))
251
    {
252
      *a = *a + nb;
253
      *na = *na - nb;
254
      return GL_TRUE;
255
    }
256
  }
257
  return GL_FALSE;
258
}
259
 
260
/*
261
 * Search for name in the extensions string. Use of strstr()
262
 * is not sufficient because extension names can be prefixes of
263
 * other extension names. Could use strtok() but the constant
264
 * string returned by glGetString might be in read-only memory.
265
 */
266
static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end)
267
{
268
  const GLubyte* p;
269
  GLuint len = _glewStrLen((const GLubyte*)name);
270
  p = start;
271
  while (p < end)
272
  {
273
    GLuint n = _glewStrCLen(p, ' ');
274
    if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE;
275
    p += n+1;
276
  }
277
  return GL_FALSE;
278
}
279
 
280
#if !defined(_WIN32) || !defined(GLEW_MX)
281
 
282
PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;
283
PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;
284
PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;
285
PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;
286
 
287
PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;
288
PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;
289
PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;
290
PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;
291
PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;
292
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;
293
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;
294
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;
295
PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;
296
PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;
297
PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;
298
PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;
299
PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;
300
PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;
301
PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;
302
PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;
303
PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;
304
PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;
305
PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;
306
PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;
307
PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;
308
PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;
309
PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;
310
PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;
311
PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;
312
PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;
313
PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;
314
PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;
315
PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;
316
PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;
317
PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;
318
PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;
319
PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;
320
PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;
321
PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;
322
PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;
323
PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;
324
PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;
325
PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;
326
PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;
327
PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;
328
PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;
329
PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;
330
PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;
331
PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;
332
PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;
333
 
334
PFNGLBLENDCOLORPROC __glewBlendColor = NULL;
335
PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;
336
PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;
337
PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;
338
PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;
339
PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;
340
PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;
341
PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;
342
PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;
343
PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;
344
PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;
345
PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;
346
PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL;
347
PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL;
348
PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;
349
PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;
350
PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;
351
PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;
352
PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;
353
PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;
354
PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;
355
PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;
356
PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;
357
PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;
358
PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;
359
PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;
360
PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;
361
PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;
362
PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;
363
PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;
364
PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;
365
PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;
366
PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;
367
PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;
368
PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;
369
PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;
370
PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;
371
PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;
372
PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;
373
PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;
374
PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;
375
PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;
376
PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;
377
PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;
378
PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;
379
PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;
380
PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;
381
 
382
PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;
383
PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;
384
PFNGLBUFFERDATAPROC __glewBufferData = NULL;
385
PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;
386
PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;
387
PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;
388
PFNGLENDQUERYPROC __glewEndQuery = NULL;
389
PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;
390
PFNGLGENQUERIESPROC __glewGenQueries = NULL;
391
PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;
392
PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;
393
PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;
394
PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;
395
PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;
396
PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;
397
PFNGLISBUFFERPROC __glewIsBuffer = NULL;
398
PFNGLISQUERYPROC __glewIsQuery = NULL;
399
PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;
400
PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;
401
 
402
PFNGLATTACHSHADERPROC __glewAttachShader = NULL;
403
PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;
404
PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;
405
PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;
406
PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;
407
PFNGLCREATESHADERPROC __glewCreateShader = NULL;
408
PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;
409
PFNGLDELETESHADERPROC __glewDeleteShader = NULL;
410
PFNGLDETACHSHADERPROC __glewDetachShader = NULL;
411
PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;
412
PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;
413
PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;
414
PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;
415
PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;
416
PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;
417
PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;
418
PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;
419
PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;
420
PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;
421
PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;
422
PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;
423
PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;
424
PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;
425
PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;
426
PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;
427
PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;
428
PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;
429
PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;
430
PFNGLISPROGRAMPROC __glewIsProgram = NULL;
431
PFNGLISSHADERPROC __glewIsShader = NULL;
432
PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;
433
PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;
434
PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;
435
PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;
436
PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;
437
PFNGLUNIFORM1FPROC __glewUniform1f = NULL;
438
PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;
439
PFNGLUNIFORM1IPROC __glewUniform1i = NULL;
440
PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;
441
PFNGLUNIFORM2FPROC __glewUniform2f = NULL;
442
PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;
443
PFNGLUNIFORM2IPROC __glewUniform2i = NULL;
444
PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;
445
PFNGLUNIFORM3FPROC __glewUniform3f = NULL;
446
PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;
447
PFNGLUNIFORM3IPROC __glewUniform3i = NULL;
448
PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;
449
PFNGLUNIFORM4FPROC __glewUniform4f = NULL;
450
PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;
451
PFNGLUNIFORM4IPROC __glewUniform4i = NULL;
452
PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;
453
PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;
454
PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;
455
PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;
456
PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;
457
PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;
458
PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;
459
PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;
460
PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;
461
PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;
462
PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;
463
PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;
464
PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;
465
PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;
466
PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;
467
PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;
468
PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;
469
PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;
470
PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;
471
PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;
472
PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;
473
PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;
474
PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;
475
PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;
476
PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;
477
PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;
478
PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;
479
PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;
480
PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;
481
PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;
482
PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;
483
PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;
484
PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;
485
PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;
486
PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;
487
PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;
488
PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;
489
PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;
490
PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;
491
PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;
492
PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;
493
PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;
494
PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;
495
 
496
PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;
497
PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;
498
PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;
499
PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;
500
PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;
501
PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;
502
 
503
PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL;
504
PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL;
505
PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL;
506
PFNGLCLAMPCOLORPROC __glewClampColor = NULL;
507
PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL;
508
PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL;
509
PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL;
510
PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL;
511
PFNGLCOLORMASKIPROC __glewColorMaski = NULL;
512
PFNGLDISABLEIPROC __glewDisablei = NULL;
513
PFNGLENABLEIPROC __glewEnablei = NULL;
514
PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL;
515
PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL;
516
PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL;
517
PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL;
518
PFNGLGETSTRINGIPROC __glewGetStringi = NULL;
519
PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL;
520
PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL;
521
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL;
522
PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL;
523
PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL;
524
PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL;
525
PFNGLISENABLEDIPROC __glewIsEnabledi = NULL;
526
PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL;
527
PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL;
528
PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL;
529
PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL;
530
PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL;
531
PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL;
532
PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL;
533
PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL;
534
PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL;
535
PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL;
536
PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL;
537
PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL;
538
PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL;
539
PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL;
540
PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL;
541
PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL;
542
PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL;
543
PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL;
544
PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL;
545
PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL;
546
PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL;
547
PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL;
548
PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL;
549
PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL;
550
PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL;
551
PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL;
552
PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL;
553
PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL;
554
PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL;
555
PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL;
556
PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL;
557
PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL;
558
 
559
PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL;
560
PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL;
561
PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL;
562
PFNGLTEXBUFFERPROC __glewTexBuffer = NULL;
563
 
564
PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL;
565
PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL;
566
PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL;
567
 
568
PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL;
569
 
570
PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL;
571
PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL;
572
PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL;
573
PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL;
574
PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL;
575
 
576
PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;
577
 
578
PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL;
579
PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD = NULL;
580
PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD = NULL;
581
PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD = NULL;
582
 
583
PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL;
584
PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL;
585
PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL;
586
PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL;
587
 
588
PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL;
589
PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD = NULL;
590
 
591
PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD = NULL;
592
PFNGLGENNAMESAMDPROC __glewGenNamesAMD = NULL;
593
PFNGLISNAMEAMDPROC __glewIsNameAMD = NULL;
594
 
595
PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL;
596
PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL;
597
PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL;
598
PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL;
599
PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL;
600
PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL;
601
PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL;
602
PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL;
603
PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL;
604
PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL;
605
PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL;
606
 
607
PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD = NULL;
608
 
609
PFNGLSTENCILOPVALUEAMDPROC __glewStencilOpValueAMD = NULL;
610
 
611
PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL;
612
PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL;
613
 
614
PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;
615
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;
616
PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;
617
PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;
618
PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;
619
 
620
PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;
621
PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;
622
PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;
623
PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;
624
PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;
625
PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;
626
PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;
627
PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;
628
 
629
PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;
630
PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;
631
 
632
PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL;
633
PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL;
634
PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL;
635
 
636
PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;
637
PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;
638
 
639
PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;
640
PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;
641
PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;
642
PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;
643
 
644
PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;
645
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;
646
PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;
647
 
648
PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL;
649
PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL;
650
PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL;
651
PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL;
652
PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL;
653
PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL;
654
PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL;
655
 
656
PFNGLCLEARDEPTHFPROC __glewClearDepthf = NULL;
657
PFNGLDEPTHRANGEFPROC __glewDepthRangef = NULL;
658
PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat = NULL;
659
PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler = NULL;
660
PFNGLSHADERBINARYPROC __glewShaderBinary = NULL;
661
 
662
PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance = NULL;
663
PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance = NULL;
664
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance = NULL;
665
 
666
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL;
667
PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL;
668
 
669
PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL;
670
 
671
PFNGLCLEARBUFFERDATAPROC __glewClearBufferData = NULL;
672
PFNGLCLEARBUFFERSUBDATAPROC __glewClearBufferSubData = NULL;
673
PFNGLCLEARNAMEDBUFFERDATAEXTPROC __glewClearNamedBufferDataEXT = NULL;
674
PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC __glewClearNamedBufferSubDataEXT = NULL;
675
 
676
PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;
677
 
678
PFNGLDISPATCHCOMPUTEPROC __glewDispatchCompute = NULL;
679
PFNGLDISPATCHCOMPUTEINDIRECTPROC __glewDispatchComputeIndirect = NULL;
680
 
681
PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL;
682
 
683
PFNGLCOPYIMAGESUBDATAPROC __glewCopyImageSubData = NULL;
684
 
685
PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB = NULL;
686
PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB = NULL;
687
PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB = NULL;
688
PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB = NULL;
689
 
690
PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;
691
 
692
PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL;
693
PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL;
694
PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL;
695
PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL;
696
 
697
PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL;
698
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL;
699
PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL;
700
PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL;
701
 
702
PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL;
703
PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL;
704
 
705
PFNGLFRAMEBUFFERPARAMETERIPROC __glewFramebufferParameteri = NULL;
706
PFNGLGETFRAMEBUFFERPARAMETERIVPROC __glewGetFramebufferParameteriv = NULL;
707
PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC __glewGetNamedFramebufferParameterivEXT = NULL;
708
PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC __glewNamedFramebufferParameteriEXT = NULL;
709
 
710
PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL;
711
PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL;
712
PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL;
713
PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL;
714
PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL;
715
PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL;
716
PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL;
717
PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL;
718
PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL;
719
PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL;
720
PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL;
721
PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL;
722
PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL;
723
PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL;
724
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL;
725
PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL;
726
PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL;
727
PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL;
728
PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL;
729
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL;
730
 
731
PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL;
732
PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL;
733
PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL;
734
PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL;
735
 
736
PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary = NULL;
737
PFNGLPROGRAMBINARYPROC __glewProgramBinary = NULL;
738
PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri = NULL;
739
 
740
PFNGLGETUNIFORMDVPROC __glewGetUniformdv = NULL;
741
PFNGLUNIFORM1DPROC __glewUniform1d = NULL;
742
PFNGLUNIFORM1DVPROC __glewUniform1dv = NULL;
743
PFNGLUNIFORM2DPROC __glewUniform2d = NULL;
744
PFNGLUNIFORM2DVPROC __glewUniform2dv = NULL;
745
PFNGLUNIFORM3DPROC __glewUniform3d = NULL;
746
PFNGLUNIFORM3DVPROC __glewUniform3dv = NULL;
747
PFNGLUNIFORM4DPROC __glewUniform4d = NULL;
748
PFNGLUNIFORM4DVPROC __glewUniform4dv = NULL;
749
PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv = NULL;
750
PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv = NULL;
751
PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv = NULL;
752
PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv = NULL;
753
PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv = NULL;
754
PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv = NULL;
755
PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv = NULL;
756
PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv = NULL;
757
PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv = NULL;
758
 
759
PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;
760
PFNGLCOLORTABLEPROC __glewColorTable = NULL;
761
PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;
762
PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;
763
PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;
764
PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;
765
PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;
766
PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;
767
PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;
768
PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;
769
PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;
770
PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;
771
PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;
772
PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;
773
PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;
774
PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;
775
PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;
776
PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;
777
PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;
778
PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;
779
PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;
780
PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;
781
PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;
782
PFNGLGETMINMAXPROC __glewGetMinmax = NULL;
783
PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;
784
PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;
785
PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;
786
PFNGLHISTOGRAMPROC __glewHistogram = NULL;
787
PFNGLMINMAXPROC __glewMinmax = NULL;
788
PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;
789
PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;
790
PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;
791
 
792
PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL;
793
PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL;
794
PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL;
795
 
796
PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ = NULL;
797
 
798
PFNGLGETINTERNALFORMATI64VPROC __glewGetInternalformati64v = NULL;
799
 
800
PFNGLINVALIDATEBUFFERDATAPROC __glewInvalidateBufferData = NULL;
801
PFNGLINVALIDATEBUFFERSUBDATAPROC __glewInvalidateBufferSubData = NULL;
802
PFNGLINVALIDATEFRAMEBUFFERPROC __glewInvalidateFramebuffer = NULL;
803
PFNGLINVALIDATESUBFRAMEBUFFERPROC __glewInvalidateSubFramebuffer = NULL;
804
PFNGLINVALIDATETEXIMAGEPROC __glewInvalidateTexImage = NULL;
805
PFNGLINVALIDATETEXSUBIMAGEPROC __glewInvalidateTexSubImage = NULL;
806
 
807
PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL;
808
PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL;
809
 
810
PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;
811
PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;
812
PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;
813
PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;
814
PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;
815
 
816
PFNGLMULTIDRAWARRAYSINDIRECTPROC __glewMultiDrawArraysIndirect = NULL;
817
PFNGLMULTIDRAWELEMENTSINDIRECTPROC __glewMultiDrawElementsIndirect = NULL;
818
 
819
PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;
820
 
821
PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;
822
PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;
823
PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;
824
PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;
825
PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;
826
PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;
827
PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;
828
PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;
829
PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;
830
PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;
831
PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;
832
PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;
833
PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;
834
PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;
835
PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;
836
PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;
837
PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;
838
PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;
839
PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;
840
PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;
841
PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;
842
PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;
843
PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;
844
PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;
845
PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;
846
PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;
847
PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;
848
PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;
849
PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;
850
PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;
851
PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;
852
PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;
853
PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;
854
PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;
855
 
856
PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;
857
PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;
858
PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;
859
PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;
860
PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;
861
PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;
862
PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;
863
PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;
864
 
865
PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;
866
PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;
867
 
868
PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv = NULL;
869
PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex = NULL;
870
PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation = NULL;
871
PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC __glewGetProgramResourceLocationIndex = NULL;
872
PFNGLGETPROGRAMRESOURCENAMEPROC __glewGetProgramResourceName = NULL;
873
PFNGLGETPROGRAMRESOURCEIVPROC __glewGetProgramResourceiv = NULL;
874
 
875
PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL;
876
 
877
PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB = NULL;
878
PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB = NULL;
879
PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB = NULL;
880
PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB = NULL;
881
PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB = NULL;
882
PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB = NULL;
883
PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB = NULL;
884
PFNGLGETNMAPIVARBPROC __glewGetnMapivARB = NULL;
885
PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB = NULL;
886
PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB = NULL;
887
PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB = NULL;
888
PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB = NULL;
889
PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB = NULL;
890
PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB = NULL;
891
PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB = NULL;
892
PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB = NULL;
893
PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB = NULL;
894
PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL;
895
PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL;
896
PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL;
897
 
898
PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL;
899
 
900
PFNGLBINDSAMPLERPROC __glewBindSampler = NULL;
901
PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL;
902
PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL;
903
PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL;
904
PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL;
905
PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL;
906
PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL;
907
PFNGLISSAMPLERPROC __glewIsSampler = NULL;
908
PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL;
909
PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL;
910
PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL;
911
PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL;
912
PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL;
913
PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL;
914
 
915
PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram = NULL;
916
PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline = NULL;
917
PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv = NULL;
918
PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines = NULL;
919
PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines = NULL;
920
PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog = NULL;
921
PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv = NULL;
922
PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline = NULL;
923
PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d = NULL;
924
PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv = NULL;
925
PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f = NULL;
926
PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv = NULL;
927
PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i = NULL;
928
PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv = NULL;
929
PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui = NULL;
930
PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv = NULL;
931
PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d = NULL;
932
PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv = NULL;
933
PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f = NULL;
934
PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv = NULL;
935
PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i = NULL;
936
PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv = NULL;
937
PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui = NULL;
938
PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv = NULL;
939
PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d = NULL;
940
PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv = NULL;
941
PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f = NULL;
942
PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv = NULL;
943
PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i = NULL;
944
PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv = NULL;
945
PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui = NULL;
946
PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv = NULL;
947
PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d = NULL;
948
PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv = NULL;
949
PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f = NULL;
950
PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv = NULL;
951
PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i = NULL;
952
PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv = NULL;
953
PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui = NULL;
954
PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv = NULL;
955
PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv = NULL;
956
PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv = NULL;
957
PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv = NULL;
958
PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv = NULL;
959
PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv = NULL;
960
PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv = NULL;
961
PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv = NULL;
962
PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv = NULL;
963
PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv = NULL;
964
PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv = NULL;
965
PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv = NULL;
966
PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv = NULL;
967
PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv = NULL;
968
PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv = NULL;
969
PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv = NULL;
970
PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv = NULL;
971
PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv = NULL;
972
PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv = NULL;
973
PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages = NULL;
974
PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline = NULL;
975
 
976
PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv = NULL;
977
 
978
PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture = NULL;
979
PFNGLMEMORYBARRIERPROC __glewMemoryBarrier = NULL;
980
 
981
PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;
982
PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;
983
PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;
984
PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;
985
PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;
986
PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;
987
PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;
988
PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;
989
PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;
990
PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;
991
PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;
992
PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;
993
PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;
994
PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;
995
PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;
996
PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;
997
PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;
998
PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;
999
PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;
1000
PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;
1001
PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;
1002
PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;
1003
PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;
1004
PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;
1005
PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;
1006
PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;
1007
PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;
1008
PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;
1009
PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;
1010
PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;
1011
PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;
1012
PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;
1013
PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;
1014
PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;
1015
PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;
1016
PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;
1017
PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;
1018
PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;
1019
PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;
1020
 
1021
PFNGLSHADERSTORAGEBLOCKBINDINGPROC __glewShaderStorageBlockBinding = NULL;
1022
 
1023
PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL;
1024
PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL;
1025
PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL;
1026
PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL;
1027
PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL;
1028
PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL;
1029
PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL;
1030
PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL;
1031
 
1032
PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL;
1033
PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL;
1034
PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL;
1035
PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL;
1036
PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL;
1037
PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL;
1038
 
1039
PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL;
1040
PFNGLDELETESYNCPROC __glewDeleteSync = NULL;
1041
PFNGLFENCESYNCPROC __glewFenceSync = NULL;
1042
PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL;
1043
PFNGLGETSYNCIVPROC __glewGetSynciv = NULL;
1044
PFNGLISSYNCPROC __glewIsSync = NULL;
1045
PFNGLWAITSYNCPROC __glewWaitSync = NULL;
1046
 
1047
PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL;
1048
PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL;
1049
 
1050
PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL;
1051
 
1052
PFNGLTEXBUFFERRANGEPROC __glewTexBufferRange = NULL;
1053
PFNGLTEXTUREBUFFERRANGEEXTPROC __glewTextureBufferRangeEXT = NULL;
1054
 
1055
PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;
1056
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;
1057
PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;
1058
PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;
1059
PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;
1060
PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;
1061
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;
1062
 
1063
PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL;
1064
PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL;
1065
PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL;
1066
PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL;
1067
 
1068
PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL;
1069
PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL;
1070
PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL;
1071
PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL;
1072
PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL;
1073
PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL;
1074
 
1075
PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample = NULL;
1076
PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample = NULL;
1077
PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC __glewTextureStorage2DMultisampleEXT = NULL;
1078
PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC __glewTextureStorage3DMultisampleEXT = NULL;
1079
 
1080
PFNGLTEXTUREVIEWPROC __glewTextureView = NULL;
1081
 
1082
PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL;
1083
PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL;
1084
PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL;
1085
 
1086
PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL;
1087
PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL;
1088
PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL;
1089
PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL;
1090
PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL;
1091
PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL;
1092
PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL;
1093
 
1094
PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL;
1095
PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL;
1096
PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL;
1097
PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL;
1098
 
1099
PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced = NULL;
1100
PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced = NULL;
1101
 
1102
PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;
1103
PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;
1104
PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;
1105
PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;
1106
 
1107
PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;
1108
PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;
1109
PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL;
1110
PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL;
1111
PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL;
1112
PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL;
1113
PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;
1114
PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL;
1115
PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL;
1116
PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL;
1117
 
1118
PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL;
1119
PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL;
1120
PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL;
1121
PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL;
1122
 
1123
PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv = NULL;
1124
PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d = NULL;
1125
PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv = NULL;
1126
PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d = NULL;
1127
PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv = NULL;
1128
PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d = NULL;
1129
PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv = NULL;
1130
PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d = NULL;
1131
PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv = NULL;
1132
PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer = NULL;
1133
 
1134
PFNGLBINDVERTEXBUFFERPROC __glewBindVertexBuffer = NULL;
1135
PFNGLVERTEXATTRIBBINDINGPROC __glewVertexAttribBinding = NULL;
1136
PFNGLVERTEXATTRIBFORMATPROC __glewVertexAttribFormat = NULL;
1137
PFNGLVERTEXATTRIBIFORMATPROC __glewVertexAttribIFormat = NULL;
1138
PFNGLVERTEXATTRIBLFORMATPROC __glewVertexAttribLFormat = NULL;
1139
PFNGLVERTEXBINDINGDIVISORPROC __glewVertexBindingDivisor = NULL;
1140
 
1141
PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;
1142
PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;
1143
PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;
1144
PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;
1145
PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;
1146
PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;
1147
PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;
1148
PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;
1149
PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;
1150
PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;
1151
 
1152
PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;
1153
PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;
1154
PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;
1155
PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;
1156
PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;
1157
PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;
1158
PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;
1159
PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;
1160
PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;
1161
PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;
1162
PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;
1163
 
1164
PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;
1165
PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;
1166
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;
1167
PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;
1168
PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;
1169
PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;
1170
PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;
1171
PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;
1172
PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;
1173
PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;
1174
PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;
1175
PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;
1176
PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;
1177
PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;
1178
PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;
1179
PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;
1180
PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;
1181
PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;
1182
PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;
1183
PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;
1184
PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;
1185
PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;
1186
PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;
1187
PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;
1188
PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;
1189
PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;
1190
PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;
1191
PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;
1192
PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;
1193
PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;
1194
PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;
1195
PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;
1196
PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;
1197
PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;
1198
PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;
1199
PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;
1200
PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;
1201
PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;
1202
PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;
1203
PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;
1204
PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;
1205
PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;
1206
PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;
1207
PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;
1208
PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;
1209
PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;
1210
PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;
1211
PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;
1212
PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;
1213
PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;
1214
PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;
1215
PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;
1216
PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;
1217
PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;
1218
PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;
1219
PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;
1220
PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;
1221
PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;
1222
PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;
1223
PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;
1224
PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;
1225
PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;
1226
 
1227
PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;
1228
PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;
1229
PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;
1230
 
1231
PFNGLCOLORP3UIPROC __glewColorP3ui = NULL;
1232
PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL;
1233
PFNGLCOLORP4UIPROC __glewColorP4ui = NULL;
1234
PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL;
1235
PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL;
1236
PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL;
1237
PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL;
1238
PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL;
1239
PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL;
1240
PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL;
1241
PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL;
1242
PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL;
1243
PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL;
1244
PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL;
1245
PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL;
1246
PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL;
1247
PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL;
1248
PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL;
1249
PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL;
1250
PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL;
1251
PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL;
1252
PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL;
1253
PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL;
1254
PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL;
1255
PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL;
1256
PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL;
1257
PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL;
1258
PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL;
1259
PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL;
1260
PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL;
1261
PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL;
1262
PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL;
1263
PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL;
1264
PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL;
1265
PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL;
1266
PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL;
1267
PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL;
1268
PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL;
1269
 
1270
PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv = NULL;
1271
PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed = NULL;
1272
PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v = NULL;
1273
PFNGLGETFLOATI_VPROC __glewGetFloati_v = NULL;
1274
PFNGLSCISSORARRAYVPROC __glewScissorArrayv = NULL;
1275
PFNGLSCISSORINDEXEDPROC __glewScissorIndexed = NULL;
1276
PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv = NULL;
1277
PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv = NULL;
1278
PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf = NULL;
1279
PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv = NULL;
1280
 
1281
PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;
1282
PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;
1283
PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;
1284
PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;
1285
PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;
1286
PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;
1287
PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;
1288
PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;
1289
PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;
1290
PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;
1291
PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;
1292
PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;
1293
PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;
1294
PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;
1295
PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;
1296
PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;
1297
 
1298
PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;
1299
 
1300
PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;
1301
PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;
1302
PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;
1303
 
1304
PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;
1305
PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;
1306
PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;
1307
PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;
1308
 
1309
PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;
1310
PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;
1311
PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;
1312
PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;
1313
PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;
1314
PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;
1315
PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;
1316
PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;
1317
PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;
1318
PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;
1319
PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;
1320
PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;
1321
PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;
1322
PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;
1323
 
1324
PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;
1325
PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;
1326
 
1327
PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI = NULL;
1328
PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI = NULL;
1329
 
1330
PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;
1331
PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;
1332
 
1333
PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;
1334
PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;
1335
PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;
1336
PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;
1337
PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;
1338
PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;
1339
PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;
1340
PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;
1341
PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;
1342
PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;
1343
PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;
1344
PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;
1345
 
1346
PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;
1347
PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;
1348
PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;
1349
 
1350
PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;
1351
PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;
1352
PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;
1353
PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;
1354
PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;
1355
PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;
1356
PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;
1357
PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;
1358
PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;
1359
PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;
1360
PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;
1361
PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;
1362
PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;
1363
PFNGLVERTEXSTREAM1DATIPROC __glewVertexStream1dATI = NULL;
1364
PFNGLVERTEXSTREAM1DVATIPROC __glewVertexStream1dvATI = NULL;
1365
PFNGLVERTEXSTREAM1FATIPROC __glewVertexStream1fATI = NULL;
1366
PFNGLVERTEXSTREAM1FVATIPROC __glewVertexStream1fvATI = NULL;
1367
PFNGLVERTEXSTREAM1IATIPROC __glewVertexStream1iATI = NULL;
1368
PFNGLVERTEXSTREAM1IVATIPROC __glewVertexStream1ivATI = NULL;
1369
PFNGLVERTEXSTREAM1SATIPROC __glewVertexStream1sATI = NULL;
1370
PFNGLVERTEXSTREAM1SVATIPROC __glewVertexStream1svATI = NULL;
1371
PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;
1372
PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;
1373
PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;
1374
PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;
1375
PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;
1376
PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;
1377
PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;
1378
PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;
1379
PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;
1380
PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;
1381
PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;
1382
PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;
1383
PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;
1384
PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;
1385
PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;
1386
PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;
1387
PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;
1388
PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;
1389
PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;
1390
PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;
1391
PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;
1392
PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;
1393
PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;
1394
PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;
1395
 
1396
PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL;
1397
PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL;
1398
PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL;
1399
 
1400
PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;
1401
 
1402
PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;
1403
 
1404
PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;
1405
 
1406
PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;
1407
 
1408
PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;
1409
PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;
1410
 
1411
PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;
1412
PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;
1413
 
1414
PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;
1415
PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;
1416
PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;
1417
PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;
1418
PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;
1419
PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;
1420
PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;
1421
PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;
1422
PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;
1423
PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;
1424
PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;
1425
PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;
1426
PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;
1427
 
1428
PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;
1429
PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;
1430
 
1431
PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;
1432
PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;
1433
PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;
1434
PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;
1435
PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;
1436
 
1437
PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;
1438
PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;
1439
 
1440
PFNGLINSERTEVENTMARKEREXTPROC __glewInsertEventMarkerEXT = NULL;
1441
PFNGLPOPGROUPMARKEREXTPROC __glewPopGroupMarkerEXT = NULL;
1442
PFNGLPUSHGROUPMARKEREXTPROC __glewPushGroupMarkerEXT = NULL;
1443
 
1444
PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;
1445
 
1446
PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL;
1447
PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL;
1448
PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL;
1449
PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL;
1450
PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL;
1451
PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL;
1452
PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL;
1453
PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL;
1454
PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL;
1455
PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL;
1456
PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL;
1457
PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL;
1458
PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL;
1459
PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL;
1460
PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL;
1461
PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL;
1462
PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL;
1463
PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL;
1464
PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL;
1465
PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL;
1466
PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL;
1467
PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL;
1468
PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL;
1469
PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL;
1470
PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL;
1471
PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL;
1472
PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL;
1473
PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL;
1474
PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL;
1475
PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL;
1476
PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL;
1477
PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL;
1478
PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL;
1479
PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL;
1480
PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL;
1481
PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL;
1482
PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL;
1483
PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL;
1484
PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL;
1485
PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL;
1486
PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL;
1487
PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL;
1488
PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL;
1489
PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL;
1490
PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL;
1491
PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL;
1492
PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL;
1493
PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL;
1494
PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL;
1495
PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL;
1496
PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL;
1497
PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL;
1498
PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL;
1499
PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL;
1500
PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL;
1501
PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL;
1502
PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL;
1503
PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL;
1504
PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL;
1505
PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL;
1506
PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL;
1507
PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL;
1508
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL;
1509
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL;
1510
PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL;
1511
PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL;
1512
PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL;
1513
PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL;
1514
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL;
1515
PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL;
1516
PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL;
1517
PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL;
1518
PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL;
1519
PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL;
1520
PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL;
1521
PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL;
1522
PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL;
1523
PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL;
1524
PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL;
1525
PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL;
1526
PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL;
1527
PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL;
1528
PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL;
1529
PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL;
1530
PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL;
1531
PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL;
1532
PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL;
1533
PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL;
1534
PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL;
1535
PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL;
1536
PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL;
1537
PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL;
1538
PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL;
1539
PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL;
1540
PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL;
1541
PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL;
1542
PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL;
1543
PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL;
1544
PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL;
1545
PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL;
1546
PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL;
1547
PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL;
1548
PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL;
1549
PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL;
1550
PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL;
1551
PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL;
1552
PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL;
1553
PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL;
1554
PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL;
1555
PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL;
1556
PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL;
1557
PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL;
1558
PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL;
1559
PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL;
1560
PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL;
1561
PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL;
1562
PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL;
1563
PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL;
1564
PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL;
1565
PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL;
1566
PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL;
1567
PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL;
1568
PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL;
1569
PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL;
1570
PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL;
1571
PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL;
1572
PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;
1573
PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;
1574
PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;
1575
PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;
1576
PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL;
1577
PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;
1578
PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL;
1579
PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL;
1580
PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL;
1581
PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL;
1582
PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL;
1583
PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL;
1584
PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL;
1585
PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL;
1586
PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL;
1587
PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL;
1588
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL;
1589
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL;
1590
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL;
1591
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL;
1592
PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL;
1593
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL;
1594
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL;
1595
PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL;
1596
PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL;
1597
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL;
1598
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL;
1599
PFNGLPROGRAMUNIFORM1DEXTPROC __glewProgramUniform1dEXT = NULL;
1600
PFNGLPROGRAMUNIFORM1DVEXTPROC __glewProgramUniform1dvEXT = NULL;
1601
PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL;
1602
PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL;
1603
PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL;
1604
PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL;
1605
PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL;
1606
PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL;
1607
PFNGLPROGRAMUNIFORM2DEXTPROC __glewProgramUniform2dEXT = NULL;
1608
PFNGLPROGRAMUNIFORM2DVEXTPROC __glewProgramUniform2dvEXT = NULL;
1609
PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL;
1610
PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL;
1611
PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL;
1612
PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL;
1613
PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL;
1614
PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL;
1615
PFNGLPROGRAMUNIFORM3DEXTPROC __glewProgramUniform3dEXT = NULL;
1616
PFNGLPROGRAMUNIFORM3DVEXTPROC __glewProgramUniform3dvEXT = NULL;
1617
PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL;
1618
PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL;
1619
PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL;
1620
PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL;
1621
PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL;
1622
PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL;
1623
PFNGLPROGRAMUNIFORM4DEXTPROC __glewProgramUniform4dEXT = NULL;
1624
PFNGLPROGRAMUNIFORM4DVEXTPROC __glewProgramUniform4dvEXT = NULL;
1625
PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL;
1626
PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL;
1627
PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL;
1628
PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL;
1629
PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL;
1630
PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL;
1631
PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC __glewProgramUniformMatrix2dvEXT = NULL;
1632
PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL;
1633
PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC __glewProgramUniformMatrix2x3dvEXT = NULL;
1634
PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL;
1635
PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC __glewProgramUniformMatrix2x4dvEXT = NULL;
1636
PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL;
1637
PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC __glewProgramUniformMatrix3dvEXT = NULL;
1638
PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL;
1639
PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC __glewProgramUniformMatrix3x2dvEXT = NULL;
1640
PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL;
1641
PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC __glewProgramUniformMatrix3x4dvEXT = NULL;
1642
PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL;
1643
PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC __glewProgramUniformMatrix4dvEXT = NULL;
1644
PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL;
1645
PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC __glewProgramUniformMatrix4x2dvEXT = NULL;
1646
PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL;
1647
PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC __glewProgramUniformMatrix4x3dvEXT = NULL;
1648
PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL;
1649
PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL;
1650
PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL;
1651
PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL;
1652
PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL;
1653
PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL;
1654
PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL;
1655
PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL;
1656
PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL;
1657
PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL;
1658
PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL;
1659
PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL;
1660
PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL;
1661
PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL;
1662
PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL;
1663
PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL;
1664
PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL;
1665
PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL;
1666
PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL;
1667
PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL;
1668
PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL;
1669
PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL;
1670
PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL;
1671
PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL;
1672
PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL;
1673
PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL;
1674
PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL;
1675
PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL;
1676
 
1677
PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;
1678
PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;
1679
PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL;
1680
PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL;
1681
PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL;
1682
PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL;
1683
 
1684
PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL;
1685
PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL;
1686
 
1687
PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;
1688
 
1689
PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;
1690
PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;
1691
PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;
1692
PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;
1693
PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;
1694
 
1695
PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;
1696
PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;
1697
PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;
1698
PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;
1699
PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;
1700
PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;
1701
PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;
1702
PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;
1703
PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;
1704
PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;
1705
PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;
1706
PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;
1707
PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;
1708
PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;
1709
PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;
1710
PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;
1711
PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;
1712
PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;
1713
 
1714
PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;
1715
 
1716
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;
1717
 
1718
PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;
1719
PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;
1720
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;
1721
PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;
1722
PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;
1723
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;
1724
PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;
1725
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;
1726
PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;
1727
PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;
1728
PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;
1729
PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;
1730
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;
1731
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;
1732
PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;
1733
PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;
1734
PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;
1735
 
1736
PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL;
1737
PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL;
1738
PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL;
1739
 
1740
PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL;
1741
PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL;
1742
 
1743
PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL;
1744
PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL;
1745
PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL;
1746
PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL;
1747
PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL;
1748
PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL;
1749
PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL;
1750
PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL;
1751
PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL;
1752
PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL;
1753
PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL;
1754
PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL;
1755
PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL;
1756
PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL;
1757
PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL;
1758
PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL;
1759
PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL;
1760
PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL;
1761
PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL;
1762
PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL;
1763
PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL;
1764
PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL;
1765
PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL;
1766
PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL;
1767
PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL;
1768
PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL;
1769
PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL;
1770
PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL;
1771
PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL;
1772
PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL;
1773
PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL;
1774
PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL;
1775
PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL;
1776
PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL;
1777
 
1778
PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;
1779
PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;
1780
PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;
1781
PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;
1782
PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;
1783
PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;
1784
PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;
1785
PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;
1786
PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;
1787
PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;
1788
 
1789
PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;
1790
 
1791
PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;
1792
 
1793
PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;
1794
PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;
1795
PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;
1796
 
1797
PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;
1798
PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;
1799
 
1800
PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;
1801
PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;
1802
 
1803
PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;
1804
PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;
1805
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;
1806
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;
1807
 
1808
PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;
1809
PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;
1810
PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;
1811
PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;
1812
PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;
1813
PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;
1814
 
1815
PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;
1816
PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;
1817
 
1818
PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;
1819
 
1820
PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL;
1821
 
1822
PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;
1823
PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;
1824
 
1825
PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;
1826
PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;
1827
PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;
1828
PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;
1829
PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;
1830
PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;
1831
PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;
1832
PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;
1833
PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;
1834
PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;
1835
PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;
1836
PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;
1837
PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;
1838
PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;
1839
PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;
1840
PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;
1841
PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;
1842
 
1843
PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL;
1844
PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL;
1845
PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL;
1846
 
1847
PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL;
1848
PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL;
1849
 
1850
PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
1851
 
1852
PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;
1853
PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;
1854
PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;
1855
 
1856
PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;
1857
 
1858
PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL;
1859
 
1860
PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL;
1861
 
1862
PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL;
1863
PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL;
1864
PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL;
1865
PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL;
1866
PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL;
1867
PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL;
1868
 
1869
PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;
1870
PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;
1871
PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;
1872
PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;
1873
PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;
1874
PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;
1875
 
1876
PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;
1877
 
1878
PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;
1879
PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL;
1880
 
1881
PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL;
1882
PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL;
1883
PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL;
1884
PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL;
1885
PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL;
1886
PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL;
1887
PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL;
1888
 
1889
PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;
1890
PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;
1891
PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;
1892
PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;
1893
PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;
1894
PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;
1895
PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;
1896
PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;
1897
 
1898
PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL;
1899
PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL;
1900
PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL;
1901
PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL;
1902
PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL;
1903
PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL;
1904
PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL;
1905
PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL;
1906
PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL;
1907
PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL;
1908
PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL;
1909
 
1910
PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;
1911
PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;
1912
PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;
1913
PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;
1914
PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;
1915
PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;
1916
PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;
1917
PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;
1918
PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;
1919
PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;
1920
PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;
1921
PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;
1922
PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;
1923
PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;
1924
PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;
1925
PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;
1926
PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;
1927
PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;
1928
PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;
1929
PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;
1930
PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;
1931
PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;
1932
PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;
1933
PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;
1934
PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;
1935
PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;
1936
PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;
1937
PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;
1938
PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;
1939
PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;
1940
PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;
1941
PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;
1942
PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;
1943
PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;
1944
PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;
1945
PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;
1946
PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;
1947
PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;
1948
PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;
1949
PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;
1950
PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;
1951
PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;
1952
 
1953
PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;
1954
PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;
1955
PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;
1956
 
1957
PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL;
1958
 
1959
PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL;
1960
 
1961
PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL;
1962
 
1963
PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;
1964
PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;
1965
PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;
1966
PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;
1967
PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;
1968
PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;
1969
 
1970
PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;
1971
PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;
1972
 
1973
PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;
1974
PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;
1975
PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;
1976
PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;
1977
PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;
1978
PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;
1979
PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;
1980
PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;
1981
 
1982
PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;
1983
PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;
1984
PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;
1985
PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;
1986
 
1987
PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;
1988
PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;
1989
 
1990
PFNGLDEBUGMESSAGECALLBACKPROC __glewDebugMessageCallback = NULL;
1991
PFNGLDEBUGMESSAGECONTROLPROC __glewDebugMessageControl = NULL;
1992
PFNGLDEBUGMESSAGEINSERTPROC __glewDebugMessageInsert = NULL;
1993
PFNGLGETDEBUGMESSAGELOGPROC __glewGetDebugMessageLog = NULL;
1994
PFNGLGETOBJECTLABELPROC __glewGetObjectLabel = NULL;
1995
PFNGLGETOBJECTPTRLABELPROC __glewGetObjectPtrLabel = NULL;
1996
PFNGLGETPOINTERVPROC __glewGetPointerv = NULL;
1997
PFNGLOBJECTLABELPROC __glewObjectLabel = NULL;
1998
PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel = NULL;
1999
PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup = NULL;
2000
 
2001
PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled = NULL;
2002
PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion = NULL;
2003
PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion = NULL;
2004
PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion = NULL;
2005
PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion = NULL;
2006
 
2007
PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;
2008
 
2009
PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;
2010
PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;
2011
PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;
2012
PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;
2013
PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;
2014
PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;
2015
PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;
2016
PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;
2017
PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;
2018
PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;
2019
PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;
2020
PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;
2021
PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;
2022
PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;
2023
PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;
2024
PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;
2025
PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;
2026
PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;
2027
PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;
2028
PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;
2029
PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;
2030
PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;
2031
PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;
2032
PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;
2033
 
2034
PFNGLGETIMAGEHANDLENVPROC __glewGetImageHandleNV = NULL;
2035
PFNGLGETTEXTUREHANDLENVPROC __glewGetTextureHandleNV = NULL;
2036
PFNGLGETTEXTURESAMPLERHANDLENVPROC __glewGetTextureSamplerHandleNV = NULL;
2037
PFNGLISIMAGEHANDLERESIDENTNVPROC __glewIsImageHandleResidentNV = NULL;
2038
PFNGLISTEXTUREHANDLERESIDENTNVPROC __glewIsTextureHandleResidentNV = NULL;
2039
PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC __glewMakeImageHandleNonResidentNV = NULL;
2040
PFNGLMAKEIMAGEHANDLERESIDENTNVPROC __glewMakeImageHandleResidentNV = NULL;
2041
PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC __glewMakeTextureHandleNonResidentNV = NULL;
2042
PFNGLMAKETEXTUREHANDLERESIDENTNVPROC __glewMakeTextureHandleResidentNV = NULL;
2043
PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC __glewProgramUniformHandleui64NV = NULL;
2044
PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC __glewProgramUniformHandleui64vNV = NULL;
2045
PFNGLUNIFORMHANDLEUI64NVPROC __glewUniformHandleui64NV = NULL;
2046
PFNGLUNIFORMHANDLEUI64VNVPROC __glewUniformHandleui64vNV = NULL;
2047
 
2048
PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL;
2049
PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL;
2050
 
2051
PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL;
2052
 
2053
PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;
2054
PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;
2055
PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;
2056
 
2057
PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;
2058
PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;
2059
PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;
2060
PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;
2061
PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;
2062
PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;
2063
PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;
2064
PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;
2065
PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;
2066
 
2067
PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL;
2068
PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL;
2069
PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL;
2070
 
2071
PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;
2072
PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;
2073
PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;
2074
PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;
2075
PFNGLISFENCENVPROC __glewIsFenceNV = NULL;
2076
PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;
2077
PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;
2078
 
2079
PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;
2080
PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;
2081
PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;
2082
PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;
2083
PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;
2084
PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;
2085
 
2086
PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL;
2087
 
2088
PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL;
2089
 
2090
PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL;
2091
PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL;
2092
PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL;
2093
PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL;
2094
PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL;
2095
PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL;
2096
PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL;
2097
PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL;
2098
PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL;
2099
PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;
2100
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;
2101
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;
2102
 
2103
PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL;
2104
PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL;
2105
PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL;
2106
PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL;
2107
PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL;
2108
PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL;
2109
PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL;
2110
PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL;
2111
PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL;
2112
PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL;
2113
PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL;
2114
PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL;
2115
PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL;
2116
PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL;
2117
PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL;
2118
PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL;
2119
PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL;
2120
PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL;
2121
PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL;
2122
PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL;
2123
PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL;
2124
PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL;
2125
PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL;
2126
PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL;
2127
PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL;
2128
PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL;
2129
PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL;
2130
PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL;
2131
PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL;
2132
PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL;
2133
PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL;
2134
PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL;
2135
PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL;
2136
PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL;
2137
 
2138
PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;
2139
PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;
2140
PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;
2141
PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;
2142
PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;
2143
PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;
2144
PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;
2145
PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;
2146
PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;
2147
PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;
2148
PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;
2149
PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;
2150
PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;
2151
PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;
2152
PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;
2153
PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;
2154
PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;
2155
PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;
2156
PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;
2157
PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;
2158
PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;
2159
PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;
2160
PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;
2161
PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;
2162
PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;
2163
PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;
2164
PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;
2165
PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;
2166
PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;
2167
PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;
2168
PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;
2169
PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;
2170
PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;
2171
PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;
2172
PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;
2173
PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;
2174
PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;
2175
PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;
2176
PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;
2177
PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;
2178
PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;
2179
PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;
2180
PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;
2181
PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;
2182
PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;
2183
PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;
2184
 
2185
PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;
2186
PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;
2187
PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;
2188
PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;
2189
PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;
2190
PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;
2191
PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;
2192
 
2193
PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL;
2194
PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL;
2195
PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL;
2196
 
2197
PFNGLCOPYPATHNVPROC __glewCopyPathNV = NULL;
2198
PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV = NULL;
2199
PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV = NULL;
2200
PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV = NULL;
2201
PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV = NULL;
2202
PFNGLDELETEPATHSNVPROC __glewDeletePathsNV = NULL;
2203
PFNGLGENPATHSNVPROC __glewGenPathsNV = NULL;
2204
PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV = NULL;
2205
PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV = NULL;
2206
PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV = NULL;
2207
PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV = NULL;
2208
PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV = NULL;
2209
PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV = NULL;
2210
PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV = NULL;
2211
PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV = NULL;
2212
PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV = NULL;
2213
PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV = NULL;
2214
PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV = NULL;
2215
PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV = NULL;
2216
PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV = NULL;
2217
PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV = NULL;
2218
PFNGLISPATHNVPROC __glewIsPathNV = NULL;
2219
PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV = NULL;
2220
PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV = NULL;
2221
PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV = NULL;
2222
PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV = NULL;
2223
PFNGLPATHCOORDSNVPROC __glewPathCoordsNV = NULL;
2224
PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV = NULL;
2225
PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV = NULL;
2226
PFNGLPATHFOGGENNVPROC __glewPathFogGenNV = NULL;
2227
PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV = NULL;
2228
PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV = NULL;
2229
PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV = NULL;
2230
PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV = NULL;
2231
PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV = NULL;
2232
PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV = NULL;
2233
PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV = NULL;
2234
PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV = NULL;
2235
PFNGLPATHSTRINGNVPROC __glewPathStringNV = NULL;
2236
PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV = NULL;
2237
PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV = NULL;
2238
PFNGLPATHTEXGENNVPROC __glewPathTexGenNV = NULL;
2239
PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV = NULL;
2240
PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV = NULL;
2241
PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV = NULL;
2242
PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV = NULL;
2243
PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV = NULL;
2244
PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV = NULL;
2245
PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV = NULL;
2246
 
2247
PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;
2248
PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;
2249
 
2250
PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;
2251
PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;
2252
 
2253
PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL;
2254
PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL;
2255
PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL;
2256
PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL;
2257
PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL;
2258
PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL;
2259
 
2260
PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;
2261
PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;
2262
 
2263
PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;
2264
PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;
2265
PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;
2266
PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;
2267
PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;
2268
PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;
2269
PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;
2270
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;
2271
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;
2272
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;
2273
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;
2274
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;
2275
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;
2276
 
2277
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;
2278
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;
2279
 
2280
PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL;
2281
PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL;
2282
PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL;
2283
PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL;
2284
PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL;
2285
PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL;
2286
PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL;
2287
PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL;
2288
PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL;
2289
PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL;
2290
PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL;
2291
PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL;
2292
PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL;
2293
 
2294
PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL;
2295
 
2296
PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL;
2297
PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV = NULL;
2298
PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV = NULL;
2299
PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL;
2300
PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL;
2301
PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL;
2302
 
2303
PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;
2304
PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;
2305
PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;
2306
PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL;
2307
PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL;
2308
PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL;
2309
PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL;
2310
PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL;
2311
PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;
2312
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;
2313
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;
2314
 
2315
PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL;
2316
PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL;
2317
PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL;
2318
PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL;
2319
PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL;
2320
PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL;
2321
PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL;
2322
 
2323
PFNGLVDPAUFININVPROC __glewVDPAUFiniNV = NULL;
2324
PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV = NULL;
2325
PFNGLVDPAUINITNVPROC __glewVDPAUInitNV = NULL;
2326
PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV = NULL;
2327
PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV = NULL;
2328
PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV = NULL;
2329
PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV = NULL;
2330
PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV = NULL;
2331
PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV = NULL;
2332
PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV = NULL;
2333
 
2334
PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;
2335
PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;
2336
 
2337
PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL;
2338
PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL;
2339
PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL;
2340
PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL;
2341
PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL;
2342
PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL;
2343
PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL;
2344
PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL;
2345
PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL;
2346
PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL;
2347
PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL;
2348
PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL;
2349
PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL;
2350
PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL;
2351
PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL;
2352
PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL;
2353
PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL;
2354
PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL;
2355
PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL;
2356
 
2357
PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL;
2358
PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL;
2359
PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL;
2360
PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL;
2361
PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL;
2362
PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL;
2363
PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL;
2364
PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL;
2365
PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL;
2366
PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL;
2367
PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL;
2368
PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL;
2369
 
2370
PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;
2371
PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;
2372
PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;
2373
PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;
2374
PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;
2375
PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;
2376
PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;
2377
PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;
2378
PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;
2379
PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;
2380
PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;
2381
PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;
2382
PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;
2383
PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;
2384
PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;
2385
PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;
2386
PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;
2387
PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;
2388
PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;
2389
PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;
2390
PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;
2391
PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;
2392
PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;
2393
PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;
2394
PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;
2395
PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;
2396
PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;
2397
PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;
2398
PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;
2399
PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;
2400
PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;
2401
PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;
2402
PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;
2403
PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;
2404
PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;
2405
PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;
2406
PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;
2407
PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;
2408
PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;
2409
PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;
2410
PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;
2411
PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;
2412
PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;
2413
PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;
2414
PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;
2415
PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;
2416
PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;
2417
PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;
2418
PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;
2419
PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;
2420
PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;
2421
PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;
2422
PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;
2423
PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;
2424
PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;
2425
PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;
2426
PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;
2427
PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;
2428
PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;
2429
PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;
2430
PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;
2431
PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;
2432
PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;
2433
PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;
2434
 
2435
PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV = NULL;
2436
PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV = NULL;
2437
PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV = NULL;
2438
PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV = NULL;
2439
PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV = NULL;
2440
PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV = NULL;
2441
PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV = NULL;
2442
PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV = NULL;
2443
PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV = NULL;
2444
PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = NULL;
2445
PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL;
2446
PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL;
2447
 
2448
PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL;
2449
PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL;
2450
PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL;
2451
PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL;
2452
PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL;
2453
PFNGLORTHOFOESPROC __glewOrthofOES = NULL;
2454
 
2455
PFNGLERRORSTRINGREGALPROC __glewErrorStringREGAL = NULL;
2456
 
2457
PFNGLGETEXTENSIONREGALPROC __glewGetExtensionREGAL = NULL;
2458
PFNGLISSUPPORTEDREGALPROC __glewIsSupportedREGAL = NULL;
2459
 
2460
PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;
2461
PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;
2462
 
2463
PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;
2464
PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;
2465
 
2466
PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;
2467
PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;
2468
 
2469
PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;
2470
PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;
2471
 
2472
PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;
2473
PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;
2474
 
2475
PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;
2476
PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;
2477
 
2478
PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;
2479
PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;
2480
PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;
2481
PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;
2482
PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;
2483
PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;
2484
 
2485
PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;
2486
 
2487
PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;
2488
 
2489
PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;
2490
PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;
2491
PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;
2492
PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;
2493
PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;
2494
PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;
2495
PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;
2496
PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;
2497
PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;
2498
PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;
2499
PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;
2500
PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;
2501
PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;
2502
PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;
2503
PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;
2504
PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;
2505
PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;
2506
 
2507
PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;
2508
 
2509
PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;
2510
 
2511
PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;
2512
 
2513
PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;
2514
PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;
2515
PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;
2516
PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;
2517
 
2518
PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;
2519
 
2520
PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;
2521
PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;
2522
PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;
2523
PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;
2524
PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;
2525
PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;
2526
PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;
2527
 
2528
PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;
2529
 
2530
PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;
2531
PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;
2532
PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;
2533
PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;
2534
PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;
2535
PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;
2536
PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;
2537
PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;
2538
 
2539
PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;
2540
 
2541
PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;
2542
PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;
2543
PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;
2544
PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;
2545
PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;
2546
PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;
2547
PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;
2548
 
2549
PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;
2550
PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;
2551
PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;
2552
PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;
2553
PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;
2554
PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;
2555
PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;
2556
PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;
2557
PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;
2558
PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;
2559
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;
2560
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;
2561
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;
2562
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;
2563
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;
2564
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;
2565
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;
2566
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;
2567
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;
2568
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;
2569
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;
2570
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;
2571
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;
2572
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;
2573
PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;
2574
PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;
2575
PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;
2576
PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;
2577
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;
2578
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;
2579
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;
2580
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;
2581
PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;
2582
PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;
2583
PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;
2584
PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;
2585
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;
2586
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;
2587
PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;
2588
PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;
2589
 
2590
PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;
2591
 
2592
#endif /* !WIN32 || !GLEW_MX */
2593
 
2594
#if !defined(GLEW_MX)
2595
 
2596
GLboolean __GLEW_VERSION_1_1 = GL_FALSE;
2597
GLboolean __GLEW_VERSION_1_2 = GL_FALSE;
2598
GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE;
2599
GLboolean __GLEW_VERSION_1_3 = GL_FALSE;
2600
GLboolean __GLEW_VERSION_1_4 = GL_FALSE;
2601
GLboolean __GLEW_VERSION_1_5 = GL_FALSE;
2602
GLboolean __GLEW_VERSION_2_0 = GL_FALSE;
2603
GLboolean __GLEW_VERSION_2_1 = GL_FALSE;
2604
GLboolean __GLEW_VERSION_3_0 = GL_FALSE;
2605
GLboolean __GLEW_VERSION_3_1 = GL_FALSE;
2606
GLboolean __GLEW_VERSION_3_2 = GL_FALSE;
2607
GLboolean __GLEW_VERSION_3_3 = GL_FALSE;
2608
GLboolean __GLEW_VERSION_4_0 = GL_FALSE;
2609
GLboolean __GLEW_VERSION_4_1 = GL_FALSE;
2610
GLboolean __GLEW_VERSION_4_2 = GL_FALSE;
2611
GLboolean __GLEW_VERSION_4_3 = GL_FALSE;
2612
GLboolean __GLEW_3DFX_multisample = GL_FALSE;
2613
GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;
2614
GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;
2615
GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE;
2616
GLboolean __GLEW_AMD_conservative_depth = GL_FALSE;
2617
GLboolean __GLEW_AMD_debug_output = GL_FALSE;
2618
GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE;
2619
GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE;
2620
GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE;
2621
GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE;
2622
GLboolean __GLEW_AMD_performance_monitor = GL_FALSE;
2623
GLboolean __GLEW_AMD_pinned_memory = GL_FALSE;
2624
GLboolean __GLEW_AMD_query_buffer_object = GL_FALSE;
2625
GLboolean __GLEW_AMD_sample_positions = GL_FALSE;
2626
GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE;
2627
GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE;
2628
GLboolean __GLEW_AMD_stencil_operation_extended = GL_FALSE;
2629
GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE;
2630
GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE;
2631
GLboolean __GLEW_AMD_vertex_shader_layer = GL_FALSE;
2632
GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE;
2633
GLboolean __GLEW_AMD_vertex_shader_viewport_index = GL_FALSE;
2634
GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE;
2635
GLboolean __GLEW_APPLE_client_storage = GL_FALSE;
2636
GLboolean __GLEW_APPLE_element_array = GL_FALSE;
2637
GLboolean __GLEW_APPLE_fence = GL_FALSE;
2638
GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;
2639
GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;
2640
GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE;
2641
GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;
2642
GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE;
2643
GLboolean __GLEW_APPLE_row_bytes = GL_FALSE;
2644
GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;
2645
GLboolean __GLEW_APPLE_texture_range = GL_FALSE;
2646
GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;
2647
GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;
2648
GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;
2649
GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE;
2650
GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;
2651
GLboolean __GLEW_ARB_ES2_compatibility = GL_FALSE;
2652
GLboolean __GLEW_ARB_ES3_compatibility = GL_FALSE;
2653
GLboolean __GLEW_ARB_arrays_of_arrays = GL_FALSE;
2654
GLboolean __GLEW_ARB_base_instance = GL_FALSE;
2655
GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE;
2656
GLboolean __GLEW_ARB_cl_event = GL_FALSE;
2657
GLboolean __GLEW_ARB_clear_buffer_object = GL_FALSE;
2658
GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;
2659
GLboolean __GLEW_ARB_compatibility = GL_FALSE;
2660
GLboolean __GLEW_ARB_compressed_texture_pixel_storage = GL_FALSE;
2661
GLboolean __GLEW_ARB_compute_shader = GL_FALSE;
2662
GLboolean __GLEW_ARB_conservative_depth = GL_FALSE;
2663
GLboolean __GLEW_ARB_copy_buffer = GL_FALSE;
2664
GLboolean __GLEW_ARB_copy_image = GL_FALSE;
2665
GLboolean __GLEW_ARB_debug_output = GL_FALSE;
2666
GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE;
2667
GLboolean __GLEW_ARB_depth_clamp = GL_FALSE;
2668
GLboolean __GLEW_ARB_depth_texture = GL_FALSE;
2669
GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;
2670
GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE;
2671
GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE;
2672
GLboolean __GLEW_ARB_draw_indirect = GL_FALSE;
2673
GLboolean __GLEW_ARB_draw_instanced = GL_FALSE;
2674
GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE;
2675
GLboolean __GLEW_ARB_explicit_uniform_location = GL_FALSE;
2676
GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE;
2677
GLboolean __GLEW_ARB_fragment_layer_viewport = GL_FALSE;
2678
GLboolean __GLEW_ARB_fragment_program = GL_FALSE;
2679
GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;
2680
GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;
2681
GLboolean __GLEW_ARB_framebuffer_no_attachments = GL_FALSE;
2682
GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE;
2683
GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE;
2684
GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE;
2685
GLboolean __GLEW_ARB_get_program_binary = GL_FALSE;
2686
GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE;
2687
GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE;
2688
GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;
2689
GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE;
2690
GLboolean __GLEW_ARB_imaging = GL_FALSE;
2691
GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE;
2692
GLboolean __GLEW_ARB_internalformat_query = GL_FALSE;
2693
GLboolean __GLEW_ARB_internalformat_query2 = GL_FALSE;
2694
GLboolean __GLEW_ARB_invalidate_subdata = GL_FALSE;
2695
GLboolean __GLEW_ARB_map_buffer_alignment = GL_FALSE;
2696
GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE;
2697
GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;
2698
GLboolean __GLEW_ARB_multi_draw_indirect = GL_FALSE;
2699
GLboolean __GLEW_ARB_multisample = GL_FALSE;
2700
GLboolean __GLEW_ARB_multitexture = GL_FALSE;
2701
GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;
2702
GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE;
2703
GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;
2704
GLboolean __GLEW_ARB_point_parameters = GL_FALSE;
2705
GLboolean __GLEW_ARB_point_sprite = GL_FALSE;
2706
GLboolean __GLEW_ARB_program_interface_query = GL_FALSE;
2707
GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE;
2708
GLboolean __GLEW_ARB_robust_buffer_access_behavior = GL_FALSE;
2709
GLboolean __GLEW_ARB_robustness = GL_FALSE;
2710
GLboolean __GLEW_ARB_robustness_application_isolation = GL_FALSE;
2711
GLboolean __GLEW_ARB_robustness_share_group_isolation = GL_FALSE;
2712
GLboolean __GLEW_ARB_sample_shading = GL_FALSE;
2713
GLboolean __GLEW_ARB_sampler_objects = GL_FALSE;
2714
GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE;
2715
GLboolean __GLEW_ARB_separate_shader_objects = GL_FALSE;
2716
GLboolean __GLEW_ARB_shader_atomic_counters = GL_FALSE;
2717
GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE;
2718
GLboolean __GLEW_ARB_shader_image_load_store = GL_FALSE;
2719
GLboolean __GLEW_ARB_shader_image_size = GL_FALSE;
2720
GLboolean __GLEW_ARB_shader_objects = GL_FALSE;
2721
GLboolean __GLEW_ARB_shader_precision = GL_FALSE;
2722
GLboolean __GLEW_ARB_shader_stencil_export = GL_FALSE;
2723
GLboolean __GLEW_ARB_shader_storage_buffer_object = GL_FALSE;
2724
GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE;
2725
GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE;
2726
GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;
2727
GLboolean __GLEW_ARB_shading_language_420pack = GL_FALSE;
2728
GLboolean __GLEW_ARB_shading_language_include = GL_FALSE;
2729
GLboolean __GLEW_ARB_shading_language_packing = GL_FALSE;
2730
GLboolean __GLEW_ARB_shadow = GL_FALSE;
2731
GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;
2732
GLboolean __GLEW_ARB_stencil_texturing = GL_FALSE;
2733
GLboolean __GLEW_ARB_sync = GL_FALSE;
2734
GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE;
2735
GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;
2736
GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE;
2737
GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE;
2738
GLboolean __GLEW_ARB_texture_buffer_range = GL_FALSE;
2739
GLboolean __GLEW_ARB_texture_compression = GL_FALSE;
2740
GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE;
2741
GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE;
2742
GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;
2743
GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE;
2744
GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;
2745
GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;
2746
GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;
2747
GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;
2748
GLboolean __GLEW_ARB_texture_float = GL_FALSE;
2749
GLboolean __GLEW_ARB_texture_gather = GL_FALSE;
2750
GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;
2751
GLboolean __GLEW_ARB_texture_multisample = GL_FALSE;
2752
GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;
2753
GLboolean __GLEW_ARB_texture_query_levels = GL_FALSE;
2754
GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE;
2755
GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;
2756
GLboolean __GLEW_ARB_texture_rg = GL_FALSE;
2757
GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE;
2758
GLboolean __GLEW_ARB_texture_storage = GL_FALSE;
2759
GLboolean __GLEW_ARB_texture_storage_multisample = GL_FALSE;
2760
GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE;
2761
GLboolean __GLEW_ARB_texture_view = GL_FALSE;
2762
GLboolean __GLEW_ARB_timer_query = GL_FALSE;
2763
GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE;
2764
GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE;
2765
GLboolean __GLEW_ARB_transform_feedback_instanced = GL_FALSE;
2766
GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;
2767
GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE;
2768
GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE;
2769
GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE;
2770
GLboolean __GLEW_ARB_vertex_attrib_64bit = GL_FALSE;
2771
GLboolean __GLEW_ARB_vertex_attrib_binding = GL_FALSE;
2772
GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;
2773
GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;
2774
GLboolean __GLEW_ARB_vertex_program = GL_FALSE;
2775
GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;
2776
GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE;
2777
GLboolean __GLEW_ARB_viewport_array = GL_FALSE;
2778
GLboolean __GLEW_ARB_window_pos = GL_FALSE;
2779
GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;
2780
GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;
2781
GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;
2782
GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;
2783
GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;
2784
GLboolean __GLEW_ATI_element_array = GL_FALSE;
2785
GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;
2786
GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;
2787
GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;
2788
GLboolean __GLEW_ATI_meminfo = GL_FALSE;
2789
GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;
2790
GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;
2791
GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;
2792
GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;
2793
GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;
2794
GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;
2795
GLboolean __GLEW_ATI_texture_float = GL_FALSE;
2796
GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;
2797
GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;
2798
GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;
2799
GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;
2800
GLboolean __GLEW_EXT_422_pixels = GL_FALSE;
2801
GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;
2802
GLboolean __GLEW_EXT_abgr = GL_FALSE;
2803
GLboolean __GLEW_EXT_bgra = GL_FALSE;
2804
GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE;
2805
GLboolean __GLEW_EXT_blend_color = GL_FALSE;
2806
GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;
2807
GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;
2808
GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;
2809
GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;
2810
GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;
2811
GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;
2812
GLboolean __GLEW_EXT_cmyka = GL_FALSE;
2813
GLboolean __GLEW_EXT_color_subtable = GL_FALSE;
2814
GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;
2815
GLboolean __GLEW_EXT_convolution = GL_FALSE;
2816
GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;
2817
GLboolean __GLEW_EXT_copy_texture = GL_FALSE;
2818
GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;
2819
GLboolean __GLEW_EXT_debug_marker = GL_FALSE;
2820
GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;
2821
GLboolean __GLEW_EXT_direct_state_access = GL_FALSE;
2822
GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE;
2823
GLboolean __GLEW_EXT_draw_instanced = GL_FALSE;
2824
GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;
2825
GLboolean __GLEW_EXT_fog_coord = GL_FALSE;
2826
GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;
2827
GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;
2828
GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;
2829
GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE;
2830
GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;
2831
GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE;
2832
GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE;
2833
GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE;
2834
GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE;
2835
GLboolean __GLEW_EXT_histogram = GL_FALSE;
2836
GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;
2837
GLboolean __GLEW_EXT_index_func = GL_FALSE;
2838
GLboolean __GLEW_EXT_index_material = GL_FALSE;
2839
GLboolean __GLEW_EXT_index_texture = GL_FALSE;
2840
GLboolean __GLEW_EXT_light_texture = GL_FALSE;
2841
GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;
2842
GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;
2843
GLboolean __GLEW_EXT_multisample = GL_FALSE;
2844
GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE;
2845
GLboolean __GLEW_EXT_packed_float = GL_FALSE;
2846
GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;
2847
GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;
2848
GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;
2849
GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;
2850
GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;
2851
GLboolean __GLEW_EXT_point_parameters = GL_FALSE;
2852
GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;
2853
GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE;
2854
GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;
2855
GLboolean __GLEW_EXT_scene_marker = GL_FALSE;
2856
GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
2857
GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE;
2858
GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;
2859
GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE;
2860
GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;
2861
GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;
2862
GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;
2863
GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;
2864
GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;
2865
GLboolean __GLEW_EXT_subtexture = GL_FALSE;
2866
GLboolean __GLEW_EXT_texture = GL_FALSE;
2867
GLboolean __GLEW_EXT_texture3D = GL_FALSE;
2868
GLboolean __GLEW_EXT_texture_array = GL_FALSE;
2869
GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE;
2870
GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;
2871
GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE;
2872
GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE;
2873
GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;
2874
GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;
2875
GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;
2876
GLboolean __GLEW_EXT_texture_env = GL_FALSE;
2877
GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;
2878
GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;
2879
GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;
2880
GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;
2881
GLboolean __GLEW_EXT_texture_integer = GL_FALSE;
2882
GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;
2883
GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;
2884
GLboolean __GLEW_EXT_texture_object = GL_FALSE;
2885
GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;
2886
GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;
2887
GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;
2888
GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE;
2889
GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;
2890
GLboolean __GLEW_EXT_texture_snorm = GL_FALSE;
2891
GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;
2892
GLboolean __GLEW_EXT_timer_query = GL_FALSE;
2893
GLboolean __GLEW_EXT_transform_feedback = GL_FALSE;
2894
GLboolean __GLEW_EXT_vertex_array = GL_FALSE;
2895
GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE;
2896
GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE;
2897
GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;
2898
GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;
2899
GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE;
2900
GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;
2901
GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE;
2902
GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;
2903
GLboolean __GLEW_HP_image_transform = GL_FALSE;
2904
GLboolean __GLEW_HP_occlusion_test = GL_FALSE;
2905
GLboolean __GLEW_HP_texture_lighting = GL_FALSE;
2906
GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;
2907
GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;
2908
GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;
2909
GLboolean __GLEW_IBM_static_data = GL_FALSE;
2910
GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;
2911
GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;
2912
GLboolean __GLEW_INGR_color_clamp = GL_FALSE;
2913
GLboolean __GLEW_INGR_interlace_read = GL_FALSE;
2914
GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;
2915
GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;
2916
GLboolean __GLEW_KHR_debug = GL_FALSE;
2917
GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE;
2918
GLboolean __GLEW_KTX_buffer_region = GL_FALSE;
2919
GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;
2920
GLboolean __GLEW_MESA_pack_invert = GL_FALSE;
2921
GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;
2922
GLboolean __GLEW_MESA_window_pos = GL_FALSE;
2923
GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;
2924
GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE;
2925
GLboolean __GLEW_NV_bindless_texture = GL_FALSE;
2926
GLboolean __GLEW_NV_blend_square = GL_FALSE;
2927
GLboolean __GLEW_NV_conditional_render = GL_FALSE;
2928
GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;
2929
GLboolean __GLEW_NV_copy_image = GL_FALSE;
2930
GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;
2931
GLboolean __GLEW_NV_depth_clamp = GL_FALSE;
2932
GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;
2933
GLboolean __GLEW_NV_evaluators = GL_FALSE;
2934
GLboolean __GLEW_NV_explicit_multisample = GL_FALSE;
2935
GLboolean __GLEW_NV_fence = GL_FALSE;
2936
GLboolean __GLEW_NV_float_buffer = GL_FALSE;
2937
GLboolean __GLEW_NV_fog_distance = GL_FALSE;
2938
GLboolean __GLEW_NV_fragment_program = GL_FALSE;
2939
GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;
2940
GLboolean __GLEW_NV_fragment_program4 = GL_FALSE;
2941
GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;
2942
GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;
2943
GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;
2944
GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;
2945
GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;
2946
GLboolean __GLEW_NV_gpu_program5 = GL_FALSE;
2947
GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE;
2948
GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE;
2949
GLboolean __GLEW_NV_half_float = GL_FALSE;
2950
GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;
2951
GLboolean __GLEW_NV_multisample_coverage = GL_FALSE;
2952
GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;
2953
GLboolean __GLEW_NV_occlusion_query = GL_FALSE;
2954
GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;
2955
GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;
2956
GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE;
2957
GLboolean __GLEW_NV_path_rendering = GL_FALSE;
2958
GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;
2959
GLboolean __GLEW_NV_point_sprite = GL_FALSE;
2960
GLboolean __GLEW_NV_present_video = GL_FALSE;
2961
GLboolean __GLEW_NV_primitive_restart = GL_FALSE;
2962
GLboolean __GLEW_NV_register_combiners = GL_FALSE;
2963
GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;
2964
GLboolean __GLEW_NV_shader_atomic_float = GL_FALSE;
2965
GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE;
2966
GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE;
2967
GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;
2968
GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;
2969
GLboolean __GLEW_NV_texture_barrier = GL_FALSE;
2970
GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;
2971
GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;
2972
GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;
2973
GLboolean __GLEW_NV_texture_multisample = GL_FALSE;
2974
GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;
2975
GLboolean __GLEW_NV_texture_shader = GL_FALSE;
2976
GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;
2977
GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;
2978
GLboolean __GLEW_NV_transform_feedback = GL_FALSE;
2979
GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE;
2980
GLboolean __GLEW_NV_vdpau_interop = GL_FALSE;
2981
GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;
2982
GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;
2983
GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE;
2984
GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE;
2985
GLboolean __GLEW_NV_vertex_program = GL_FALSE;
2986
GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;
2987
GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;
2988
GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;
2989
GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;
2990
GLboolean __GLEW_NV_vertex_program4 = GL_FALSE;
2991
GLboolean __GLEW_NV_video_capture = GL_FALSE;
2992
GLboolean __GLEW_OES_byte_coordinates = GL_FALSE;
2993
GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE;
2994
GLboolean __GLEW_OES_read_format = GL_FALSE;
2995
GLboolean __GLEW_OES_single_precision = GL_FALSE;
2996
GLboolean __GLEW_OML_interlace = GL_FALSE;
2997
GLboolean __GLEW_OML_resample = GL_FALSE;
2998
GLboolean __GLEW_OML_subsample = GL_FALSE;
2999
GLboolean __GLEW_PGI_misc_hints = GL_FALSE;
3000
GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;
3001
GLboolean __GLEW_REGAL_error_string = GL_FALSE;
3002
GLboolean __GLEW_REGAL_extension_query = GL_FALSE;
3003
GLboolean __GLEW_REGAL_log = GL_FALSE;
3004
GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;
3005
GLboolean __GLEW_S3_s3tc = GL_FALSE;
3006
GLboolean __GLEW_SGIS_color_range = GL_FALSE;
3007
GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;
3008
GLboolean __GLEW_SGIS_fog_function = GL_FALSE;
3009
GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;
3010
GLboolean __GLEW_SGIS_multisample = GL_FALSE;
3011
GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;
3012
GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE;
3013
GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;
3014
GLboolean __GLEW_SGIS_texture4D = GL_FALSE;
3015
GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;
3016
GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;
3017
GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;
3018
GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;
3019
GLboolean __GLEW_SGIS_texture_select = GL_FALSE;
3020
GLboolean __GLEW_SGIX_async = GL_FALSE;
3021
GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;
3022
GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;
3023
GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;
3024
GLboolean __GLEW_SGIX_clipmap = GL_FALSE;
3025
GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE;
3026
GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;
3027
GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;
3028
GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;
3029
GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;
3030
GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;
3031
GLboolean __GLEW_SGIX_framezoom = GL_FALSE;
3032
GLboolean __GLEW_SGIX_interlace = GL_FALSE;
3033
GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;
3034
GLboolean __GLEW_SGIX_list_priority = GL_FALSE;
3035
GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;
3036
GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;
3037
GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;
3038
GLboolean __GLEW_SGIX_resample = GL_FALSE;
3039
GLboolean __GLEW_SGIX_shadow = GL_FALSE;
3040
GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;
3041
GLboolean __GLEW_SGIX_sprite = GL_FALSE;
3042
GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;
3043
GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;
3044
GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;
3045
GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;
3046
GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;
3047
GLboolean __GLEW_SGIX_texture_range = GL_FALSE;
3048
GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;
3049
GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;
3050
GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;
3051
GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;
3052
GLboolean __GLEW_SGI_color_matrix = GL_FALSE;
3053
GLboolean __GLEW_SGI_color_table = GL_FALSE;
3054
GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;
3055
GLboolean __GLEW_SUNX_constant_data = GL_FALSE;
3056
GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;
3057
GLboolean __GLEW_SUN_global_alpha = GL_FALSE;
3058
GLboolean __GLEW_SUN_mesh_array = GL_FALSE;
3059
GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;
3060
GLboolean __GLEW_SUN_slice_accum = GL_FALSE;
3061
GLboolean __GLEW_SUN_triangle_list = GL_FALSE;
3062
GLboolean __GLEW_SUN_vertex = GL_FALSE;
3063
GLboolean __GLEW_WIN_phong_shading = GL_FALSE;
3064
GLboolean __GLEW_WIN_specular_fog = GL_FALSE;
3065
GLboolean __GLEW_WIN_swap_hint = GL_FALSE;
3066
 
3067
#endif /* !GLEW_MX */
3068
 
3069
#ifdef GL_VERSION_1_2
3070
 
3071
static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)
3072
{
3073
  GLboolean r = GL_FALSE;
3074
 
3075
  r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r;
3076
  r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r;
3077
  r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r;
3078
  r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r;
3079
 
3080
  return r;
3081
}
3082
 
3083
#endif /* GL_VERSION_1_2 */
3084
 
3085
#ifdef GL_VERSION_1_2_1
3086
 
3087
#endif /* GL_VERSION_1_2_1 */
3088
 
3089
#ifdef GL_VERSION_1_3
3090
 
3091
static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)
3092
{
3093
  GLboolean r = GL_FALSE;
3094
 
3095
  r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r;
3096
  r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r;
3097
  r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r;
3098
  r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r;
3099
  r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r;
3100
  r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r;
3101
  r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r;
3102
  r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r;
3103
  r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r;
3104
  r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r;
3105
  r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r;
3106
  r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r;
3107
  r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r;
3108
  r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r;
3109
  r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r;
3110
  r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r;
3111
  r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r;
3112
  r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r;
3113
  r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r;
3114
  r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r;
3115
  r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r;
3116
  r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r;
3117
  r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r;
3118
  r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r;
3119
  r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r;
3120
  r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r;
3121
  r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r;
3122
  r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r;
3123
  r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r;
3124
  r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r;
3125
  r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r;
3126
  r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r;
3127
  r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r;
3128
  r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r;
3129
  r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r;
3130
  r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r;
3131
  r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r;
3132
  r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r;
3133
  r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r;
3134
  r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r;
3135
  r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r;
3136
  r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r;
3137
  r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r;
3138
  r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r;
3139
  r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r;
3140
  r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r;
3141
 
3142
  return r;
3143
}
3144
 
3145
#endif /* GL_VERSION_1_3 */
3146
 
3147
#ifdef GL_VERSION_1_4
3148
 
3149
static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)
3150
{
3151
  GLboolean r = GL_FALSE;
3152
 
3153
  r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r;
3154
  r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
3155
  r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r;
3156
  r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r;
3157
  r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r;
3158
  r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r;
3159
  r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r;
3160
  r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r;
3161
  r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r;
3162
  r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r;
3163
  r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r;
3164
  r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r;
3165
  r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r;
3166
  r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r;
3167
  r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r;
3168
  r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r;
3169
  r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r;
3170
  r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r;
3171
  r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r;
3172
  r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r;
3173
  r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r;
3174
  r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r;
3175
  r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r;
3176
  r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r;
3177
  r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r;
3178
  r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r;
3179
  r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r;
3180
  r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r;
3181
  r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r;
3182
  r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r;
3183
  r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r;
3184
  r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r;
3185
  r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r;
3186
  r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r;
3187
  r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r;
3188
  r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r;
3189
  r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r;
3190
  r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r;
3191
  r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r;
3192
  r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r;
3193
  r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r;
3194
  r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r;
3195
  r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r;
3196
  r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r;
3197
  r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r;
3198
  r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r;
3199
  r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r;
3200
 
3201
  return r;
3202
}
3203
 
3204
#endif /* GL_VERSION_1_4 */
3205
 
3206
#ifdef GL_VERSION_1_5
3207
 
3208
static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)
3209
{
3210
  GLboolean r = GL_FALSE;
3211
 
3212
  r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r;
3213
  r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r;
3214
  r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r;
3215
  r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r;
3216
  r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r;
3217
  r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r;
3218
  r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r;
3219
  r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r;
3220
  r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r;
3221
  r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r;
3222
  r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r;
3223
  r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r;
3224
  r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r;
3225
  r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r;
3226
  r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r;
3227
  r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r;
3228
  r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r;
3229
  r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r;
3230
  r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r;
3231
 
3232
  return r;
3233
}
3234
 
3235
#endif /* GL_VERSION_1_5 */
3236
 
3237
#ifdef GL_VERSION_2_0
3238
 
3239
static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)
3240
{
3241
  GLboolean r = GL_FALSE;
3242
 
3243
  r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r;
3244
  r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r;
3245
  r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r;
3246
  r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r;
3247
  r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r;
3248
  r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r;
3249
  r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r;
3250
  r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r;
3251
  r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r;
3252
  r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r;
3253
  r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r;
3254
  r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r;
3255
  r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r;
3256
  r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r;
3257
  r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r;
3258
  r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r;
3259
  r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r;
3260
  r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r;
3261
  r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r;
3262
  r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r;
3263
  r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r;
3264
  r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r;
3265
  r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r;
3266
  r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r;
3267
  r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r;
3268
  r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r;
3269
  r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r;
3270
  r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r;
3271
  r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r;
3272
  r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r;
3273
  r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r;
3274
  r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r;
3275
  r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r;
3276
  r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r;
3277
  r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r;
3278
  r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r;
3279
  r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r;
3280
  r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r;
3281
  r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r;
3282
  r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r;
3283
  r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r;
3284
  r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r;
3285
  r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r;
3286
  r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r;
3287
  r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r;
3288
  r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r;
3289
  r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r;
3290
  r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r;
3291
  r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r;
3292
  r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r;
3293
  r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r;
3294
  r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r;
3295
  r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r;
3296
  r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r;
3297
  r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r;
3298
  r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r;
3299
  r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r;
3300
  r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r;
3301
  r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r;
3302
  r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r;
3303
  r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r;
3304
  r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r;
3305
  r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r;
3306
  r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r;
3307
  r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r;
3308
  r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r;
3309
  r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r;
3310
  r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r;
3311
  r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r;
3312
  r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r;
3313
  r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r;
3314
  r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r;
3315
  r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r;
3316
  r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r;
3317
  r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r;
3318
  r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r;
3319
  r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r;
3320
  r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r;
3321
  r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r;
3322
  r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r;
3323
  r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r;
3324
  r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r;
3325
  r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r;
3326
  r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r;
3327
  r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r;
3328
  r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r;
3329
  r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r;
3330
  r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r;
3331
  r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r;
3332
  r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r;
3333
  r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r;
3334
  r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r;
3335
  r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r;
3336
 
3337
  return r;
3338
}
3339
 
3340
#endif /* GL_VERSION_2_0 */
3341
 
3342
#ifdef GL_VERSION_2_1
3343
 
3344
static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT)
3345
{
3346
  GLboolean r = GL_FALSE;
3347
 
3348
  r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r;
3349
  r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r;
3350
  r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r;
3351
  r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r;
3352
  r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r;
3353
  r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r;
3354
 
3355
  return r;
3356
}
3357
 
3358
#endif /* GL_VERSION_2_1 */
3359
 
3360
#ifdef GL_VERSION_3_0
3361
 
3362
static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)
3363
{
3364
  GLboolean r = GL_FALSE;
3365
 
3366
  r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r;
3367
  r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r;
3368
  r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r;
3369
  r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r;
3370
  r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r;
3371
  r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r;
3372
  r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r;
3373
  r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r;
3374
  r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r;
3375
  r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r;
3376
  r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r;
3377
  r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r;
3378
  r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r;
3379
  r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r;
3380
  r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r;
3381
  r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r;
3382
  r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r;
3383
  r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r;
3384
  r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r;
3385
  r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r;
3386
  r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r;
3387
  r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r;
3388
  r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r;
3389
  r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r;
3390
  r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r;
3391
  r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r;
3392
  r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r;
3393
  r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r;
3394
  r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r;
3395
  r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r;
3396
  r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r;
3397
  r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r;
3398
  r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r;
3399
  r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r;
3400
  r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r;
3401
  r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r;
3402
  r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r;
3403
  r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r;
3404
  r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r;
3405
  r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r;
3406
  r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r;
3407
  r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r;
3408
  r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r;
3409
  r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r;
3410
  r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r;
3411
  r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r;
3412
  r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r;
3413
  r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r;
3414
  r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r;
3415
  r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r;
3416
  r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r;
3417
  r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r;
3418
  r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r;
3419
  r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r;
3420
  r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r;
3421
 
3422
  return r;
3423
}
3424
 
3425
#endif /* GL_VERSION_3_0 */
3426
 
3427
#ifdef GL_VERSION_3_1
3428
 
3429
static GLboolean _glewInit_GL_VERSION_3_1 (GLEW_CONTEXT_ARG_DEF_INIT)
3430
{
3431
  GLboolean r = GL_FALSE;
3432
 
3433
  r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r;
3434
  r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r;
3435
  r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r;
3436
  r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r;
3437
 
3438
  return r;
3439
}
3440
 
3441
#endif /* GL_VERSION_3_1 */
3442
 
3443
#ifdef GL_VERSION_3_2
3444
 
3445
static GLboolean _glewInit_GL_VERSION_3_2 (GLEW_CONTEXT_ARG_DEF_INIT)
3446
{
3447
  GLboolean r = GL_FALSE;
3448
 
3449
  r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r;
3450
  r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r;
3451
  r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r;
3452
 
3453
  return r;
3454
}
3455
 
3456
#endif /* GL_VERSION_3_2 */
3457
 
3458
#ifdef GL_VERSION_3_3
3459
 
3460
static GLboolean _glewInit_GL_VERSION_3_3 (GLEW_CONTEXT_ARG_DEF_INIT)
3461
{
3462
  GLboolean r = GL_FALSE;
3463
 
3464
  r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r;
3465
 
3466
  return r;
3467
}
3468
 
3469
#endif /* GL_VERSION_3_3 */
3470
 
3471
#ifdef GL_VERSION_4_0
3472
 
3473
static GLboolean _glewInit_GL_VERSION_4_0 (GLEW_CONTEXT_ARG_DEF_INIT)
3474
{
3475
  GLboolean r = GL_FALSE;
3476
 
3477
  r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r;
3478
  r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r;
3479
  r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r;
3480
  r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r;
3481
  r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r;
3482
 
3483
  return r;
3484
}
3485
 
3486
#endif /* GL_VERSION_4_0 */
3487
 
3488
#ifdef GL_VERSION_4_1
3489
 
3490
#endif /* GL_VERSION_4_1 */
3491
 
3492
#ifdef GL_VERSION_4_2
3493
 
3494
#endif /* GL_VERSION_4_2 */
3495
 
3496
#ifdef GL_VERSION_4_3
3497
 
3498
#endif /* GL_VERSION_4_3 */
3499
 
3500
#ifdef GL_3DFX_multisample
3501
 
3502
#endif /* GL_3DFX_multisample */
3503
 
3504
#ifdef GL_3DFX_tbuffer
3505
 
3506
static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)
3507
{
3508
  GLboolean r = GL_FALSE;
3509
 
3510
  r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r;
3511
 
3512
  return r;
3513
}
3514
 
3515
#endif /* GL_3DFX_tbuffer */
3516
 
3517
#ifdef GL_3DFX_texture_compression_FXT1
3518
 
3519
#endif /* GL_3DFX_texture_compression_FXT1 */
3520
 
3521
#ifdef GL_AMD_blend_minmax_factor
3522
 
3523
#endif /* GL_AMD_blend_minmax_factor */
3524
 
3525
#ifdef GL_AMD_conservative_depth
3526
 
3527
#endif /* GL_AMD_conservative_depth */
3528
 
3529
#ifdef GL_AMD_debug_output
3530
 
3531
static GLboolean _glewInit_GL_AMD_debug_output (GLEW_CONTEXT_ARG_DEF_INIT)
3532
{
3533
  GLboolean r = GL_FALSE;
3534
 
3535
  r = ((glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackAMD")) == NULL) || r;
3536
  r = ((glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageEnableAMD")) == NULL) || r;
3537
  r = ((glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertAMD")) == NULL) || r;
3538
  r = ((glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogAMD")) == NULL) || r;
3539
 
3540
  return r;
3541
}
3542
 
3543
#endif /* GL_AMD_debug_output */
3544
 
3545
#ifdef GL_AMD_depth_clamp_separate
3546
 
3547
#endif /* GL_AMD_depth_clamp_separate */
3548
 
3549
#ifdef GL_AMD_draw_buffers_blend
3550
 
3551
static GLboolean _glewInit_GL_AMD_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
3552
{
3553
  GLboolean r = GL_FALSE;
3554
 
3555
  r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r;
3556
  r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r;
3557
  r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r;
3558
  r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r;
3559
 
3560
  return r;
3561
}
3562
 
3563
#endif /* GL_AMD_draw_buffers_blend */
3564
 
3565
#ifdef GL_AMD_multi_draw_indirect
3566
 
3567
static GLboolean _glewInit_GL_AMD_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
3568
{
3569
  GLboolean r = GL_FALSE;
3570
 
3571
  r = ((glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectAMD")) == NULL) || r;
3572
  r = ((glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectAMD")) == NULL) || r;
3573
 
3574
  return r;
3575
}
3576
 
3577
#endif /* GL_AMD_multi_draw_indirect */
3578
 
3579
#ifdef GL_AMD_name_gen_delete
3580
 
3581
static GLboolean _glewInit_GL_AMD_name_gen_delete (GLEW_CONTEXT_ARG_DEF_INIT)
3582
{
3583
  GLboolean r = GL_FALSE;
3584
 
3585
  r = ((glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamesAMD")) == NULL) || r;
3586
  r = ((glGenNamesAMD = (PFNGLGENNAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glGenNamesAMD")) == NULL) || r;
3587
  r = ((glIsNameAMD = (PFNGLISNAMEAMDPROC)glewGetProcAddress((const GLubyte*)"glIsNameAMD")) == NULL) || r;
3588
 
3589
  return r;
3590
}
3591
 
3592
#endif /* GL_AMD_name_gen_delete */
3593
 
3594
#ifdef GL_AMD_performance_monitor
3595
 
3596
static GLboolean _glewInit_GL_AMD_performance_monitor (GLEW_CONTEXT_ARG_DEF_INIT)
3597
{
3598
  GLboolean r = GL_FALSE;
3599
 
3600
  r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r;
3601
  r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r;
3602
  r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r;
3603
  r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r;
3604
  r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r;
3605
  r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r;
3606
  r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r;
3607
  r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r;
3608
  r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r;
3609
  r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r;
3610
  r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r;
3611
 
3612
  return r;
3613
}
3614
 
3615
#endif /* GL_AMD_performance_monitor */
3616
 
3617
#ifdef GL_AMD_pinned_memory
3618
 
3619
#endif /* GL_AMD_pinned_memory */
3620
 
3621
#ifdef GL_AMD_query_buffer_object
3622
 
3623
#endif /* GL_AMD_query_buffer_object */
3624
 
3625
#ifdef GL_AMD_sample_positions
3626
 
3627
static GLboolean _glewInit_GL_AMD_sample_positions (GLEW_CONTEXT_ARG_DEF_INIT)
3628
{
3629
  GLboolean r = GL_FALSE;
3630
 
3631
  r = ((glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC)glewGetProcAddress((const GLubyte*)"glSetMultisamplefvAMD")) == NULL) || r;
3632
 
3633
  return r;
3634
}
3635
 
3636
#endif /* GL_AMD_sample_positions */
3637
 
3638
#ifdef GL_AMD_seamless_cubemap_per_texture
3639
 
3640
#endif /* GL_AMD_seamless_cubemap_per_texture */
3641
 
3642
#ifdef GL_AMD_shader_stencil_export
3643
 
3644
#endif /* GL_AMD_shader_stencil_export */
3645
 
3646
#ifdef GL_AMD_stencil_operation_extended
3647
 
3648
static GLboolean _glewInit_GL_AMD_stencil_operation_extended (GLEW_CONTEXT_ARG_DEF_INIT)
3649
{
3650
  GLboolean r = GL_FALSE;
3651
 
3652
  r = ((glStencilOpValueAMD = (PFNGLSTENCILOPVALUEAMDPROC)glewGetProcAddress((const GLubyte*)"glStencilOpValueAMD")) == NULL) || r;
3653
 
3654
  return r;
3655
}
3656
 
3657
#endif /* GL_AMD_stencil_operation_extended */
3658
 
3659
#ifdef GL_AMD_texture_texture4
3660
 
3661
#endif /* GL_AMD_texture_texture4 */
3662
 
3663
#ifdef GL_AMD_transform_feedback3_lines_triangles
3664
 
3665
#endif /* GL_AMD_transform_feedback3_lines_triangles */
3666
 
3667
#ifdef GL_AMD_vertex_shader_layer
3668
 
3669
#endif /* GL_AMD_vertex_shader_layer */
3670
 
3671
#ifdef GL_AMD_vertex_shader_tessellator
3672
 
3673
static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (GLEW_CONTEXT_ARG_DEF_INIT)
3674
{
3675
  GLboolean r = GL_FALSE;
3676
 
3677
  r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r;
3678
  r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r;
3679
 
3680
  return r;
3681
}
3682
 
3683
#endif /* GL_AMD_vertex_shader_tessellator */
3684
 
3685
#ifdef GL_AMD_vertex_shader_viewport_index
3686
 
3687
#endif /* GL_AMD_vertex_shader_viewport_index */
3688
 
3689
#ifdef GL_APPLE_aux_depth_stencil
3690
 
3691
#endif /* GL_APPLE_aux_depth_stencil */
3692
 
3693
#ifdef GL_APPLE_client_storage
3694
 
3695
#endif /* GL_APPLE_client_storage */
3696
 
3697
#ifdef GL_APPLE_element_array
3698
 
3699
static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT)
3700
{
3701
  GLboolean r = GL_FALSE;
3702
 
3703
  r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r;
3704
  r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r;
3705
  r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r;
3706
  r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r;
3707
  r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r;
3708
 
3709
  return r;
3710
}
3711
 
3712
#endif /* GL_APPLE_element_array */
3713
 
3714
#ifdef GL_APPLE_fence
3715
 
3716
static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT)
3717
{
3718
  GLboolean r = GL_FALSE;
3719
 
3720
  r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r;
3721
  r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r;
3722
  r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r;
3723
  r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r;
3724
  r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r;
3725
  r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r;
3726
  r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r;
3727
  r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r;
3728
 
3729
  return r;
3730
}
3731
 
3732
#endif /* GL_APPLE_fence */
3733
 
3734
#ifdef GL_APPLE_float_pixels
3735
 
3736
#endif /* GL_APPLE_float_pixels */
3737
 
3738
#ifdef GL_APPLE_flush_buffer_range
3739
 
3740
static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
3741
{
3742
  GLboolean r = GL_FALSE;
3743
 
3744
  r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r;
3745
  r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r;
3746
 
3747
  return r;
3748
}
3749
 
3750
#endif /* GL_APPLE_flush_buffer_range */
3751
 
3752
#ifdef GL_APPLE_object_purgeable
3753
 
3754
static GLboolean _glewInit_GL_APPLE_object_purgeable (GLEW_CONTEXT_ARG_DEF_INIT)
3755
{
3756
  GLboolean r = GL_FALSE;
3757
 
3758
  r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r;
3759
  r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r;
3760
  r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r;
3761
 
3762
  return r;
3763
}
3764
 
3765
#endif /* GL_APPLE_object_purgeable */
3766
 
3767
#ifdef GL_APPLE_pixel_buffer
3768
 
3769
#endif /* GL_APPLE_pixel_buffer */
3770
 
3771
#ifdef GL_APPLE_rgb_422
3772
 
3773
#endif /* GL_APPLE_rgb_422 */
3774
 
3775
#ifdef GL_APPLE_row_bytes
3776
 
3777
#endif /* GL_APPLE_row_bytes */
3778
 
3779
#ifdef GL_APPLE_specular_vector
3780
 
3781
#endif /* GL_APPLE_specular_vector */
3782
 
3783
#ifdef GL_APPLE_texture_range
3784
 
3785
static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT)
3786
{
3787
  GLboolean r = GL_FALSE;
3788
 
3789
  r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r;
3790
  r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r;
3791
 
3792
  return r;
3793
}
3794
 
3795
#endif /* GL_APPLE_texture_range */
3796
 
3797
#ifdef GL_APPLE_transform_hint
3798
 
3799
#endif /* GL_APPLE_transform_hint */
3800
 
3801
#ifdef GL_APPLE_vertex_array_object
3802
 
3803
static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
3804
{
3805
  GLboolean r = GL_FALSE;
3806
 
3807
  r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r;
3808
  r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r;
3809
  r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r;
3810
  r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r;
3811
 
3812
  return r;
3813
}
3814
 
3815
#endif /* GL_APPLE_vertex_array_object */
3816
 
3817
#ifdef GL_APPLE_vertex_array_range
3818
 
3819
static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
3820
{
3821
  GLboolean r = GL_FALSE;
3822
 
3823
  r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r;
3824
  r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r;
3825
  r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r;
3826
 
3827
  return r;
3828
}
3829
 
3830
#endif /* GL_APPLE_vertex_array_range */
3831
 
3832
#ifdef GL_APPLE_vertex_program_evaluators
3833
 
3834
static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
3835
{
3836
  GLboolean r = GL_FALSE;
3837
 
3838
  r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r;
3839
  r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r;
3840
  r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r;
3841
  r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r;
3842
  r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r;
3843
  r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r;
3844
  r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r;
3845
 
3846
  return r;
3847
}
3848
 
3849
#endif /* GL_APPLE_vertex_program_evaluators */
3850
 
3851
#ifdef GL_APPLE_ycbcr_422
3852
 
3853
#endif /* GL_APPLE_ycbcr_422 */
3854
 
3855
#ifdef GL_ARB_ES2_compatibility
3856
 
3857
static GLboolean _glewInit_GL_ARB_ES2_compatibility (GLEW_CONTEXT_ARG_DEF_INIT)
3858
{
3859
  GLboolean r = GL_FALSE;
3860
 
3861
  r = ((glClearDepthf = (PFNGLCLEARDEPTHFPROC)glewGetProcAddress((const GLubyte*)"glClearDepthf")) == NULL) || r;
3862
  r = ((glDepthRangef = (PFNGLDEPTHRANGEFPROC)glewGetProcAddress((const GLubyte*)"glDepthRangef")) == NULL) || r;
3863
  r = ((glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glewGetProcAddress((const GLubyte*)"glGetShaderPrecisionFormat")) == NULL) || r;
3864
  r = ((glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glewGetProcAddress((const GLubyte*)"glReleaseShaderCompiler")) == NULL) || r;
3865
  r = ((glShaderBinary = (PFNGLSHADERBINARYPROC)glewGetProcAddress((const GLubyte*)"glShaderBinary")) == NULL) || r;
3866
 
3867
  return r;
3868
}
3869
 
3870
#endif /* GL_ARB_ES2_compatibility */
3871
 
3872
#ifdef GL_ARB_ES3_compatibility
3873
 
3874
#endif /* GL_ARB_ES3_compatibility */
3875
 
3876
#ifdef GL_ARB_arrays_of_arrays
3877
 
3878
#endif /* GL_ARB_arrays_of_arrays */
3879
 
3880
#ifdef GL_ARB_base_instance
3881
 
3882
static GLboolean _glewInit_GL_ARB_base_instance (GLEW_CONTEXT_ARG_DEF_INIT)
3883
{
3884
  GLboolean r = GL_FALSE;
3885
 
3886
  r = ((glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstance")) == NULL) || r;
3887
  r = ((glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstance")) == NULL) || r;
3888
  r = ((glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstance")) == NULL) || r;
3889
 
3890
  return r;
3891
}
3892
 
3893
#endif /* GL_ARB_base_instance */
3894
 
3895
#ifdef GL_ARB_blend_func_extended
3896
 
3897
static GLboolean _glewInit_GL_ARB_blend_func_extended (GLEW_CONTEXT_ARG_DEF_INIT)
3898
{
3899
  GLboolean r = GL_FALSE;
3900
 
3901
  r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r;
3902
  r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r;
3903
 
3904
  return r;
3905
}
3906
 
3907
#endif /* GL_ARB_blend_func_extended */
3908
 
3909
#ifdef GL_ARB_cl_event
3910
 
3911
static GLboolean _glewInit_GL_ARB_cl_event (GLEW_CONTEXT_ARG_DEF_INIT)
3912
{
3913
  GLboolean r = GL_FALSE;
3914
 
3915
  r = ((glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateSyncFromCLeventARB")) == NULL) || r;
3916
 
3917
  return r;
3918
}
3919
 
3920
#endif /* GL_ARB_cl_event */
3921
 
3922
#ifdef GL_ARB_clear_buffer_object
3923
 
3924
static GLboolean _glewInit_GL_ARB_clear_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
3925
{
3926
  GLboolean r = GL_FALSE;
3927
 
3928
  r = ((glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferData")) == NULL) || r;
3929
  r = ((glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferSubData")) == NULL) || r;
3930
  r = ((glClearNamedBufferDataEXT = (PFNGLCLEARNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferDataEXT")) == NULL) || r;
3931
  r = ((glClearNamedBufferSubDataEXT = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferSubDataEXT")) == NULL) || r;
3932
 
3933
  return r;
3934
}
3935
 
3936
#endif /* GL_ARB_clear_buffer_object */
3937
 
3938
#ifdef GL_ARB_color_buffer_float
3939
 
3940
static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
3941
{
3942
  GLboolean r = GL_FALSE;
3943
 
3944
  r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r;
3945
 
3946
  return r;
3947
}
3948
 
3949
#endif /* GL_ARB_color_buffer_float */
3950
 
3951
#ifdef GL_ARB_compatibility
3952
 
3953
#endif /* GL_ARB_compatibility */
3954
 
3955
#ifdef GL_ARB_compressed_texture_pixel_storage
3956
 
3957
#endif /* GL_ARB_compressed_texture_pixel_storage */
3958
 
3959
#ifdef GL_ARB_compute_shader
3960
 
3961
static GLboolean _glewInit_GL_ARB_compute_shader (GLEW_CONTEXT_ARG_DEF_INIT)
3962
{
3963
  GLboolean r = GL_FALSE;
3964
 
3965
  r = ((glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)glewGetProcAddress((const GLubyte*)"glDispatchCompute")) == NULL) || r;
3966
  r = ((glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeIndirect")) == NULL) || r;
3967
 
3968
  return r;
3969
}
3970
 
3971
#endif /* GL_ARB_compute_shader */
3972
 
3973
#ifdef GL_ARB_conservative_depth
3974
 
3975
#endif /* GL_ARB_conservative_depth */
3976
 
3977
#ifdef GL_ARB_copy_buffer
3978
 
3979
static GLboolean _glewInit_GL_ARB_copy_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
3980
{
3981
  GLboolean r = GL_FALSE;
3982
 
3983
  r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r;
3984
 
3985
  return r;
3986
}
3987
 
3988
#endif /* GL_ARB_copy_buffer */
3989
 
3990
#ifdef GL_ARB_copy_image
3991
 
3992
static GLboolean _glewInit_GL_ARB_copy_image (GLEW_CONTEXT_ARG_DEF_INIT)
3993
{
3994
  GLboolean r = GL_FALSE;
3995
 
3996
  r = ((glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubData")) == NULL) || r;
3997
 
3998
  return r;
3999
}
4000
 
4001
#endif /* GL_ARB_copy_image */
4002
 
4003
#ifdef GL_ARB_debug_output
4004
 
4005
static GLboolean _glewInit_GL_ARB_debug_output (GLEW_CONTEXT_ARG_DEF_INIT)
4006
{
4007
  GLboolean r = GL_FALSE;
4008
 
4009
  r = ((glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackARB")) == NULL) || r;
4010
  r = ((glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControlARB")) == NULL) || r;
4011
  r = ((glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertARB")) == NULL) || r;
4012
  r = ((glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogARB")) == NULL) || r;
4013
 
4014
  return r;
4015
}
4016
 
4017
#endif /* GL_ARB_debug_output */
4018
 
4019
#ifdef GL_ARB_depth_buffer_float
4020
 
4021
#endif /* GL_ARB_depth_buffer_float */
4022
 
4023
#ifdef GL_ARB_depth_clamp
4024
 
4025
#endif /* GL_ARB_depth_clamp */
4026
 
4027
#ifdef GL_ARB_depth_texture
4028
 
4029
#endif /* GL_ARB_depth_texture */
4030
 
4031
#ifdef GL_ARB_draw_buffers
4032
 
4033
static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
4034
{
4035
  GLboolean r = GL_FALSE;
4036
 
4037
  r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r;
4038
 
4039
  return r;
4040
}
4041
 
4042
#endif /* GL_ARB_draw_buffers */
4043
 
4044
#ifdef GL_ARB_draw_buffers_blend
4045
 
4046
static GLboolean _glewInit_GL_ARB_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
4047
{
4048
  GLboolean r = GL_FALSE;
4049
 
4050
  r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r;
4051
  r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r;
4052
  r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r;
4053
  r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r;
4054
 
4055
  return r;
4056
}
4057
 
4058
#endif /* GL_ARB_draw_buffers_blend */
4059
 
4060
#ifdef GL_ARB_draw_elements_base_vertex
4061
 
4062
static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
4063
{
4064
  GLboolean r = GL_FALSE;
4065
 
4066
  r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r;
4067
  r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r;
4068
  r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r;
4069
  r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r;
4070
 
4071
  return r;
4072
}
4073
 
4074
#endif /* GL_ARB_draw_elements_base_vertex */
4075
 
4076
#ifdef GL_ARB_draw_indirect
4077
 
4078
static GLboolean _glewInit_GL_ARB_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
4079
{
4080
  GLboolean r = GL_FALSE;
4081
 
4082
  r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r;
4083
  r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r;
4084
 
4085
  return r;
4086
}
4087
 
4088
#endif /* GL_ARB_draw_indirect */
4089
 
4090
#ifdef GL_ARB_draw_instanced
4091
 
4092
#endif /* GL_ARB_draw_instanced */
4093
 
4094
#ifdef GL_ARB_explicit_attrib_location
4095
 
4096
#endif /* GL_ARB_explicit_attrib_location */
4097
 
4098
#ifdef GL_ARB_explicit_uniform_location
4099
 
4100
#endif /* GL_ARB_explicit_uniform_location */
4101
 
4102
#ifdef GL_ARB_fragment_coord_conventions
4103
 
4104
#endif /* GL_ARB_fragment_coord_conventions */
4105
 
4106
#ifdef GL_ARB_fragment_layer_viewport
4107
 
4108
#endif /* GL_ARB_fragment_layer_viewport */
4109
 
4110
#ifdef GL_ARB_fragment_program
4111
 
4112
#endif /* GL_ARB_fragment_program */
4113
 
4114
#ifdef GL_ARB_fragment_program_shadow
4115
 
4116
#endif /* GL_ARB_fragment_program_shadow */
4117
 
4118
#ifdef GL_ARB_fragment_shader
4119
 
4120
#endif /* GL_ARB_fragment_shader */
4121
 
4122
#ifdef GL_ARB_framebuffer_no_attachments
4123
 
4124
static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (GLEW_CONTEXT_ARG_DEF_INIT)
4125
{
4126
  GLboolean r = GL_FALSE;
4127
 
4128
  r = ((glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glFramebufferParameteri")) == NULL) || r;
4129
  r = ((glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameteriv")) == NULL) || r;
4130
  r = ((glGetNamedFramebufferParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameterivEXT")) == NULL) || r;
4131
  r = ((glNamedFramebufferParameteriEXT = (PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferParameteriEXT")) == NULL) || r;
4132
 
4133
  return r;
4134
}
4135
 
4136
#endif /* GL_ARB_framebuffer_no_attachments */
4137
 
4138
#ifdef GL_ARB_framebuffer_object
4139
 
4140
static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
4141
{
4142
  GLboolean r = GL_FALSE;
4143
 
4144
  r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r;
4145
  r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r;
4146
  r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r;
4147
  r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r;
4148
  r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r;
4149
  r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r;
4150
  r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r;
4151
  r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r;
4152
  r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r;
4153
  r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r;
4154
  r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r;
4155
  r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r;
4156
  r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r;
4157
  r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r;
4158
  r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r;
4159
  r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r;
4160
  r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r;
4161
  r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r;
4162
  r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r;
4163
  r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r;
4164
 
4165
  return r;
4166
}
4167
 
4168
#endif /* GL_ARB_framebuffer_object */
4169
 
4170
#ifdef GL_ARB_framebuffer_sRGB
4171
 
4172
#endif /* GL_ARB_framebuffer_sRGB */
4173
 
4174
#ifdef GL_ARB_geometry_shader4
4175
 
4176
static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
4177
{
4178
  GLboolean r = GL_FALSE;
4179
 
4180
  r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r;
4181
  r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r;
4182
  r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r;
4183
  r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r;
4184
 
4185
  return r;
4186
}
4187
 
4188
#endif /* GL_ARB_geometry_shader4 */
4189
 
4190
#ifdef GL_ARB_get_program_binary
4191
 
4192
static GLboolean _glewInit_GL_ARB_get_program_binary (GLEW_CONTEXT_ARG_DEF_INIT)
4193
{
4194
  GLboolean r = GL_FALSE;
4195
 
4196
  r = ((glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinary")) == NULL) || r;
4197
  r = ((glProgramBinary = (PFNGLPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glProgramBinary")) == NULL) || r;
4198
  r = ((glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteri")) == NULL) || r;
4199
 
4200
  return r;
4201
}
4202
 
4203
#endif /* GL_ARB_get_program_binary */
4204
 
4205
#ifdef GL_ARB_gpu_shader5
4206
 
4207
#endif /* GL_ARB_gpu_shader5 */
4208
 
4209
#ifdef GL_ARB_gpu_shader_fp64
4210
 
4211
static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (GLEW_CONTEXT_ARG_DEF_INIT)
4212
{
4213
  GLboolean r = GL_FALSE;
4214
 
4215
  r = ((glGetUniformdv = (PFNGLGETUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformdv")) == NULL) || r;
4216
  r = ((glUniform1d = (PFNGLUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glUniform1d")) == NULL) || r;
4217
  r = ((glUniform1dv = (PFNGLUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glUniform1dv")) == NULL) || r;
4218
  r = ((glUniform2d = (PFNGLUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glUniform2d")) == NULL) || r;
4219
  r = ((glUniform2dv = (PFNGLUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glUniform2dv")) == NULL) || r;
4220
  r = ((glUniform3d = (PFNGLUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glUniform3d")) == NULL) || r;
4221
  r = ((glUniform3dv = (PFNGLUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glUniform3dv")) == NULL) || r;
4222
  r = ((glUniform4d = (PFNGLUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glUniform4d")) == NULL) || r;
4223
  r = ((glUniform4dv = (PFNGLUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glUniform4dv")) == NULL) || r;
4224
  r = ((glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2dv")) == NULL) || r;
4225
  r = ((glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3dv")) == NULL) || r;
4226
  r = ((glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4dv")) == NULL) || r;
4227
  r = ((glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3dv")) == NULL) || r;
4228
  r = ((glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2dv")) == NULL) || r;
4229
  r = ((glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4dv")) == NULL) || r;
4230
  r = ((glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4dv")) == NULL) || r;
4231
  r = ((glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2dv")) == NULL) || r;
4232
  r = ((glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3dv")) == NULL) || r;
4233
 
4234
  return r;
4235
}
4236
 
4237
#endif /* GL_ARB_gpu_shader_fp64 */
4238
 
4239
#ifdef GL_ARB_half_float_pixel
4240
 
4241
#endif /* GL_ARB_half_float_pixel */
4242
 
4243
#ifdef GL_ARB_half_float_vertex
4244
 
4245
#endif /* GL_ARB_half_float_vertex */
4246
 
4247
#ifdef GL_ARB_imaging
4248
 
4249
static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT)
4250
{
4251
  GLboolean r = GL_FALSE;
4252
 
4253
  r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
4254
  r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r;
4255
  r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r;
4256
  r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r;
4257
  r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r;
4258
  r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r;
4259
  r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r;
4260
  r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r;
4261
  r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r;
4262
  r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r;
4263
  r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r;
4264
  r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r;
4265
  r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r;
4266
  r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r;
4267
  r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r;
4268
  r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r;
4269
  r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r;
4270
  r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r;
4271
  r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r;
4272
  r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r;
4273
  r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r;
4274
  r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r;
4275
  r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r;
4276
  r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r;
4277
  r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r;
4278
  r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r;
4279
  r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r;
4280
  r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r;
4281
  r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r;
4282
  r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r;
4283
  r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r;
4284
  r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r;
4285
  r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r;
4286
 
4287
  return r;
4288
}
4289
 
4290
#endif /* GL_ARB_imaging */
4291
 
4292
#ifdef GL_ARB_instanced_arrays
4293
 
4294
static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
4295
{
4296
  GLboolean r = GL_FALSE;
4297
 
4298
  r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r;
4299
  r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r;
4300
  r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r;
4301
 
4302
  return r;
4303
}
4304
 
4305
#endif /* GL_ARB_instanced_arrays */
4306
 
4307
#ifdef GL_ARB_internalformat_query
4308
 
4309
static GLboolean _glewInit_GL_ARB_internalformat_query (GLEW_CONTEXT_ARG_DEF_INIT)
4310
{
4311
  GLboolean r = GL_FALSE;
4312
 
4313
  r = ((glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformativ")) == NULL) || r;
4314
 
4315
  return r;
4316
}
4317
 
4318
#endif /* GL_ARB_internalformat_query */
4319
 
4320
#ifdef GL_ARB_internalformat_query2
4321
 
4322
static GLboolean _glewInit_GL_ARB_internalformat_query2 (GLEW_CONTEXT_ARG_DEF_INIT)
4323
{
4324
  GLboolean r = GL_FALSE;
4325
 
4326
  r = ((glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformati64v")) == NULL) || r;
4327
 
4328
  return r;
4329
}
4330
 
4331
#endif /* GL_ARB_internalformat_query2 */
4332
 
4333
#ifdef GL_ARB_invalidate_subdata
4334
 
4335
static GLboolean _glewInit_GL_ARB_invalidate_subdata (GLEW_CONTEXT_ARG_DEF_INIT)
4336
{
4337
  GLboolean r = GL_FALSE;
4338
 
4339
  r = ((glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferData")) == NULL) || r;
4340
  r = ((glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferSubData")) == NULL) || r;
4341
  r = ((glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateFramebuffer")) == NULL) || r;
4342
  r = ((glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateSubFramebuffer")) == NULL) || r;
4343
  r = ((glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexImage")) == NULL) || r;
4344
  r = ((glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexSubImage")) == NULL) || r;
4345
 
4346
  return r;
4347
}
4348
 
4349
#endif /* GL_ARB_invalidate_subdata */
4350
 
4351
#ifdef GL_ARB_map_buffer_alignment
4352
 
4353
#endif /* GL_ARB_map_buffer_alignment */
4354
 
4355
#ifdef GL_ARB_map_buffer_range
4356
 
4357
static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
4358
{
4359
  GLboolean r = GL_FALSE;
4360
 
4361
  r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r;
4362
  r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r;
4363
 
4364
  return r;
4365
}
4366
 
4367
#endif /* GL_ARB_map_buffer_range */
4368
 
4369
#ifdef GL_ARB_matrix_palette
4370
 
4371
static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT)
4372
{
4373
  GLboolean r = GL_FALSE;
4374
 
4375
  r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r;
4376
  r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r;
4377
  r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r;
4378
  r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r;
4379
  r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r;
4380
 
4381
  return r;
4382
}
4383
 
4384
#endif /* GL_ARB_matrix_palette */
4385
 
4386
#ifdef GL_ARB_multi_draw_indirect
4387
 
4388
static GLboolean _glewInit_GL_ARB_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
4389
{
4390
  GLboolean r = GL_FALSE;
4391
 
4392
  r = ((glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirect")) == NULL) || r;
4393
  r = ((glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirect")) == NULL) || r;
4394
 
4395
  return r;
4396
}
4397
 
4398
#endif /* GL_ARB_multi_draw_indirect */
4399
 
4400
#ifdef GL_ARB_multisample
4401
 
4402
static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
4403
{
4404
  GLboolean r = GL_FALSE;
4405
 
4406
  r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r;
4407
 
4408
  return r;
4409
}
4410
 
4411
#endif /* GL_ARB_multisample */
4412
 
4413
#ifdef GL_ARB_multitexture
4414
 
4415
static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)
4416
{
4417
  GLboolean r = GL_FALSE;
4418
 
4419
  r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r;
4420
  r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r;
4421
  r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r;
4422
  r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r;
4423
  r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r;
4424
  r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r;
4425
  r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r;
4426
  r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r;
4427
  r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r;
4428
  r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r;
4429
  r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r;
4430
  r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r;
4431
  r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r;
4432
  r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r;
4433
  r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r;
4434
  r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r;
4435
  r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r;
4436
  r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r;
4437
  r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r;
4438
  r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r;
4439
  r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r;
4440
  r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r;
4441
  r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r;
4442
  r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;
4443
  r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;
4444
  r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;
4445
  r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;
4446
  r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;
4447
  r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;
4448
  r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;
4449
  r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;
4450
  r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;
4451
  r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;
4452
  r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;
4453
 
4454
  return r;
4455
}
4456
 
4457
#endif /* GL_ARB_multitexture */
4458
 
4459
#ifdef GL_ARB_occlusion_query
4460
 
4461
static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
4462
{
4463
  GLboolean r = GL_FALSE;
4464
 
4465
  r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;
4466
  r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;
4467
  r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;
4468
  r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;
4469
  r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;
4470
  r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;
4471
  r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;
4472
  r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;
4473
 
4474
  return r;
4475
}
4476
 
4477
#endif /* GL_ARB_occlusion_query */
4478
 
4479
#ifdef GL_ARB_occlusion_query2
4480
 
4481
#endif /* GL_ARB_occlusion_query2 */
4482
 
4483
#ifdef GL_ARB_pixel_buffer_object
4484
 
4485
#endif /* GL_ARB_pixel_buffer_object */
4486
 
4487
#ifdef GL_ARB_point_parameters
4488
 
4489
static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
4490
{
4491
  GLboolean r = GL_FALSE;
4492
 
4493
  r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;
4494
  r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;
4495
 
4496
  return r;
4497
}
4498
 
4499
#endif /* GL_ARB_point_parameters */
4500
 
4501
#ifdef GL_ARB_point_sprite
4502
 
4503
#endif /* GL_ARB_point_sprite */
4504
 
4505
#ifdef GL_ARB_program_interface_query
4506
 
4507
static GLboolean _glewInit_GL_ARB_program_interface_query (GLEW_CONTEXT_ARG_DEF_INIT)
4508
{
4509
  GLboolean r = GL_FALSE;
4510
 
4511
  r = ((glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInterfaceiv")) == NULL) || r;
4512
  r = ((glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceIndex")) == NULL) || r;
4513
  r = ((glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocation")) == NULL) || r;
4514
  r = ((glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocationIndex")) == NULL) || r;
4515
  r = ((glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceName")) == NULL) || r;
4516
  r = ((glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceiv")) == NULL) || r;
4517
 
4518
  return r;
4519
}
4520
 
4521
#endif /* GL_ARB_program_interface_query */
4522
 
4523
#ifdef GL_ARB_provoking_vertex
4524
 
4525
static GLboolean _glewInit_GL_ARB_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
4526
{
4527
  GLboolean r = GL_FALSE;
4528
 
4529
  r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r;
4530
 
4531
  return r;
4532
}
4533
 
4534
#endif /* GL_ARB_provoking_vertex */
4535
 
4536
#ifdef GL_ARB_robust_buffer_access_behavior
4537
 
4538
#endif /* GL_ARB_robust_buffer_access_behavior */
4539
 
4540
#ifdef GL_ARB_robustness
4541
 
4542
static GLboolean _glewInit_GL_ARB_robustness (GLEW_CONTEXT_ARG_DEF_INIT)
4543
{
4544
  GLboolean r = GL_FALSE;
4545
 
4546
  r = ((glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusARB")) == NULL) || r;
4547
  r = ((glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnColorTableARB")) == NULL) || r;
4548
  r = ((glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImageARB")) == NULL) || r;
4549
  r = ((glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnConvolutionFilterARB")) == NULL) || r;
4550
  r = ((glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glGetnHistogramARB")) == NULL) || r;
4551
  r = ((glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapdvARB")) == NULL) || r;
4552
  r = ((glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapfvARB")) == NULL) || r;
4553
  r = ((glGetnMapivARB = (PFNGLGETNMAPIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapivARB")) == NULL) || r;
4554
  r = ((glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMinmaxARB")) == NULL) || r;
4555
  r = ((glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapfvARB")) == NULL) || r;
4556
  r = ((glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapuivARB")) == NULL) || r;
4557
  r = ((glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapusvARB")) == NULL) || r;
4558
  r = ((glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPolygonStippleARB")) == NULL) || r;
4559
  r = ((glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnSeparableFilterARB")) == NULL) || r;
4560
  r = ((glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImageARB")) == NULL) || r;
4561
  r = ((glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdvARB")) == NULL) || r;
4562
  r = ((glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvARB")) == NULL) || r;
4563
  r = ((glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivARB")) == NULL) || r;
4564
  r = ((glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuivARB")) == NULL) || r;
4565
  r = ((glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsARB")) == NULL) || r;
4566
 
4567
  return r;
4568
}
4569
 
4570
#endif /* GL_ARB_robustness */
4571
 
4572
#ifdef GL_ARB_robustness_application_isolation
4573
 
4574
#endif /* GL_ARB_robustness_application_isolation */
4575
 
4576
#ifdef GL_ARB_robustness_share_group_isolation
4577
 
4578
#endif /* GL_ARB_robustness_share_group_isolation */
4579
 
4580
#ifdef GL_ARB_sample_shading
4581
 
4582
static GLboolean _glewInit_GL_ARB_sample_shading (GLEW_CONTEXT_ARG_DEF_INIT)
4583
{
4584
  GLboolean r = GL_FALSE;
4585
 
4586
  r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r;
4587
 
4588
  return r;
4589
}
4590
 
4591
#endif /* GL_ARB_sample_shading */
4592
 
4593
#ifdef GL_ARB_sampler_objects
4594
 
4595
static GLboolean _glewInit_GL_ARB_sampler_objects (GLEW_CONTEXT_ARG_DEF_INIT)
4596
{
4597
  GLboolean r = GL_FALSE;
4598
 
4599
  r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r;
4600
  r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r;
4601
  r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r;
4602
  r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r;
4603
  r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r;
4604
  r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r;
4605
  r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r;
4606
  r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r;
4607
  r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r;
4608
  r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r;
4609
  r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r;
4610
  r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r;
4611
  r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r;
4612
  r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r;
4613
 
4614
  return r;
4615
}
4616
 
4617
#endif /* GL_ARB_sampler_objects */
4618
 
4619
#ifdef GL_ARB_seamless_cube_map
4620
 
4621
#endif /* GL_ARB_seamless_cube_map */
4622
 
4623
#ifdef GL_ARB_separate_shader_objects
4624
 
4625
static GLboolean _glewInit_GL_ARB_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
4626
{
4627
  GLboolean r = GL_FALSE;
4628
 
4629
  r = ((glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glActiveShaderProgram")) == NULL) || r;
4630
  r = ((glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glBindProgramPipeline")) == NULL) || r;
4631
  r = ((glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramv")) == NULL) || r;
4632
  r = ((glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramPipelines")) == NULL) || r;
4633
  r = ((glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glGenProgramPipelines")) == NULL) || r;
4634
  r = ((glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineInfoLog")) == NULL) || r;
4635
  r = ((glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineiv")) == NULL) || r;
4636
  r = ((glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glIsProgramPipeline")) == NULL) || r;
4637
  r = ((glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1d")) == NULL) || r;
4638
  r = ((glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dv")) == NULL) || r;
4639
  r = ((glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1f")) == NULL) || r;
4640
  r = ((glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fv")) == NULL) || r;
4641
  r = ((glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i")) == NULL) || r;
4642
  r = ((glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iv")) == NULL) || r;
4643
  r = ((glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui")) == NULL) || r;
4644
  r = ((glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiv")) == NULL) || r;
4645
  r = ((glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2d")) == NULL) || r;
4646
  r = ((glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dv")) == NULL) || r;
4647
  r = ((glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2f")) == NULL) || r;
4648
  r = ((glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fv")) == NULL) || r;
4649
  r = ((glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i")) == NULL) || r;
4650
  r = ((glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iv")) == NULL) || r;
4651
  r = ((glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui")) == NULL) || r;
4652
  r = ((glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiv")) == NULL) || r;
4653
  r = ((glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3d")) == NULL) || r;
4654
  r = ((glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dv")) == NULL) || r;
4655
  r = ((glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3f")) == NULL) || r;
4656
  r = ((glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fv")) == NULL) || r;
4657
  r = ((glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i")) == NULL) || r;
4658
  r = ((glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iv")) == NULL) || r;
4659
  r = ((glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui")) == NULL) || r;
4660
  r = ((glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiv")) == NULL) || r;
4661
  r = ((glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4d")) == NULL) || r;
4662
  r = ((glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dv")) == NULL) || r;
4663
  r = ((glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4f")) == NULL) || r;
4664
  r = ((glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fv")) == NULL) || r;
4665
  r = ((glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i")) == NULL) || r;
4666
  r = ((glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iv")) == NULL) || r;
4667
  r = ((glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui")) == NULL) || r;
4668
  r = ((glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiv")) == NULL) || r;
4669
  r = ((glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dv")) == NULL) || r;
4670
  r = ((glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fv")) == NULL) || r;
4671
  r = ((glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dv")) == NULL) || r;
4672
  r = ((glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fv")) == NULL) || r;
4673
  r = ((glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dv")) == NULL) || r;
4674
  r = ((glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fv")) == NULL) || r;
4675
  r = ((glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dv")) == NULL) || r;
4676
  r = ((glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fv")) == NULL) || r;
4677
  r = ((glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dv")) == NULL) || r;
4678
  r = ((glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fv")) == NULL) || r;
4679
  r = ((glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dv")) == NULL) || r;
4680
  r = ((glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fv")) == NULL) || r;
4681
  r = ((glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dv")) == NULL) || r;
4682
  r = ((glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fv")) == NULL) || r;
4683
  r = ((glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dv")) == NULL) || r;
4684
  r = ((glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fv")) == NULL) || r;
4685
  r = ((glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dv")) == NULL) || r;
4686
  r = ((glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fv")) == NULL) || r;
4687
  r = ((glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glewGetProcAddress((const GLubyte*)"glUseProgramStages")) == NULL) || r;
4688
  r = ((glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramPipeline")) == NULL) || r;
4689
 
4690
  return r;
4691
}
4692
 
4693
#endif /* GL_ARB_separate_shader_objects */
4694
 
4695
#ifdef GL_ARB_shader_atomic_counters
4696
 
4697
static GLboolean _glewInit_GL_ARB_shader_atomic_counters (GLEW_CONTEXT_ARG_DEF_INIT)
4698
{
4699
  GLboolean r = GL_FALSE;
4700
 
4701
  r = ((glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAtomicCounterBufferiv")) == NULL) || r;
4702
 
4703
  return r;
4704
}
4705
 
4706
#endif /* GL_ARB_shader_atomic_counters */
4707
 
4708
#ifdef GL_ARB_shader_bit_encoding
4709
 
4710
#endif /* GL_ARB_shader_bit_encoding */
4711
 
4712
#ifdef GL_ARB_shader_image_load_store
4713
 
4714
static GLboolean _glewInit_GL_ARB_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
4715
{
4716
  GLboolean r = GL_FALSE;
4717
 
4718
  r = ((glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glBindImageTexture")) == NULL) || r;
4719
  r = ((glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrier")) == NULL) || r;
4720
 
4721
  return r;
4722
}
4723
 
4724
#endif /* GL_ARB_shader_image_load_store */
4725
 
4726
#ifdef GL_ARB_shader_image_size
4727
 
4728
#endif /* GL_ARB_shader_image_size */
4729
 
4730
#ifdef GL_ARB_shader_objects
4731
 
4732
static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
4733
{
4734
  GLboolean r = GL_FALSE;
4735
 
4736
  r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;
4737
  r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;
4738
  r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;
4739
  r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;
4740
  r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;
4741
  r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;
4742
  r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;
4743
  r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;
4744
  r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;
4745
  r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;
4746
  r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;
4747
  r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;
4748
  r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;
4749
  r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;
4750
  r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;
4751
  r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;
4752
  r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;
4753
  r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;
4754
  r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;
4755
  r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;
4756
  r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;
4757
  r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;
4758
  r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;
4759
  r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;
4760
  r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;
4761
  r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;
4762
  r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;
4763
  r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;
4764
  r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;
4765
  r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;
4766
  r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;
4767
  r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;
4768
  r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;
4769
  r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;
4770
  r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;
4771
  r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;
4772
  r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;
4773
  r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;
4774
  r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;
4775
 
4776
  return r;
4777
}
4778
 
4779
#endif /* GL_ARB_shader_objects */
4780
 
4781
#ifdef GL_ARB_shader_precision
4782
 
4783
#endif /* GL_ARB_shader_precision */
4784
 
4785
#ifdef GL_ARB_shader_stencil_export
4786
 
4787
#endif /* GL_ARB_shader_stencil_export */
4788
 
4789
#ifdef GL_ARB_shader_storage_buffer_object
4790
 
4791
static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
4792
{
4793
  GLboolean r = GL_FALSE;
4794
 
4795
  r = ((glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glShaderStorageBlockBinding")) == NULL) || r;
4796
 
4797
  return r;
4798
}
4799
 
4800
#endif /* GL_ARB_shader_storage_buffer_object */
4801
 
4802
#ifdef GL_ARB_shader_subroutine
4803
 
4804
static GLboolean _glewInit_GL_ARB_shader_subroutine (GLEW_CONTEXT_ARG_DEF_INIT)
4805
{
4806
  GLboolean r = GL_FALSE;
4807
 
4808
  r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r;
4809
  r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r;
4810
  r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r;
4811
  r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r;
4812
  r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r;
4813
  r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r;
4814
  r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r;
4815
  r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r;
4816
 
4817
  return r;
4818
}
4819
 
4820
#endif /* GL_ARB_shader_subroutine */
4821
 
4822
#ifdef GL_ARB_shader_texture_lod
4823
 
4824
#endif /* GL_ARB_shader_texture_lod */
4825
 
4826
#ifdef GL_ARB_shading_language_100
4827
 
4828
#endif /* GL_ARB_shading_language_100 */
4829
 
4830
#ifdef GL_ARB_shading_language_420pack
4831
 
4832
#endif /* GL_ARB_shading_language_420pack */
4833
 
4834
#ifdef GL_ARB_shading_language_include
4835
 
4836
static GLboolean _glewInit_GL_ARB_shading_language_include (GLEW_CONTEXT_ARG_DEF_INIT)
4837
{
4838
  GLboolean r = GL_FALSE;
4839
 
4840
  r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r;
4841
  r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r;
4842
  r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r;
4843
  r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r;
4844
  r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r;
4845
  r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r;
4846
 
4847
  return r;
4848
}
4849
 
4850
#endif /* GL_ARB_shading_language_include */
4851
 
4852
#ifdef GL_ARB_shading_language_packing
4853
 
4854
#endif /* GL_ARB_shading_language_packing */
4855
 
4856
#ifdef GL_ARB_shadow
4857
 
4858
#endif /* GL_ARB_shadow */
4859
 
4860
#ifdef GL_ARB_shadow_ambient
4861
 
4862
#endif /* GL_ARB_shadow_ambient */
4863
 
4864
#ifdef GL_ARB_stencil_texturing
4865
 
4866
#endif /* GL_ARB_stencil_texturing */
4867
 
4868
#ifdef GL_ARB_sync
4869
 
4870
static GLboolean _glewInit_GL_ARB_sync (GLEW_CONTEXT_ARG_DEF_INIT)
4871
{
4872
  GLboolean r = GL_FALSE;
4873
 
4874
  r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r;
4875
  r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r;
4876
  r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r;
4877
  r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r;
4878
  r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r;
4879
  r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r;
4880
  r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r;
4881
 
4882
  return r;
4883
}
4884
 
4885
#endif /* GL_ARB_sync */
4886
 
4887
#ifdef GL_ARB_tessellation_shader
4888
 
4889
static GLboolean _glewInit_GL_ARB_tessellation_shader (GLEW_CONTEXT_ARG_DEF_INIT)
4890
{
4891
  GLboolean r = GL_FALSE;
4892
 
4893
  r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r;
4894
  r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r;
4895
 
4896
  return r;
4897
}
4898
 
4899
#endif /* GL_ARB_tessellation_shader */
4900
 
4901
#ifdef GL_ARB_texture_border_clamp
4902
 
4903
#endif /* GL_ARB_texture_border_clamp */
4904
 
4905
#ifdef GL_ARB_texture_buffer_object
4906
 
4907
static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
4908
{
4909
  GLboolean r = GL_FALSE;
4910
 
4911
  r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;
4912
 
4913
  return r;
4914
}
4915
 
4916
#endif /* GL_ARB_texture_buffer_object */
4917
 
4918
#ifdef GL_ARB_texture_buffer_object_rgb32
4919
 
4920
#endif /* GL_ARB_texture_buffer_object_rgb32 */
4921
 
4922
#ifdef GL_ARB_texture_buffer_range
4923
 
4924
static GLboolean _glewInit_GL_ARB_texture_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
4925
{
4926
  GLboolean r = GL_FALSE;
4927
 
4928
  r = ((glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTexBufferRange")) == NULL) || r;
4929
  r = ((glTextureBufferRangeEXT = (PFNGLTEXTUREBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferRangeEXT")) == NULL) || r;
4930
 
4931
  return r;
4932
}
4933
 
4934
#endif /* GL_ARB_texture_buffer_range */
4935
 
4936
#ifdef GL_ARB_texture_compression
4937
 
4938
static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)
4939
{
4940
  GLboolean r = GL_FALSE;
4941
 
4942
  r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;
4943
  r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;
4944
  r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;
4945
  r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;
4946
  r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;
4947
  r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;
4948
  r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;
4949
 
4950
  return r;
4951
}
4952
 
4953
#endif /* GL_ARB_texture_compression */
4954
 
4955
#ifdef GL_ARB_texture_compression_bptc
4956
 
4957
#endif /* GL_ARB_texture_compression_bptc */
4958
 
4959
#ifdef GL_ARB_texture_compression_rgtc
4960
 
4961
#endif /* GL_ARB_texture_compression_rgtc */
4962
 
4963
#ifdef GL_ARB_texture_cube_map
4964
 
4965
#endif /* GL_ARB_texture_cube_map */
4966
 
4967
#ifdef GL_ARB_texture_cube_map_array
4968
 
4969
#endif /* GL_ARB_texture_cube_map_array */
4970
 
4971
#ifdef GL_ARB_texture_env_add
4972
 
4973
#endif /* GL_ARB_texture_env_add */
4974
 
4975
#ifdef GL_ARB_texture_env_combine
4976
 
4977
#endif /* GL_ARB_texture_env_combine */
4978
 
4979
#ifdef GL_ARB_texture_env_crossbar
4980
 
4981
#endif /* GL_ARB_texture_env_crossbar */
4982
 
4983
#ifdef GL_ARB_texture_env_dot3
4984
 
4985
#endif /* GL_ARB_texture_env_dot3 */
4986
 
4987
#ifdef GL_ARB_texture_float
4988
 
4989
#endif /* GL_ARB_texture_float */
4990
 
4991
#ifdef GL_ARB_texture_gather
4992
 
4993
#endif /* GL_ARB_texture_gather */
4994
 
4995
#ifdef GL_ARB_texture_mirrored_repeat
4996
 
4997
#endif /* GL_ARB_texture_mirrored_repeat */
4998
 
4999
#ifdef GL_ARB_texture_multisample
5000
 
5001
static GLboolean _glewInit_GL_ARB_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
5002
{
5003
  GLboolean r = GL_FALSE;
5004
 
5005
  r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r;
5006
  r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r;
5007
  r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r;
5008
  r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r;
5009
 
5010
  return r;
5011
}
5012
 
5013
#endif /* GL_ARB_texture_multisample */
5014
 
5015
#ifdef GL_ARB_texture_non_power_of_two
5016
 
5017
#endif /* GL_ARB_texture_non_power_of_two */
5018
 
5019
#ifdef GL_ARB_texture_query_levels
5020
 
5021
#endif /* GL_ARB_texture_query_levels */
5022
 
5023
#ifdef GL_ARB_texture_query_lod
5024
 
5025
#endif /* GL_ARB_texture_query_lod */
5026
 
5027
#ifdef GL_ARB_texture_rectangle
5028
 
5029
#endif /* GL_ARB_texture_rectangle */
5030
 
5031
#ifdef GL_ARB_texture_rg
5032
 
5033
#endif /* GL_ARB_texture_rg */
5034
 
5035
#ifdef GL_ARB_texture_rgb10_a2ui
5036
 
5037
#endif /* GL_ARB_texture_rgb10_a2ui */
5038
 
5039
#ifdef GL_ARB_texture_storage
5040
 
5041
static GLboolean _glewInit_GL_ARB_texture_storage (GLEW_CONTEXT_ARG_DEF_INIT)
5042
{
5043
  GLboolean r = GL_FALSE;
5044
 
5045
  r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r;
5046
  r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r;
5047
  r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r;
5048
  r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r;
5049
  r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r;
5050
  r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r;
5051
 
5052
  return r;
5053
}
5054
 
5055
#endif /* GL_ARB_texture_storage */
5056
 
5057
#ifdef GL_ARB_texture_storage_multisample
5058
 
5059
static GLboolean _glewInit_GL_ARB_texture_storage_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
5060
{
5061
  GLboolean r = GL_FALSE;
5062
 
5063
  r = ((glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2DMultisample")) == NULL) || r;
5064
  r = ((glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DMultisample")) == NULL) || r;
5065
  r = ((glTextureStorage2DMultisampleEXT = (PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DMultisampleEXT")) == NULL) || r;
5066
  r = ((glTextureStorage3DMultisampleEXT = (PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DMultisampleEXT")) == NULL) || r;
5067
 
5068
  return r;
5069
}
5070
 
5071
#endif /* GL_ARB_texture_storage_multisample */
5072
 
5073
#ifdef GL_ARB_texture_swizzle
5074
 
5075
#endif /* GL_ARB_texture_swizzle */
5076
 
5077
#ifdef GL_ARB_texture_view
5078
 
5079
static GLboolean _glewInit_GL_ARB_texture_view (GLEW_CONTEXT_ARG_DEF_INIT)
5080
{
5081
  GLboolean r = GL_FALSE;
5082
 
5083
  r = ((glTextureView = (PFNGLTEXTUREVIEWPROC)glewGetProcAddress((const GLubyte*)"glTextureView")) == NULL) || r;
5084
 
5085
  return r;
5086
}
5087
 
5088
#endif /* GL_ARB_texture_view */
5089
 
5090
#ifdef GL_ARB_timer_query
5091
 
5092
static GLboolean _glewInit_GL_ARB_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
5093
{
5094
  GLboolean r = GL_FALSE;
5095
 
5096
  r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r;
5097
  r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r;
5098
  r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r;
5099
 
5100
  return r;
5101
}
5102
 
5103
#endif /* GL_ARB_timer_query */
5104
 
5105
#ifdef GL_ARB_transform_feedback2
5106
 
5107
static GLboolean _glewInit_GL_ARB_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
5108
{
5109
  GLboolean r = GL_FALSE;
5110
 
5111
  r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r;
5112
  r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r;
5113
  r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r;
5114
  r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r;
5115
  r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r;
5116
  r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r;
5117
  r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r;
5118
 
5119
  return r;
5120
}
5121
 
5122
#endif /* GL_ARB_transform_feedback2 */
5123
 
5124
#ifdef GL_ARB_transform_feedback3
5125
 
5126
static GLboolean _glewInit_GL_ARB_transform_feedback3 (GLEW_CONTEXT_ARG_DEF_INIT)
5127
{
5128
  GLboolean r = GL_FALSE;
5129
 
5130
  r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r;
5131
  r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r;
5132
  r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r;
5133
  r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r;
5134
 
5135
  return r;
5136
}
5137
 
5138
#endif /* GL_ARB_transform_feedback3 */
5139
 
5140
#ifdef GL_ARB_transform_feedback_instanced
5141
 
5142
static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
5143
{
5144
  GLboolean r = GL_FALSE;
5145
 
5146
  r = ((glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstanced")) == NULL) || r;
5147
  r = ((glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStreamInstanced")) == NULL) || r;
5148
 
5149
  return r;
5150
}
5151
 
5152
#endif /* GL_ARB_transform_feedback_instanced */
5153
 
5154
#ifdef GL_ARB_transpose_matrix
5155
 
5156
static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)
5157
{
5158
  GLboolean r = GL_FALSE;
5159
 
5160
  r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r;
5161
  r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r;
5162
  r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r;
5163
  r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r;
5164
 
5165
  return r;
5166
}
5167
 
5168
#endif /* GL_ARB_transpose_matrix */
5169
 
5170
#ifdef GL_ARB_uniform_buffer_object
5171
 
5172
static GLboolean _glewInit_GL_ARB_uniform_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
5173
{
5174
  GLboolean r = GL_FALSE;
5175
 
5176
  r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;
5177
  r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;
5178
  r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r;
5179
  r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r;
5180
  r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r;
5181
  r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r;
5182
  r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;
5183
  r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r;
5184
  r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r;
5185
  r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r;
5186
 
5187
  return r;
5188
}
5189
 
5190
#endif /* GL_ARB_uniform_buffer_object */
5191
 
5192
#ifdef GL_ARB_vertex_array_bgra
5193
 
5194
#endif /* GL_ARB_vertex_array_bgra */
5195
 
5196
#ifdef GL_ARB_vertex_array_object
5197
 
5198
static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
5199
{
5200
  GLboolean r = GL_FALSE;
5201
 
5202
  r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r;
5203
  r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r;
5204
  r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r;
5205
  r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r;
5206
 
5207
  return r;
5208
}
5209
 
5210
#endif /* GL_ARB_vertex_array_object */
5211
 
5212
#ifdef GL_ARB_vertex_attrib_64bit
5213
 
5214
static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
5215
{
5216
  GLboolean r = GL_FALSE;
5217
 
5218
  r = ((glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdv")) == NULL) || r;
5219
  r = ((glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1d")) == NULL) || r;
5220
  r = ((glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dv")) == NULL) || r;
5221
  r = ((glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2d")) == NULL) || r;
5222
  r = ((glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dv")) == NULL) || r;
5223
  r = ((glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3d")) == NULL) || r;
5224
  r = ((glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dv")) == NULL) || r;
5225
  r = ((glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4d")) == NULL) || r;
5226
  r = ((glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dv")) == NULL) || r;
5227
  r = ((glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointer")) == NULL) || r;
5228
 
5229
  return r;
5230
}
5231
 
5232
#endif /* GL_ARB_vertex_attrib_64bit */
5233
 
5234
#ifdef GL_ARB_vertex_attrib_binding
5235
 
5236
static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (GLEW_CONTEXT_ARG_DEF_INIT)
5237
{
5238
  GLboolean r = GL_FALSE;
5239
 
5240
  r = ((glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffer")) == NULL) || r;
5241
  r = ((glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribBinding")) == NULL) || r;
5242
  r = ((glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormat")) == NULL) || r;
5243
  r = ((glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormat")) == NULL) || r;
5244
  r = ((glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormat")) == NULL) || r;
5245
  r = ((glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexBindingDivisor")) == NULL) || r;
5246
 
5247
  return r;
5248
}
5249
 
5250
#endif /* GL_ARB_vertex_attrib_binding */
5251
 
5252
#ifdef GL_ARB_vertex_blend
5253
 
5254
static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT)
5255
{
5256
  GLboolean r = GL_FALSE;
5257
 
5258
  r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r;
5259
  r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r;
5260
  r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r;
5261
  r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r;
5262
  r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r;
5263
  r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r;
5264
  r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r;
5265
  r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r;
5266
  r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r;
5267
  r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r;
5268
 
5269
  return r;
5270
}
5271
 
5272
#endif /* GL_ARB_vertex_blend */
5273
 
5274
#ifdef GL_ARB_vertex_buffer_object
5275
 
5276
static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
5277
{
5278
  GLboolean r = GL_FALSE;
5279
 
5280
  r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;
5281
  r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;
5282
  r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;
5283
  r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;
5284
  r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;
5285
  r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;
5286
  r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;
5287
  r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;
5288
  r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;
5289
  r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;
5290
  r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;
5291
 
5292
  return r;
5293
}
5294
 
5295
#endif /* GL_ARB_vertex_buffer_object */
5296
 
5297
#ifdef GL_ARB_vertex_program
5298
 
5299
static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
5300
{
5301
  GLboolean r = GL_FALSE;
5302
 
5303
  r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;
5304
  r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;
5305
  r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;
5306
  r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;
5307
  r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;
5308
  r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;
5309
  r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;
5310
  r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;
5311
  r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;
5312
  r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;
5313
  r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;
5314
  r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;
5315
  r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;
5316
  r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;
5317
  r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;
5318
  r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;
5319
  r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;
5320
  r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;
5321
  r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;
5322
  r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;
5323
  r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;
5324
  r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;
5325
  r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;
5326
  r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;
5327
  r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;
5328
  r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;
5329
  r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;
5330
  r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;
5331
  r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;
5332
  r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;
5333
  r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;
5334
  r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;
5335
  r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;
5336
  r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;
5337
  r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;
5338
  r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;
5339
  r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;
5340
  r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;
5341
  r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;
5342
  r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;
5343
  r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;
5344
  r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;
5345
  r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;
5346
  r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;
5347
  r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;
5348
  r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;
5349
  r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;
5350
  r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;
5351
  r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;
5352
  r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;
5353
  r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;
5354
  r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;
5355
  r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;
5356
  r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;
5357
  r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;
5358
  r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;
5359
  r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;
5360
  r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;
5361
  r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;
5362
  r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;
5363
  r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;
5364
  r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;
5365
 
5366
  return r;
5367
}
5368
 
5369
#endif /* GL_ARB_vertex_program */
5370
 
5371
#ifdef GL_ARB_vertex_shader
5372
 
5373
static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
5374
{
5375
  GLboolean r = GL_FALSE;
5376
 
5377
  r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;
5378
  r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;
5379
  r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;
5380
 
5381
  return r;
5382
}
5383
 
5384
#endif /* GL_ARB_vertex_shader */
5385
 
5386
#ifdef GL_ARB_vertex_type_2_10_10_10_rev
5387
 
5388
static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (GLEW_CONTEXT_ARG_DEF_INIT)
5389
{
5390
  GLboolean r = GL_FALSE;
5391
 
5392
  r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r;
5393
  r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r;
5394
  r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r;
5395
  r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r;
5396
  r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r;
5397
  r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r;
5398
  r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r;
5399
  r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r;
5400
  r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r;
5401
  r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r;
5402
  r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r;
5403
  r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r;
5404
  r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r;
5405
  r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r;
5406
  r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r;
5407
  r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r;
5408
  r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r;
5409
  r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r;
5410
  r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r;
5411
  r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r;
5412
  r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r;
5413
  r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r;
5414
  r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r;
5415
  r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r;
5416
  r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r;
5417
  r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r;
5418
  r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r;
5419
  r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r;
5420
  r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r;
5421
  r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r;
5422
  r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r;
5423
  r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r;
5424
  r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r;
5425
  r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r;
5426
  r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r;
5427
  r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r;
5428
  r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r;
5429
  r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r;
5430
 
5431
  return r;
5432
}
5433
 
5434
#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
5435
 
5436
#ifdef GL_ARB_viewport_array
5437
 
5438
static GLboolean _glewInit_GL_ARB_viewport_array (GLEW_CONTEXT_ARG_DEF_INIT)
5439
{
5440
  GLboolean r = GL_FALSE;
5441
 
5442
  r = ((glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayv")) == NULL) || r;
5443
  r = ((glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexed")) == NULL) || r;
5444
  r = ((glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_v")) == NULL) || r;
5445
  r = ((glGetFloati_v = (PFNGLGETFLOATI_VPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_v")) == NULL) || r;
5446
  r = ((glScissorArrayv = (PFNGLSCISSORARRAYVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayv")) == NULL) || r;
5447
  r = ((glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexed")) == NULL) || r;
5448
  r = ((glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedv")) == NULL) || r;
5449
  r = ((glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayv")) == NULL) || r;
5450
  r = ((glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedf")) == NULL) || r;
5451
  r = ((glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfv")) == NULL) || r;
5452
 
5453
  return r;
5454
}
5455
 
5456
#endif /* GL_ARB_viewport_array */
5457
 
5458
#ifdef GL_ARB_window_pos
5459
 
5460
static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
5461
{
5462
  GLboolean r = GL_FALSE;
5463
 
5464
  r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r;
5465
  r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r;
5466
  r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r;
5467
  r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r;
5468
  r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r;
5469
  r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r;
5470
  r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r;
5471
  r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r;
5472
  r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r;
5473
  r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r;
5474
  r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r;
5475
  r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r;
5476
  r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r;
5477
  r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r;
5478
  r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r;
5479
  r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r;
5480
 
5481
  return r;
5482
}
5483
 
5484
#endif /* GL_ARB_window_pos */
5485
 
5486
#ifdef GL_ATIX_point_sprites
5487
 
5488
#endif /* GL_ATIX_point_sprites */
5489
 
5490
#ifdef GL_ATIX_texture_env_combine3
5491
 
5492
#endif /* GL_ATIX_texture_env_combine3 */
5493
 
5494
#ifdef GL_ATIX_texture_env_route
5495
 
5496
#endif /* GL_ATIX_texture_env_route */
5497
 
5498
#ifdef GL_ATIX_vertex_shader_output_point_size
5499
 
5500
#endif /* GL_ATIX_vertex_shader_output_point_size */
5501
 
5502
#ifdef GL_ATI_draw_buffers
5503
 
5504
static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
5505
{
5506
  GLboolean r = GL_FALSE;
5507
 
5508
  r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;
5509
 
5510
  return r;
5511
}
5512
 
5513
#endif /* GL_ATI_draw_buffers */
5514
 
5515
#ifdef GL_ATI_element_array
5516
 
5517
static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT)
5518
{
5519
  GLboolean r = GL_FALSE;
5520
 
5521
  r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r;
5522
  r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r;
5523
  r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r;
5524
 
5525
  return r;
5526
}
5527
 
5528
#endif /* GL_ATI_element_array */
5529
 
5530
#ifdef GL_ATI_envmap_bumpmap
5531
 
5532
static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT)
5533
{
5534
  GLboolean r = GL_FALSE;
5535
 
5536
  r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r;
5537
  r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r;
5538
  r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r;
5539
  r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r;
5540
 
5541
  return r;
5542
}
5543
 
5544
#endif /* GL_ATI_envmap_bumpmap */
5545
 
5546
#ifdef GL_ATI_fragment_shader
5547
 
5548
static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)
5549
{
5550
  GLboolean r = GL_FALSE;
5551
 
5552
  r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;
5553
  r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;
5554
  r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;
5555
  r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;
5556
  r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;
5557
  r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;
5558
  r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;
5559
  r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;
5560
  r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;
5561
  r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;
5562
  r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;
5563
  r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;
5564
  r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;
5565
  r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;
5566
 
5567
  return r;
5568
}
5569
 
5570
#endif /* GL_ATI_fragment_shader */
5571
 
5572
#ifdef GL_ATI_map_object_buffer
5573
 
5574
static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
5575
{
5576
  GLboolean r = GL_FALSE;
5577
 
5578
  r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r;
5579
  r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r;
5580
 
5581
  return r;
5582
}
5583
 
5584
#endif /* GL_ATI_map_object_buffer */
5585
 
5586
#ifdef GL_ATI_meminfo
5587
 
5588
#endif /* GL_ATI_meminfo */
5589
 
5590
#ifdef GL_ATI_pn_triangles
5591
 
5592
static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)
5593
{
5594
  GLboolean r = GL_FALSE;
5595
 
5596
  r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r;
5597
  r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r;
5598
 
5599
  return r;
5600
}
5601
 
5602
#endif /* GL_ATI_pn_triangles */
5603
 
5604
#ifdef GL_ATI_separate_stencil
5605
 
5606
static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT)
5607
{
5608
  GLboolean r = GL_FALSE;
5609
 
5610
  r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r;
5611
  r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r;
5612
 
5613
  return r;
5614
}
5615
 
5616
#endif /* GL_ATI_separate_stencil */
5617
 
5618
#ifdef GL_ATI_shader_texture_lod
5619
 
5620
#endif /* GL_ATI_shader_texture_lod */
5621
 
5622
#ifdef GL_ATI_text_fragment_shader
5623
 
5624
#endif /* GL_ATI_text_fragment_shader */
5625
 
5626
#ifdef GL_ATI_texture_compression_3dc
5627
 
5628
#endif /* GL_ATI_texture_compression_3dc */
5629
 
5630
#ifdef GL_ATI_texture_env_combine3
5631
 
5632
#endif /* GL_ATI_texture_env_combine3 */
5633
 
5634
#ifdef GL_ATI_texture_float
5635
 
5636
#endif /* GL_ATI_texture_float */
5637
 
5638
#ifdef GL_ATI_texture_mirror_once
5639
 
5640
#endif /* GL_ATI_texture_mirror_once */
5641
 
5642
#ifdef GL_ATI_vertex_array_object
5643
 
5644
static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
5645
{
5646
  GLboolean r = GL_FALSE;
5647
 
5648
  r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r;
5649
  r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r;
5650
  r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r;
5651
  r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r;
5652
  r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r;
5653
  r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r;
5654
  r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r;
5655
  r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r;
5656
  r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r;
5657
  r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r;
5658
  r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r;
5659
  r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r;
5660
 
5661
  return r;
5662
}
5663
 
5664
#endif /* GL_ATI_vertex_array_object */
5665
 
5666
#ifdef GL_ATI_vertex_attrib_array_object
5667
 
5668
static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
5669
{
5670
  GLboolean r = GL_FALSE;
5671
 
5672
  r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r;
5673
  r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r;
5674
  r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r;
5675
 
5676
  return r;
5677
}
5678
 
5679
#endif /* GL_ATI_vertex_attrib_array_object */
5680
 
5681
#ifdef GL_ATI_vertex_streams
5682
 
5683
static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT)
5684
{
5685
  GLboolean r = GL_FALSE;
5686
 
5687
  r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r;
5688
  r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r;
5689
  r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r;
5690
  r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r;
5691
  r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r;
5692
  r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r;
5693
  r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r;
5694
  r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r;
5695
  r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r;
5696
  r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r;
5697
  r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r;
5698
  r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r;
5699
  r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r;
5700
  r = ((glVertexStream1dATI = (PFNGLVERTEXSTREAM1DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dATI")) == NULL) || r;
5701
  r = ((glVertexStream1dvATI = (PFNGLVERTEXSTREAM1DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dvATI")) == NULL) || r;
5702
  r = ((glVertexStream1fATI = (PFNGLVERTEXSTREAM1FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fATI")) == NULL) || r;
5703
  r = ((glVertexStream1fvATI = (PFNGLVERTEXSTREAM1FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fvATI")) == NULL) || r;
5704
  r = ((glVertexStream1iATI = (PFNGLVERTEXSTREAM1IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1iATI")) == NULL) || r;
5705
  r = ((glVertexStream1ivATI = (PFNGLVERTEXSTREAM1IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1ivATI")) == NULL) || r;
5706
  r = ((glVertexStream1sATI = (PFNGLVERTEXSTREAM1SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1sATI")) == NULL) || r;
5707
  r = ((glVertexStream1svATI = (PFNGLVERTEXSTREAM1SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1svATI")) == NULL) || r;
5708
  r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r;
5709
  r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r;
5710
  r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r;
5711
  r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r;
5712
  r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r;
5713
  r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r;
5714
  r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r;
5715
  r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r;
5716
  r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r;
5717
  r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r;
5718
  r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r;
5719
  r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r;
5720
  r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r;
5721
  r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r;
5722
  r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r;
5723
  r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r;
5724
  r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r;
5725
  r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r;
5726
  r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r;
5727
  r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r;
5728
  r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r;
5729
  r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r;
5730
  r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r;
5731
  r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r;
5732
 
5733
  return r;
5734
}
5735
 
5736
#endif /* GL_ATI_vertex_streams */
5737
 
5738
#ifdef GL_EXT_422_pixels
5739
 
5740
#endif /* GL_EXT_422_pixels */
5741
 
5742
#ifdef GL_EXT_Cg_shader
5743
 
5744
#endif /* GL_EXT_Cg_shader */
5745
 
5746
#ifdef GL_EXT_abgr
5747
 
5748
#endif /* GL_EXT_abgr */
5749
 
5750
#ifdef GL_EXT_bgra
5751
 
5752
#endif /* GL_EXT_bgra */
5753
 
5754
#ifdef GL_EXT_bindable_uniform
5755
 
5756
static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT)
5757
{
5758
  GLboolean r = GL_FALSE;
5759
 
5760
  r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r;
5761
  r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r;
5762
  r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r;
5763
 
5764
  return r;
5765
}
5766
 
5767
#endif /* GL_EXT_bindable_uniform */
5768
 
5769
#ifdef GL_EXT_blend_color
5770
 
5771
static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT)
5772
{
5773
  GLboolean r = GL_FALSE;
5774
 
5775
  r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r;
5776
 
5777
  return r;
5778
}
5779
 
5780
#endif /* GL_EXT_blend_color */
5781
 
5782
#ifdef GL_EXT_blend_equation_separate
5783
 
5784
static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT)
5785
{
5786
  GLboolean r = GL_FALSE;
5787
 
5788
  r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r;
5789
 
5790
  return r;
5791
}
5792
 
5793
#endif /* GL_EXT_blend_equation_separate */
5794
 
5795
#ifdef GL_EXT_blend_func_separate
5796
 
5797
static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT)
5798
{
5799
  GLboolean r = GL_FALSE;
5800
 
5801
  r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r;
5802
 
5803
  return r;
5804
}
5805
 
5806
#endif /* GL_EXT_blend_func_separate */
5807
 
5808
#ifdef GL_EXT_blend_logic_op
5809
 
5810
#endif /* GL_EXT_blend_logic_op */
5811
 
5812
#ifdef GL_EXT_blend_minmax
5813
 
5814
static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT)
5815
{
5816
  GLboolean r = GL_FALSE;
5817
 
5818
  r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r;
5819
 
5820
  return r;
5821
}
5822
 
5823
#endif /* GL_EXT_blend_minmax */
5824
 
5825
#ifdef GL_EXT_blend_subtract
5826
 
5827
#endif /* GL_EXT_blend_subtract */
5828
 
5829
#ifdef GL_EXT_clip_volume_hint
5830
 
5831
#endif /* GL_EXT_clip_volume_hint */
5832
 
5833
#ifdef GL_EXT_cmyka
5834
 
5835
#endif /* GL_EXT_cmyka */
5836
 
5837
#ifdef GL_EXT_color_subtable
5838
 
5839
static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT)
5840
{
5841
  GLboolean r = GL_FALSE;
5842
 
5843
  r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r;
5844
  r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r;
5845
 
5846
  return r;
5847
}
5848
 
5849
#endif /* GL_EXT_color_subtable */
5850
 
5851
#ifdef GL_EXT_compiled_vertex_array
5852
 
5853
static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
5854
{
5855
  GLboolean r = GL_FALSE;
5856
 
5857
  r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r;
5858
  r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r;
5859
 
5860
  return r;
5861
}
5862
 
5863
#endif /* GL_EXT_compiled_vertex_array */
5864
 
5865
#ifdef GL_EXT_convolution
5866
 
5867
static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT)
5868
{
5869
  GLboolean r = GL_FALSE;
5870
 
5871
  r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r;
5872
  r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r;
5873
  r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r;
5874
  r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r;
5875
  r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r;
5876
  r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r;
5877
  r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r;
5878
  r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r;
5879
  r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r;
5880
  r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r;
5881
  r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r;
5882
  r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r;
5883
  r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r;
5884
 
5885
  return r;
5886
}
5887
 
5888
#endif /* GL_EXT_convolution */
5889
 
5890
#ifdef GL_EXT_coordinate_frame
5891
 
5892
static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT)
5893
{
5894
  GLboolean r = GL_FALSE;
5895
 
5896
  r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r;
5897
  r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r;
5898
 
5899
  return r;
5900
}
5901
 
5902
#endif /* GL_EXT_coordinate_frame */
5903
 
5904
#ifdef GL_EXT_copy_texture
5905
 
5906
static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT)
5907
{
5908
  GLboolean r = GL_FALSE;
5909
 
5910
  r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r;
5911
  r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r;
5912
  r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r;
5913
  r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r;
5914
  r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r;
5915
 
5916
  return r;
5917
}
5918
 
5919
#endif /* GL_EXT_copy_texture */
5920
 
5921
#ifdef GL_EXT_cull_vertex
5922
 
5923
static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
5924
{
5925
  GLboolean r = GL_FALSE;
5926
 
5927
  r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r;
5928
  r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r;
5929
 
5930
  return r;
5931
}
5932
 
5933
#endif /* GL_EXT_cull_vertex */
5934
 
5935
#ifdef GL_EXT_debug_marker
5936
 
5937
static GLboolean _glewInit_GL_EXT_debug_marker (GLEW_CONTEXT_ARG_DEF_INIT)
5938
{
5939
  GLboolean r = GL_FALSE;
5940
 
5941
  r = ((glInsertEventMarkerEXT = (PFNGLINSERTEVENTMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glInsertEventMarkerEXT")) == NULL) || r;
5942
  r = ((glPopGroupMarkerEXT = (PFNGLPOPGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPopGroupMarkerEXT")) == NULL) || r;
5943
  r = ((glPushGroupMarkerEXT = (PFNGLPUSHGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPushGroupMarkerEXT")) == NULL) || r;
5944
 
5945
  return r;
5946
}
5947
 
5948
#endif /* GL_EXT_debug_marker */
5949
 
5950
#ifdef GL_EXT_depth_bounds_test
5951
 
5952
static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT)
5953
{
5954
  GLboolean r = GL_FALSE;
5955
 
5956
  r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r;
5957
 
5958
  return r;
5959
}
5960
 
5961
#endif /* GL_EXT_depth_bounds_test */
5962
 
5963
#ifdef GL_EXT_direct_state_access
5964
 
5965
static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT)
5966
{
5967
  GLboolean r = GL_FALSE;
5968
 
5969
  r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r;
5970
  r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r;
5971
  r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r;
5972
  r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r;
5973
  r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r;
5974
  r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r;
5975
  r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r;
5976
  r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r;
5977
  r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r;
5978
  r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r;
5979
  r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r;
5980
  r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r;
5981
  r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r;
5982
  r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r;
5983
  r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r;
5984
  r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r;
5985
  r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r;
5986
  r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r;
5987
  r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r;
5988
  r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r;
5989
  r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r;
5990
  r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r;
5991
  r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r;
5992
  r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r;
5993
  r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r;
5994
  r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r;
5995
  r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r;
5996
  r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r;
5997
  r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r;
5998
  r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r;
5999
  r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r;
6000
  r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r;
6001
  r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r;
6002
  r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r;
6003
  r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r;
6004
  r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r;
6005
  r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r;
6006
  r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r;
6007
  r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r;
6008
  r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r;
6009
  r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r;
6010
  r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r;
6011
  r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r;
6012
  r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r;
6013
  r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r;
6014
  r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r;
6015
  r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r;
6016
  r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r;
6017
  r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r;
6018
  r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r;
6019
  r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r;
6020
  r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r;
6021
  r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r;
6022
  r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r;
6023
  r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r;
6024
  r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r;
6025
  r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r;
6026
  r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r;
6027
  r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r;
6028
  r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r;
6029
  r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r;
6030
  r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r;
6031
  r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r;
6032
  r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r;
6033
  r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r;
6034
  r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r;
6035
  r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r;
6036
  r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r;
6037
  r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r;
6038
  r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r;
6039
  r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r;
6040
  r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r;
6041
  r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r;
6042
  r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r;
6043
  r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r;
6044
  r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r;
6045
  r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r;
6046
  r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r;
6047
  r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r;
6048
  r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r;
6049
  r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r;
6050
  r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r;
6051
  r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r;
6052
  r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r;
6053
  r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r;
6054
  r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r;
6055
  r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r;
6056
  r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r;
6057
  r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r;
6058
  r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r;
6059
  r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r;
6060
  r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r;
6061
  r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r;
6062
  r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r;
6063
  r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r;
6064
  r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r;
6065
  r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r;
6066
  r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r;
6067
  r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r;
6068
  r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r;
6069
  r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r;
6070
  r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r;
6071
  r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r;
6072
  r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r;
6073
  r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r;
6074
  r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r;
6075
  r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r;
6076
  r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r;
6077
  r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r;
6078
  r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r;
6079
  r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r;
6080
  r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r;
6081
  r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r;
6082
  r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r;
6083
  r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r;
6084
  r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r;
6085
  r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r;
6086
  r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r;
6087
  r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r;
6088
  r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r;
6089
  r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r;
6090
  r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r;
6091
  r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r;
6092
  r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r;
6093
  r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r;
6094
  r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r;
6095
  r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r;
6096
  r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;
6097
  r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;
6098
  r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;
6099
  r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r;
6100
  r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;
6101
  r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r;
6102
  r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r;
6103
  r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r;
6104
  r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r;
6105
  r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r;
6106
  r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r;
6107
  r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r;
6108
  r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r;
6109
  r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r;
6110
  r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r;
6111
  r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r;
6112
  r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r;
6113
  r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r;
6114
  r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r;
6115
  r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r;
6116
  r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r;
6117
  r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r;
6118
  r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r;
6119
  r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r;
6120
  r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r;
6121
  r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r;
6122
  r = ((glProgramUniform1dEXT = (PFNGLPROGRAMUNIFORM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dEXT")) == NULL) || r;
6123
  r = ((glProgramUniform1dvEXT = (PFNGLPROGRAMUNIFORM1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dvEXT")) == NULL) || r;
6124
  r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r;
6125
  r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r;
6126
  r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r;
6127
  r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r;
6128
  r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r;
6129
  r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r;
6130
  r = ((glProgramUniform2dEXT = (PFNGLPROGRAMUNIFORM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dEXT")) == NULL) || r;
6131
  r = ((glProgramUniform2dvEXT = (PFNGLPROGRAMUNIFORM2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dvEXT")) == NULL) || r;
6132
  r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r;
6133
  r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r;
6134
  r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r;
6135
  r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r;
6136
  r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r;
6137
  r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r;
6138
  r = ((glProgramUniform3dEXT = (PFNGLPROGRAMUNIFORM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dEXT")) == NULL) || r;
6139
  r = ((glProgramUniform3dvEXT = (PFNGLPROGRAMUNIFORM3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dvEXT")) == NULL) || r;
6140
  r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r;
6141
  r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r;
6142
  r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r;
6143
  r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r;
6144
  r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r;
6145
  r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r;
6146
  r = ((glProgramUniform4dEXT = (PFNGLPROGRAMUNIFORM4DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dEXT")) == NULL) || r;
6147
  r = ((glProgramUniform4dvEXT = (PFNGLPROGRAMUNIFORM4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dvEXT")) == NULL) || r;
6148
  r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r;
6149
  r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r;
6150
  r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r;
6151
  r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r;
6152
  r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r;
6153
  r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r;
6154
  r = ((glProgramUniformMatrix2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dvEXT")) == NULL) || r;
6155
  r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r;
6156
  r = ((glProgramUniformMatrix2x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dvEXT")) == NULL) || r;
6157
  r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r;
6158
  r = ((glProgramUniformMatrix2x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dvEXT")) == NULL) || r;
6159
  r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r;
6160
  r = ((glProgramUniformMatrix3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dvEXT")) == NULL) || r;
6161
  r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r;
6162
  r = ((glProgramUniformMatrix3x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dvEXT")) == NULL) || r;
6163
  r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r;
6164
  r = ((glProgramUniformMatrix3x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dvEXT")) == NULL) || r;
6165
  r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r;
6166
  r = ((glProgramUniformMatrix4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dvEXT")) == NULL) || r;
6167
  r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r;
6168
  r = ((glProgramUniformMatrix4x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dvEXT")) == NULL) || r;
6169
  r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r;
6170
  r = ((glProgramUniformMatrix4x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dvEXT")) == NULL) || r;
6171
  r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r;
6172
  r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r;
6173
  r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r;
6174
  r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r;
6175
  r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r;
6176
  r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r;
6177
  r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r;
6178
  r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r;
6179
  r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r;
6180
  r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r;
6181
  r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r;
6182
  r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r;
6183
  r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r;
6184
  r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r;
6185
  r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r;
6186
  r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r;
6187
  r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r;
6188
  r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r;
6189
  r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r;
6190
  r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r;
6191
  r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r;
6192
  r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r;
6193
  r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r;
6194
  r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r;
6195
  r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r;
6196
  r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r;
6197
  r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r;
6198
  r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r;
6199
 
6200
  return r;
6201
}
6202
 
6203
#endif /* GL_EXT_direct_state_access */
6204
 
6205
#ifdef GL_EXT_draw_buffers2
6206
 
6207
static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT)
6208
{
6209
  GLboolean r = GL_FALSE;
6210
 
6211
  r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r;
6212
  r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r;
6213
  r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r;
6214
  r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r;
6215
  r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r;
6216
  r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r;
6217
 
6218
  return r;
6219
}
6220
 
6221
#endif /* GL_EXT_draw_buffers2 */
6222
 
6223
#ifdef GL_EXT_draw_instanced
6224
 
6225
static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
6226
{
6227
  GLboolean r = GL_FALSE;
6228
 
6229
  r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r;
6230
  r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r;
6231
 
6232
  return r;
6233
}
6234
 
6235
#endif /* GL_EXT_draw_instanced */
6236
 
6237
#ifdef GL_EXT_draw_range_elements
6238
 
6239
static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT)
6240
{
6241
  GLboolean r = GL_FALSE;
6242
 
6243
  r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r;
6244
 
6245
  return r;
6246
}
6247
 
6248
#endif /* GL_EXT_draw_range_elements */
6249
 
6250
#ifdef GL_EXT_fog_coord
6251
 
6252
static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT)
6253
{
6254
  GLboolean r = GL_FALSE;
6255
 
6256
  r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r;
6257
  r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r;
6258
  r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r;
6259
  r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r;
6260
  r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r;
6261
 
6262
  return r;
6263
}
6264
 
6265
#endif /* GL_EXT_fog_coord */
6266
 
6267
#ifdef GL_EXT_fragment_lighting
6268
 
6269
static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT)
6270
{
6271
  GLboolean r = GL_FALSE;
6272
 
6273
  r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r;
6274
  r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r;
6275
  r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r;
6276
  r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r;
6277
  r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r;
6278
  r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r;
6279
  r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r;
6280
  r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r;
6281
  r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r;
6282
  r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r;
6283
  r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r;
6284
  r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r;
6285
  r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r;
6286
  r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r;
6287
  r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r;
6288
  r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r;
6289
  r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r;
6290
  r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r;
6291
 
6292
  return r;
6293
}
6294
 
6295
#endif /* GL_EXT_fragment_lighting */
6296
 
6297
#ifdef GL_EXT_framebuffer_blit
6298
 
6299
static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT)
6300
{
6301
  GLboolean r = GL_FALSE;
6302
 
6303
  r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r;
6304
 
6305
  return r;
6306
}
6307
 
6308
#endif /* GL_EXT_framebuffer_blit */
6309
 
6310
#ifdef GL_EXT_framebuffer_multisample
6311
 
6312
static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
6313
{
6314
  GLboolean r = GL_FALSE;
6315
 
6316
  r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r;
6317
 
6318
  return r;
6319
}
6320
 
6321
#endif /* GL_EXT_framebuffer_multisample */
6322
 
6323
#ifdef GL_EXT_framebuffer_multisample_blit_scaled
6324
 
6325
#endif /* GL_EXT_framebuffer_multisample_blit_scaled */
6326
 
6327
#ifdef GL_EXT_framebuffer_object
6328
 
6329
static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
6330
{
6331
  GLboolean r = GL_FALSE;
6332
 
6333
  r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;
6334
  r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;
6335
  r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;
6336
  r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;
6337
  r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;
6338
  r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;
6339
  r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;
6340
  r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;
6341
  r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;
6342
  r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;
6343
  r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;
6344
  r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;
6345
  r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;
6346
  r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;
6347
  r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;
6348
  r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;
6349
  r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;
6350
 
6351
  return r;
6352
}
6353
 
6354
#endif /* GL_EXT_framebuffer_object */
6355
 
6356
#ifdef GL_EXT_framebuffer_sRGB
6357
 
6358
#endif /* GL_EXT_framebuffer_sRGB */
6359
 
6360
#ifdef GL_EXT_geometry_shader4
6361
 
6362
static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
6363
{
6364
  GLboolean r = GL_FALSE;
6365
 
6366
  r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r;
6367
  r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r;
6368
  r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r;
6369
 
6370
  return r;
6371
}
6372
 
6373
#endif /* GL_EXT_geometry_shader4 */
6374
 
6375
#ifdef GL_EXT_gpu_program_parameters
6376
 
6377
static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
6378
{
6379
  GLboolean r = GL_FALSE;
6380
 
6381
  r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r;
6382
  r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r;
6383
 
6384
  return r;
6385
}
6386
 
6387
#endif /* GL_EXT_gpu_program_parameters */
6388
 
6389
#ifdef GL_EXT_gpu_shader4
6390
 
6391
static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
6392
{
6393
  GLboolean r = GL_FALSE;
6394
 
6395
  r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r;
6396
  r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r;
6397
  r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r;
6398
  r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r;
6399
  r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r;
6400
  r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r;
6401
  r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r;
6402
  r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r;
6403
  r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r;
6404
  r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r;
6405
  r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r;
6406
  r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r;
6407
  r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r;
6408
  r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r;
6409
  r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r;
6410
  r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r;
6411
  r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r;
6412
  r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r;
6413
  r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r;
6414
  r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r;
6415
  r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r;
6416
  r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r;
6417
  r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r;
6418
  r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r;
6419
  r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r;
6420
  r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r;
6421
  r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r;
6422
  r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r;
6423
  r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r;
6424
  r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r;
6425
  r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r;
6426
  r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r;
6427
  r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r;
6428
  r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r;
6429
 
6430
  return r;
6431
}
6432
 
6433
#endif /* GL_EXT_gpu_shader4 */
6434
 
6435
#ifdef GL_EXT_histogram
6436
 
6437
static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT)
6438
{
6439
  GLboolean r = GL_FALSE;
6440
 
6441
  r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r;
6442
  r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r;
6443
  r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r;
6444
  r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r;
6445
  r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r;
6446
  r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r;
6447
  r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r;
6448
  r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r;
6449
  r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r;
6450
  r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r;
6451
 
6452
  return r;
6453
}
6454
 
6455
#endif /* GL_EXT_histogram */
6456
 
6457
#ifdef GL_EXT_index_array_formats
6458
 
6459
#endif /* GL_EXT_index_array_formats */
6460
 
6461
#ifdef GL_EXT_index_func
6462
 
6463
static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT)
6464
{
6465
  GLboolean r = GL_FALSE;
6466
 
6467
  r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r;
6468
 
6469
  return r;
6470
}
6471
 
6472
#endif /* GL_EXT_index_func */
6473
 
6474
#ifdef GL_EXT_index_material
6475
 
6476
static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT)
6477
{
6478
  GLboolean r = GL_FALSE;
6479
 
6480
  r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r;
6481
 
6482
  return r;
6483
}
6484
 
6485
#endif /* GL_EXT_index_material */
6486
 
6487
#ifdef GL_EXT_index_texture
6488
 
6489
#endif /* GL_EXT_index_texture */
6490
 
6491
#ifdef GL_EXT_light_texture
6492
 
6493
static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT)
6494
{
6495
  GLboolean r = GL_FALSE;
6496
 
6497
  r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r;
6498
  r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r;
6499
  r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r;
6500
 
6501
  return r;
6502
}
6503
 
6504
#endif /* GL_EXT_light_texture */
6505
 
6506
#ifdef GL_EXT_misc_attribute
6507
 
6508
#endif /* GL_EXT_misc_attribute */
6509
 
6510
#ifdef GL_EXT_multi_draw_arrays
6511
 
6512
static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
6513
{
6514
  GLboolean r = GL_FALSE;
6515
 
6516
  r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r;
6517
  r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r;
6518
 
6519
  return r;
6520
}
6521
 
6522
#endif /* GL_EXT_multi_draw_arrays */
6523
 
6524
#ifdef GL_EXT_multisample
6525
 
6526
static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
6527
{
6528
  GLboolean r = GL_FALSE;
6529
 
6530
  r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r;
6531
  r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r;
6532
 
6533
  return r;
6534
}
6535
 
6536
#endif /* GL_EXT_multisample */
6537
 
6538
#ifdef GL_EXT_packed_depth_stencil
6539
 
6540
#endif /* GL_EXT_packed_depth_stencil */
6541
 
6542
#ifdef GL_EXT_packed_float
6543
 
6544
#endif /* GL_EXT_packed_float */
6545
 
6546
#ifdef GL_EXT_packed_pixels
6547
 
6548
#endif /* GL_EXT_packed_pixels */
6549
 
6550
#ifdef GL_EXT_paletted_texture
6551
 
6552
static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT)
6553
{
6554
  GLboolean r = GL_FALSE;
6555
 
6556
  r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r;
6557
  r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r;
6558
  r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r;
6559
  r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r;
6560
 
6561
  return r;
6562
}
6563
 
6564
#endif /* GL_EXT_paletted_texture */
6565
 
6566
#ifdef GL_EXT_pixel_buffer_object
6567
 
6568
#endif /* GL_EXT_pixel_buffer_object */
6569
 
6570
#ifdef GL_EXT_pixel_transform
6571
 
6572
static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT)
6573
{
6574
  GLboolean r = GL_FALSE;
6575
 
6576
  r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r;
6577
  r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r;
6578
  r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r;
6579
  r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r;
6580
  r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r;
6581
  r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r;
6582
 
6583
  return r;
6584
}
6585
 
6586
#endif /* GL_EXT_pixel_transform */
6587
 
6588
#ifdef GL_EXT_pixel_transform_color_table
6589
 
6590
#endif /* GL_EXT_pixel_transform_color_table */
6591
 
6592
#ifdef GL_EXT_point_parameters
6593
 
6594
static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
6595
{
6596
  GLboolean r = GL_FALSE;
6597
 
6598
  r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;
6599
  r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;
6600
 
6601
  return r;
6602
}
6603
 
6604
#endif /* GL_EXT_point_parameters */
6605
 
6606
#ifdef GL_EXT_polygon_offset
6607
 
6608
static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)
6609
{
6610
  GLboolean r = GL_FALSE;
6611
 
6612
  r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r;
6613
 
6614
  return r;
6615
}
6616
 
6617
#endif /* GL_EXT_polygon_offset */
6618
 
6619
#ifdef GL_EXT_provoking_vertex
6620
 
6621
static GLboolean _glewInit_GL_EXT_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
6622
{
6623
  GLboolean r = GL_FALSE;
6624
 
6625
  r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r;
6626
 
6627
  return r;
6628
}
6629
 
6630
#endif /* GL_EXT_provoking_vertex */
6631
 
6632
#ifdef GL_EXT_rescale_normal
6633
 
6634
#endif /* GL_EXT_rescale_normal */
6635
 
6636
#ifdef GL_EXT_scene_marker
6637
 
6638
static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT)
6639
{
6640
  GLboolean r = GL_FALSE;
6641
 
6642
  r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r;
6643
  r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r;
6644
 
6645
  return r;
6646
}
6647
 
6648
#endif /* GL_EXT_scene_marker */
6649
 
6650
#ifdef GL_EXT_secondary_color
6651
 
6652
static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)
6653
{
6654
  GLboolean r = GL_FALSE;
6655
 
6656
  r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;
6657
  r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;
6658
  r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;
6659
  r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;
6660
  r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;
6661
  r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;
6662
  r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;
6663
  r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;
6664
  r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;
6665
  r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;
6666
  r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;
6667
  r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;
6668
  r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;
6669
  r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;
6670
  r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;
6671
  r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;
6672
  r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;
6673
 
6674
  return r;
6675
}
6676
 
6677
#endif /* GL_EXT_secondary_color */
6678
 
6679
#ifdef GL_EXT_separate_shader_objects
6680
 
6681
static GLboolean _glewInit_GL_EXT_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
6682
{
6683
  GLboolean r = GL_FALSE;
6684
 
6685
  r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r;
6686
  r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r;
6687
  r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r;
6688
 
6689
  return r;
6690
}
6691
 
6692
#endif /* GL_EXT_separate_shader_objects */
6693
 
6694
#ifdef GL_EXT_separate_specular_color
6695
 
6696
#endif /* GL_EXT_separate_specular_color */
6697
 
6698
#ifdef GL_EXT_shader_image_load_store
6699
 
6700
static GLboolean _glewInit_GL_EXT_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
6701
{
6702
  GLboolean r = GL_FALSE;
6703
 
6704
  r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r;
6705
  r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r;
6706
 
6707
  return r;
6708
}
6709
 
6710
#endif /* GL_EXT_shader_image_load_store */
6711
 
6712
#ifdef GL_EXT_shadow_funcs
6713
 
6714
#endif /* GL_EXT_shadow_funcs */
6715
 
6716
#ifdef GL_EXT_shared_texture_palette
6717
 
6718
#endif /* GL_EXT_shared_texture_palette */
6719
 
6720
#ifdef GL_EXT_stencil_clear_tag
6721
 
6722
#endif /* GL_EXT_stencil_clear_tag */
6723
 
6724
#ifdef GL_EXT_stencil_two_side
6725
 
6726
static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)
6727
{
6728
  GLboolean r = GL_FALSE;
6729
 
6730
  r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;
6731
 
6732
  return r;
6733
}
6734
 
6735
#endif /* GL_EXT_stencil_two_side */
6736
 
6737
#ifdef GL_EXT_stencil_wrap
6738
 
6739
#endif /* GL_EXT_stencil_wrap */
6740
 
6741
#ifdef GL_EXT_subtexture
6742
 
6743
static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT)
6744
{
6745
  GLboolean r = GL_FALSE;
6746
 
6747
  r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r;
6748
  r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r;
6749
  r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r;
6750
 
6751
  return r;
6752
}
6753
 
6754
#endif /* GL_EXT_subtexture */
6755
 
6756
#ifdef GL_EXT_texture
6757
 
6758
#endif /* GL_EXT_texture */
6759
 
6760
#ifdef GL_EXT_texture3D
6761
 
6762
static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT)
6763
{
6764
  GLboolean r = GL_FALSE;
6765
 
6766
  r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r;
6767
 
6768
  return r;
6769
}
6770
 
6771
#endif /* GL_EXT_texture3D */
6772
 
6773
#ifdef GL_EXT_texture_array
6774
 
6775
static GLboolean _glewInit_GL_EXT_texture_array (GLEW_CONTEXT_ARG_DEF_INIT)
6776
{
6777
  GLboolean r = GL_FALSE;
6778
 
6779
  r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r;
6780
 
6781
  return r;
6782
}
6783
 
6784
#endif /* GL_EXT_texture_array */
6785
 
6786
#ifdef GL_EXT_texture_buffer_object
6787
 
6788
static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
6789
{
6790
  GLboolean r = GL_FALSE;
6791
 
6792
  r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r;
6793
 
6794
  return r;
6795
}
6796
 
6797
#endif /* GL_EXT_texture_buffer_object */
6798
 
6799
#ifdef GL_EXT_texture_compression_dxt1
6800
 
6801
#endif /* GL_EXT_texture_compression_dxt1 */
6802
 
6803
#ifdef GL_EXT_texture_compression_latc
6804
 
6805
#endif /* GL_EXT_texture_compression_latc */
6806
 
6807
#ifdef GL_EXT_texture_compression_rgtc
6808
 
6809
#endif /* GL_EXT_texture_compression_rgtc */
6810
 
6811
#ifdef GL_EXT_texture_compression_s3tc
6812
 
6813
#endif /* GL_EXT_texture_compression_s3tc */
6814
 
6815
#ifdef GL_EXT_texture_cube_map
6816
 
6817
#endif /* GL_EXT_texture_cube_map */
6818
 
6819
#ifdef GL_EXT_texture_edge_clamp
6820
 
6821
#endif /* GL_EXT_texture_edge_clamp */
6822
 
6823
#ifdef GL_EXT_texture_env
6824
 
6825
#endif /* GL_EXT_texture_env */
6826
 
6827
#ifdef GL_EXT_texture_env_add
6828
 
6829
#endif /* GL_EXT_texture_env_add */
6830
 
6831
#ifdef GL_EXT_texture_env_combine
6832
 
6833
#endif /* GL_EXT_texture_env_combine */
6834
 
6835
#ifdef GL_EXT_texture_env_dot3
6836
 
6837
#endif /* GL_EXT_texture_env_dot3 */
6838
 
6839
#ifdef GL_EXT_texture_filter_anisotropic
6840
 
6841
#endif /* GL_EXT_texture_filter_anisotropic */
6842
 
6843
#ifdef GL_EXT_texture_integer
6844
 
6845
static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT)
6846
{
6847
  GLboolean r = GL_FALSE;
6848
 
6849
  r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r;
6850
  r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r;
6851
  r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r;
6852
  r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r;
6853
  r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r;
6854
  r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r;
6855
 
6856
  return r;
6857
}
6858
 
6859
#endif /* GL_EXT_texture_integer */
6860
 
6861
#ifdef GL_EXT_texture_lod_bias
6862
 
6863
#endif /* GL_EXT_texture_lod_bias */
6864
 
6865
#ifdef GL_EXT_texture_mirror_clamp
6866
 
6867
#endif /* GL_EXT_texture_mirror_clamp */
6868
 
6869
#ifdef GL_EXT_texture_object
6870
 
6871
static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT)
6872
{
6873
  GLboolean r = GL_FALSE;
6874
 
6875
  r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r;
6876
  r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r;
6877
  r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r;
6878
  r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;
6879
  r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;
6880
  r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;
6881
 
6882
  return r;
6883
}
6884
 
6885
#endif /* GL_EXT_texture_object */
6886
 
6887
#ifdef GL_EXT_texture_perturb_normal
6888
 
6889
static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT)
6890
{
6891
  GLboolean r = GL_FALSE;
6892
 
6893
  r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;
6894
 
6895
  return r;
6896
}
6897
 
6898
#endif /* GL_EXT_texture_perturb_normal */
6899
 
6900
#ifdef GL_EXT_texture_rectangle
6901
 
6902
#endif /* GL_EXT_texture_rectangle */
6903
 
6904
#ifdef GL_EXT_texture_sRGB
6905
 
6906
#endif /* GL_EXT_texture_sRGB */
6907
 
6908
#ifdef GL_EXT_texture_sRGB_decode
6909
 
6910
#endif /* GL_EXT_texture_sRGB_decode */
6911
 
6912
#ifdef GL_EXT_texture_shared_exponent
6913
 
6914
#endif /* GL_EXT_texture_shared_exponent */
6915
 
6916
#ifdef GL_EXT_texture_snorm
6917
 
6918
#endif /* GL_EXT_texture_snorm */
6919
 
6920
#ifdef GL_EXT_texture_swizzle
6921
 
6922
#endif /* GL_EXT_texture_swizzle */
6923
 
6924
#ifdef GL_EXT_timer_query
6925
 
6926
static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
6927
{
6928
  GLboolean r = GL_FALSE;
6929
 
6930
  r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r;
6931
  r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r;
6932
 
6933
  return r;
6934
}
6935
 
6936
#endif /* GL_EXT_timer_query */
6937
 
6938
#ifdef GL_EXT_transform_feedback
6939
 
6940
static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
6941
{
6942
  GLboolean r = GL_FALSE;
6943
 
6944
  r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r;
6945
  r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r;
6946
  r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r;
6947
  r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r;
6948
  r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r;
6949
  r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r;
6950
  r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r;
6951
 
6952
  return r;
6953
}
6954
 
6955
#endif /* GL_EXT_transform_feedback */
6956
 
6957
#ifdef GL_EXT_vertex_array
6958
 
6959
static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
6960
{
6961
  GLboolean r = GL_FALSE;
6962
 
6963
  r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;
6964
  r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;
6965
  r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;
6966
  r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;
6967
  r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;
6968
  r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;
6969
  r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;
6970
  r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;
6971
 
6972
  return r;
6973
}
6974
 
6975
#endif /* GL_EXT_vertex_array */
6976
 
6977
#ifdef GL_EXT_vertex_array_bgra
6978
 
6979
#endif /* GL_EXT_vertex_array_bgra */
6980
 
6981
#ifdef GL_EXT_vertex_attrib_64bit
6982
 
6983
static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
6984
{
6985
  GLboolean r = GL_FALSE;
6986
 
6987
  r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r;
6988
  r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r;
6989
  r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r;
6990
  r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r;
6991
  r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r;
6992
  r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r;
6993
  r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r;
6994
  r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r;
6995
  r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r;
6996
  r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r;
6997
  r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r;
6998
 
6999
  return r;
7000
}
7001
 
7002
#endif /* GL_EXT_vertex_attrib_64bit */
7003
 
7004
#ifdef GL_EXT_vertex_shader
7005
 
7006
static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
7007
{
7008
  GLboolean r = GL_FALSE;
7009
 
7010
  r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;
7011
  r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;
7012
  r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;
7013
  r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;
7014
  r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;
7015
  r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;
7016
  r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;
7017
  r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;
7018
  r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;
7019
  r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;
7020
  r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;
7021
  r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;
7022
  r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;
7023
  r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;
7024
  r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;
7025
  r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;
7026
  r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;
7027
  r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;
7028
  r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;
7029
  r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;
7030
  r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;
7031
  r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;
7032
  r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;
7033
  r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;
7034
  r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;
7035
  r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;
7036
  r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;
7037
  r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;
7038
  r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;
7039
  r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;
7040
  r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;
7041
  r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;
7042
  r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;
7043
  r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;
7044
  r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;
7045
  r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;
7046
  r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;
7047
  r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;
7048
  r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;
7049
  r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;
7050
  r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;
7051
  r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;
7052
 
7053
  return r;
7054
}
7055
 
7056
#endif /* GL_EXT_vertex_shader */
7057
 
7058
#ifdef GL_EXT_vertex_weighting
7059
 
7060
static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT)
7061
{
7062
  GLboolean r = GL_FALSE;
7063
 
7064
  r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;
7065
  r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;
7066
  r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;
7067
 
7068
  return r;
7069
}
7070
 
7071
#endif /* GL_EXT_vertex_weighting */
7072
 
7073
#ifdef GL_EXT_x11_sync_object
7074
 
7075
static GLboolean _glewInit_GL_EXT_x11_sync_object (GLEW_CONTEXT_ARG_DEF_INIT)
7076
{
7077
  GLboolean r = GL_FALSE;
7078
 
7079
  r = ((glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSyncEXT")) == NULL) || r;
7080
 
7081
  return r;
7082
}
7083
 
7084
#endif /* GL_EXT_x11_sync_object */
7085
 
7086
#ifdef GL_GREMEDY_frame_terminator
7087
 
7088
static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT)
7089
{
7090
  GLboolean r = GL_FALSE;
7091
 
7092
  r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r;
7093
 
7094
  return r;
7095
}
7096
 
7097
#endif /* GL_GREMEDY_frame_terminator */
7098
 
7099
#ifdef GL_GREMEDY_string_marker
7100
 
7101
static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT)
7102
{
7103
  GLboolean r = GL_FALSE;
7104
 
7105
  r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r;
7106
 
7107
  return r;
7108
}
7109
 
7110
#endif /* GL_GREMEDY_string_marker */
7111
 
7112
#ifdef GL_HP_convolution_border_modes
7113
 
7114
#endif /* GL_HP_convolution_border_modes */
7115
 
7116
#ifdef GL_HP_image_transform
7117
 
7118
static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT)
7119
{
7120
  GLboolean r = GL_FALSE;
7121
 
7122
  r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;
7123
  r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;
7124
  r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;
7125
  r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;
7126
  r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;
7127
  r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;
7128
 
7129
  return r;
7130
}
7131
 
7132
#endif /* GL_HP_image_transform */
7133
 
7134
#ifdef GL_HP_occlusion_test
7135
 
7136
#endif /* GL_HP_occlusion_test */
7137
 
7138
#ifdef GL_HP_texture_lighting
7139
 
7140
#endif /* GL_HP_texture_lighting */
7141
 
7142
#ifdef GL_IBM_cull_vertex
7143
 
7144
#endif /* GL_IBM_cull_vertex */
7145
 
7146
#ifdef GL_IBM_multimode_draw_arrays
7147
 
7148
static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
7149
{
7150
  GLboolean r = GL_FALSE;
7151
 
7152
  r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;
7153
  r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;
7154
 
7155
  return r;
7156
}
7157
 
7158
#endif /* GL_IBM_multimode_draw_arrays */
7159
 
7160
#ifdef GL_IBM_rasterpos_clip
7161
 
7162
#endif /* GL_IBM_rasterpos_clip */
7163
 
7164
#ifdef GL_IBM_static_data
7165
 
7166
#endif /* GL_IBM_static_data */
7167
 
7168
#ifdef GL_IBM_texture_mirrored_repeat
7169
 
7170
#endif /* GL_IBM_texture_mirrored_repeat */
7171
 
7172
#ifdef GL_IBM_vertex_array_lists
7173
 
7174
static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT)
7175
{
7176
  GLboolean r = GL_FALSE;
7177
 
7178
  r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;
7179
  r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;
7180
  r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;
7181
  r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;
7182
  r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;
7183
  r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;
7184
  r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;
7185
  r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;
7186
 
7187
  return r;
7188
}
7189
 
7190
#endif /* GL_IBM_vertex_array_lists */
7191
 
7192
#ifdef GL_INGR_color_clamp
7193
 
7194
#endif /* GL_INGR_color_clamp */
7195
 
7196
#ifdef GL_INGR_interlace_read
7197
 
7198
#endif /* GL_INGR_interlace_read */
7199
 
7200
#ifdef GL_INTEL_parallel_arrays
7201
 
7202
static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
7203
{
7204
  GLboolean r = GL_FALSE;
7205
 
7206
  r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;
7207
  r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;
7208
  r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;
7209
  r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;
7210
 
7211
  return r;
7212
}
7213
 
7214
#endif /* GL_INTEL_parallel_arrays */
7215
 
7216
#ifdef GL_INTEL_texture_scissor
7217
 
7218
static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT)
7219
{
7220
  GLboolean r = GL_FALSE;
7221
 
7222
  r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;
7223
  r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;
7224
 
7225
  return r;
7226
}
7227
 
7228
#endif /* GL_INTEL_texture_scissor */
7229
 
7230
#ifdef GL_KHR_debug
7231
 
7232
static GLboolean _glewInit_GL_KHR_debug (GLEW_CONTEXT_ARG_DEF_INIT)
7233
{
7234
  GLboolean r = GL_FALSE;
7235
 
7236
  r = ((glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallback")) == NULL) || r;
7237
  r = ((glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControl")) == NULL) || r;
7238
  r = ((glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsert")) == NULL) || r;
7239
  r = ((glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLog")) == NULL) || r;
7240
  r = ((glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabel")) == NULL) || r;
7241
  r = ((glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectPtrLabel")) == NULL) || r;
7242
  r = ((glGetPointerv = (PFNGLGETPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetPointerv")) == NULL) || r;
7243
  r = ((glObjectLabel = (PFNGLOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectLabel")) == NULL) || r;
7244
  r = ((glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectPtrLabel")) == NULL) || r;
7245
  r = ((glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPushDebugGroup")) == NULL) || r;
7246
 
7247
  return r;
7248
}
7249
 
7250
#endif /* GL_KHR_debug */
7251
 
7252
#ifdef GL_KHR_texture_compression_astc_ldr
7253
 
7254
#endif /* GL_KHR_texture_compression_astc_ldr */
7255
 
7256
#ifdef GL_KTX_buffer_region
7257
 
7258
static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT)
7259
{
7260
  GLboolean r = GL_FALSE;
7261
 
7262
  r = ((glBufferRegionEnabled = (PFNGLBUFFERREGIONENABLEDPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabled")) == NULL) || r;
7263
  r = ((glDeleteBufferRegion = (PFNGLDELETEBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegion")) == NULL) || r;
7264
  r = ((glDrawBufferRegion = (PFNGLDRAWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegion")) == NULL) || r;
7265
  r = ((glNewBufferRegion = (PFNGLNEWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegion")) == NULL) || r;
7266
  r = ((glReadBufferRegion = (PFNGLREADBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegion")) == NULL) || r;
7267
 
7268
  return r;
7269
}
7270
 
7271
#endif /* GL_KTX_buffer_region */
7272
 
7273
#ifdef GL_MESAX_texture_stack
7274
 
7275
#endif /* GL_MESAX_texture_stack */
7276
 
7277
#ifdef GL_MESA_pack_invert
7278
 
7279
#endif /* GL_MESA_pack_invert */
7280
 
7281
#ifdef GL_MESA_resize_buffers
7282
 
7283
static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
7284
{
7285
  GLboolean r = GL_FALSE;
7286
 
7287
  r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;
7288
 
7289
  return r;
7290
}
7291
 
7292
#endif /* GL_MESA_resize_buffers */
7293
 
7294
#ifdef GL_MESA_window_pos
7295
 
7296
static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
7297
{
7298
  GLboolean r = GL_FALSE;
7299
 
7300
  r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;
7301
  r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;
7302
  r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;
7303
  r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;
7304
  r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;
7305
  r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;
7306
  r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;
7307
  r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;
7308
  r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;
7309
  r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;
7310
  r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;
7311
  r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;
7312
  r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;
7313
  r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;
7314
  r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;
7315
  r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;
7316
  r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;
7317
  r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;
7318
  r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;
7319
  r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;
7320
  r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;
7321
  r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;
7322
  r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;
7323
  r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;
7324
 
7325
  return r;
7326
}
7327
 
7328
#endif /* GL_MESA_window_pos */
7329
 
7330
#ifdef GL_MESA_ycbcr_texture
7331
 
7332
#endif /* GL_MESA_ycbcr_texture */
7333
 
7334
#ifdef GL_NVX_gpu_memory_info
7335
 
7336
#endif /* GL_NVX_gpu_memory_info */
7337
 
7338
#ifdef GL_NV_bindless_texture
7339
 
7340
static GLboolean _glewInit_GL_NV_bindless_texture (GLEW_CONTEXT_ARG_DEF_INIT)
7341
{
7342
  GLboolean r = GL_FALSE;
7343
 
7344
  r = ((glGetImageHandleNV = (PFNGLGETIMAGEHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleNV")) == NULL) || r;
7345
  r = ((glGetTextureHandleNV = (PFNGLGETTEXTUREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleNV")) == NULL) || r;
7346
  r = ((glGetTextureSamplerHandleNV = (PFNGLGETTEXTURESAMPLERHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleNV")) == NULL) || r;
7347
  r = ((glIsImageHandleResidentNV = (PFNGLISIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentNV")) == NULL) || r;
7348
  r = ((glIsTextureHandleResidentNV = (PFNGLISTEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentNV")) == NULL) || r;
7349
  r = ((glMakeImageHandleNonResidentNV = (PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentNV")) == NULL) || r;
7350
  r = ((glMakeImageHandleResidentNV = (PFNGLMAKEIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentNV")) == NULL) || r;
7351
  r = ((glMakeTextureHandleNonResidentNV = (PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentNV")) == NULL) || r;
7352
  r = ((glMakeTextureHandleResidentNV = (PFNGLMAKETEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentNV")) == NULL) || r;
7353
  r = ((glProgramUniformHandleui64NV = (PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64NV")) == NULL) || r;
7354
  r = ((glProgramUniformHandleui64vNV = (PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vNV")) == NULL) || r;
7355
  r = ((glUniformHandleui64NV = (PFNGLUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64NV")) == NULL) || r;
7356
  r = ((glUniformHandleui64vNV = (PFNGLUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vNV")) == NULL) || r;
7357
 
7358
  return r;
7359
}
7360
 
7361
#endif /* GL_NV_bindless_texture */
7362
 
7363
#ifdef GL_NV_blend_square
7364
 
7365
#endif /* GL_NV_blend_square */
7366
 
7367
#ifdef GL_NV_conditional_render
7368
 
7369
static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT)
7370
{
7371
  GLboolean r = GL_FALSE;
7372
 
7373
  r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r;
7374
  r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r;
7375
 
7376
  return r;
7377
}
7378
 
7379
#endif /* GL_NV_conditional_render */
7380
 
7381
#ifdef GL_NV_copy_depth_to_color
7382
 
7383
#endif /* GL_NV_copy_depth_to_color */
7384
 
7385
#ifdef GL_NV_copy_image
7386
 
7387
static GLboolean _glewInit_GL_NV_copy_image (GLEW_CONTEXT_ARG_DEF_INIT)
7388
{
7389
  GLboolean r = GL_FALSE;
7390
 
7391
  r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r;
7392
 
7393
  return r;
7394
}
7395
 
7396
#endif /* GL_NV_copy_image */
7397
 
7398
#ifdef GL_NV_depth_buffer_float
7399
 
7400
static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
7401
{
7402
  GLboolean r = GL_FALSE;
7403
 
7404
  r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r;
7405
  r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r;
7406
  r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r;
7407
 
7408
  return r;
7409
}
7410
 
7411
#endif /* GL_NV_depth_buffer_float */
7412
 
7413
#ifdef GL_NV_depth_clamp
7414
 
7415
#endif /* GL_NV_depth_clamp */
7416
 
7417
#ifdef GL_NV_depth_range_unclamped
7418
 
7419
#endif /* GL_NV_depth_range_unclamped */
7420
 
7421
#ifdef GL_NV_evaluators
7422
 
7423
static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
7424
{
7425
  GLboolean r = GL_FALSE;
7426
 
7427
  r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;
7428
  r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;
7429
  r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;
7430
  r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;
7431
  r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;
7432
  r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;
7433
  r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;
7434
  r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;
7435
  r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;
7436
 
7437
  return r;
7438
}
7439
 
7440
#endif /* GL_NV_evaluators */
7441
 
7442
#ifdef GL_NV_explicit_multisample
7443
 
7444
static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
7445
{
7446
  GLboolean r = GL_FALSE;
7447
 
7448
  r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r;
7449
  r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r;
7450
  r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r;
7451
 
7452
  return r;
7453
}
7454
 
7455
#endif /* GL_NV_explicit_multisample */
7456
 
7457
#ifdef GL_NV_fence
7458
 
7459
static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT)
7460
{
7461
  GLboolean r = GL_FALSE;
7462
 
7463
  r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;
7464
  r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;
7465
  r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;
7466
  r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;
7467
  r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;
7468
  r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;
7469
  r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;
7470
 
7471
  return r;
7472
}
7473
 
7474
#endif /* GL_NV_fence */
7475
 
7476
#ifdef GL_NV_float_buffer
7477
 
7478
#endif /* GL_NV_float_buffer */
7479
 
7480
#ifdef GL_NV_fog_distance
7481
 
7482
#endif /* GL_NV_fog_distance */
7483
 
7484
#ifdef GL_NV_fragment_program
7485
 
7486
static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)
7487
{
7488
  GLboolean r = GL_FALSE;
7489
 
7490
  r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;
7491
  r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;
7492
  r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;
7493
  r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;
7494
  r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;
7495
  r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;
7496
 
7497
  return r;
7498
}
7499
 
7500
#endif /* GL_NV_fragment_program */
7501
 
7502
#ifdef GL_NV_fragment_program2
7503
 
7504
#endif /* GL_NV_fragment_program2 */
7505
 
7506
#ifdef GL_NV_fragment_program4
7507
 
7508
#endif /* GL_NV_fragment_program4 */
7509
 
7510
#ifdef GL_NV_fragment_program_option
7511
 
7512
#endif /* GL_NV_fragment_program_option */
7513
 
7514
#ifdef GL_NV_framebuffer_multisample_coverage
7515
 
7516
static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT)
7517
{
7518
  GLboolean r = GL_FALSE;
7519
 
7520
  r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r;
7521
 
7522
  return r;
7523
}
7524
 
7525
#endif /* GL_NV_framebuffer_multisample_coverage */
7526
 
7527
#ifdef GL_NV_geometry_program4
7528
 
7529
static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
7530
{
7531
  GLboolean r = GL_FALSE;
7532
 
7533
  r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r;
7534
 
7535
  return r;
7536
}
7537
 
7538
#endif /* GL_NV_geometry_program4 */
7539
 
7540
#ifdef GL_NV_geometry_shader4
7541
 
7542
#endif /* GL_NV_geometry_shader4 */
7543
 
7544
#ifdef GL_NV_gpu_program4
7545
 
7546
static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
7547
{
7548
  GLboolean r = GL_FALSE;
7549
 
7550
  r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r;
7551
  r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r;
7552
  r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r;
7553
  r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r;
7554
  r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r;
7555
  r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r;
7556
  r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r;
7557
  r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r;
7558
  r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r;
7559
  r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r;
7560
  r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r;
7561
  r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r;
7562
 
7563
  return r;
7564
}
7565
 
7566
#endif /* GL_NV_gpu_program4 */
7567
 
7568
#ifdef GL_NV_gpu_program5
7569
 
7570
#endif /* GL_NV_gpu_program5 */
7571
 
7572
#ifdef GL_NV_gpu_program_fp64
7573
 
7574
#endif /* GL_NV_gpu_program_fp64 */
7575
 
7576
#ifdef GL_NV_gpu_shader5
7577
 
7578
static GLboolean _glewInit_GL_NV_gpu_shader5 (GLEW_CONTEXT_ARG_DEF_INIT)
7579
{
7580
  GLboolean r = GL_FALSE;
7581
 
7582
  r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r;
7583
  r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r;
7584
  r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r;
7585
  r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r;
7586
  r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r;
7587
  r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r;
7588
  r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r;
7589
  r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r;
7590
  r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r;
7591
  r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r;
7592
  r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r;
7593
  r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r;
7594
  r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r;
7595
  r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r;
7596
  r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r;
7597
  r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r;
7598
  r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r;
7599
  r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r;
7600
  r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r;
7601
  r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r;
7602
  r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r;
7603
  r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r;
7604
  r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r;
7605
  r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r;
7606
  r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r;
7607
  r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r;
7608
  r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r;
7609
  r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r;
7610
  r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r;
7611
  r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r;
7612
  r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r;
7613
  r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r;
7614
  r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r;
7615
  r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r;
7616
 
7617
  return r;
7618
}
7619
 
7620
#endif /* GL_NV_gpu_shader5 */
7621
 
7622
#ifdef GL_NV_half_float
7623
 
7624
static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)
7625
{
7626
  GLboolean r = GL_FALSE;
7627
 
7628
  r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;
7629
  r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;
7630
  r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;
7631
  r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;
7632
  r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;
7633
  r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;
7634
  r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;
7635
  r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;
7636
  r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;
7637
  r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;
7638
  r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;
7639
  r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;
7640
  r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;
7641
  r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;
7642
  r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;
7643
  r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;
7644
  r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;
7645
  r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;
7646
  r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;
7647
  r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;
7648
  r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;
7649
  r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;
7650
  r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;
7651
  r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;
7652
  r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;
7653
  r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;
7654
  r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;
7655
  r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;
7656
  r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;
7657
  r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;
7658
  r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;
7659
  r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;
7660
  r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;
7661
  r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;
7662
  r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;
7663
  r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;
7664
  r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;
7665
  r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;
7666
  r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;
7667
  r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;
7668
  r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;
7669
  r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;
7670
  r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;
7671
  r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;
7672
  r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;
7673
  r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;
7674
 
7675
  return r;
7676
}
7677
 
7678
#endif /* GL_NV_half_float */
7679
 
7680
#ifdef GL_NV_light_max_exponent
7681
 
7682
#endif /* GL_NV_light_max_exponent */
7683
 
7684
#ifdef GL_NV_multisample_coverage
7685
 
7686
#endif /* GL_NV_multisample_coverage */
7687
 
7688
#ifdef GL_NV_multisample_filter_hint
7689
 
7690
#endif /* GL_NV_multisample_filter_hint */
7691
 
7692
#ifdef GL_NV_occlusion_query
7693
 
7694
static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
7695
{
7696
  GLboolean r = GL_FALSE;
7697
 
7698
  r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;
7699
  r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;
7700
  r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;
7701
  r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;
7702
  r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;
7703
  r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;
7704
  r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;
7705
 
7706
  return r;
7707
}
7708
 
7709
#endif /* GL_NV_occlusion_query */
7710
 
7711
#ifdef GL_NV_packed_depth_stencil
7712
 
7713
#endif /* GL_NV_packed_depth_stencil */
7714
 
7715
#ifdef GL_NV_parameter_buffer_object
7716
 
7717
static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
7718
{
7719
  GLboolean r = GL_FALSE;
7720
 
7721
  r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r;
7722
  r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r;
7723
  r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r;
7724
 
7725
  return r;
7726
}
7727
 
7728
#endif /* GL_NV_parameter_buffer_object */
7729
 
7730
#ifdef GL_NV_parameter_buffer_object2
7731
 
7732
#endif /* GL_NV_parameter_buffer_object2 */
7733
 
7734
#ifdef GL_NV_path_rendering
7735
 
7736
static GLboolean _glewInit_GL_NV_path_rendering (GLEW_CONTEXT_ARG_DEF_INIT)
7737
{
7738
  GLboolean r = GL_FALSE;
7739
 
7740
  r = ((glCopyPathNV = (PFNGLCOPYPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCopyPathNV")) == NULL) || r;
7741
  r = ((glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathInstancedNV")) == NULL) || r;
7742
  r = ((glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathNV")) == NULL) || r;
7743
  r = ((glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathInstancedNV")) == NULL) || r;
7744
  r = ((glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathNV")) == NULL) || r;
7745
  r = ((glDeletePathsNV = (PFNGLDELETEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glDeletePathsNV")) == NULL) || r;
7746
  r = ((glGenPathsNV = (PFNGLGENPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glGenPathsNV")) == NULL) || r;
7747
  r = ((glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenfvNV")) == NULL) || r;
7748
  r = ((glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenivNV")) == NULL) || r;
7749
  r = ((glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCommandsNV")) == NULL) || r;
7750
  r = ((glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCoordsNV")) == NULL) || r;
7751
  r = ((glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathDashArrayNV")) == NULL) || r;
7752
  r = ((glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathLengthNV")) == NULL) || r;
7753
  r = ((glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricRangeNV")) == NULL) || r;
7754
  r = ((glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricsNV")) == NULL) || r;
7755
  r = ((glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterfvNV")) == NULL) || r;
7756
  r = ((glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterivNV")) == NULL) || r;
7757
  r = ((glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathSpacingNV")) == NULL) || r;
7758
  r = ((glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenfvNV")) == NULL) || r;
7759
  r = ((glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenivNV")) == NULL) || r;
7760
  r = ((glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glInterpolatePathsNV")) == NULL) || r;
7761
  r = ((glIsPathNV = (PFNGLISPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPathNV")) == NULL) || r;
7762
  r = ((glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInFillPathNV")) == NULL) || r;
7763
  r = ((glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInStrokePathNV")) == NULL) || r;
7764
  r = ((glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathColorGenNV")) == NULL) || r;
7765
  r = ((glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCommandsNV")) == NULL) || r;
7766
  r = ((glPathCoordsNV = (PFNGLPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoordsNV")) == NULL) || r;
7767
  r = ((glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoverDepthFuncNV")) == NULL) || r;
7768
  r = ((glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathDashArrayNV")) == NULL) || r;
7769
  r = ((glPathFogGenNV = (PFNGLPATHFOGGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathFogGenNV")) == NULL) || r;
7770
  r = ((glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphRangeNV")) == NULL) || r;
7771
  r = ((glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphsNV")) == NULL) || r;
7772
  r = ((glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfNV")) == NULL) || r;
7773
  r = ((glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfvNV")) == NULL) || r;
7774
  r = ((glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPathParameteriNV")) == NULL) || r;
7775
  r = ((glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterivNV")) == NULL) || r;
7776
  r = ((glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilDepthOffsetNV")) == NULL) || r;
7777
  r = ((glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilFuncNV")) == NULL) || r;
7778
  r = ((glPathStringNV = (PFNGLPATHSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glPathStringNV")) == NULL) || r;
7779
  r = ((glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCommandsNV")) == NULL) || r;
7780
  r = ((glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCoordsNV")) == NULL) || r;
7781
  r = ((glPathTexGenNV = (PFNGLPATHTEXGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathTexGenNV")) == NULL) || r;
7782
  r = ((glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC)glewGetProcAddress((const GLubyte*)"glPointAlongPathNV")) == NULL) || r;
7783
  r = ((glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathInstancedNV")) == NULL) || r;
7784
  r = ((glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathNV")) == NULL) || r;
7785
  r = ((glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathInstancedNV")) == NULL) || r;
7786
  r = ((glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathNV")) == NULL) || r;
7787
  r = ((glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC)glewGetProcAddress((const GLubyte*)"glTransformPathNV")) == NULL) || r;
7788
  r = ((glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glWeightPathsNV")) == NULL) || r;
7789
 
7790
  return r;
7791
}
7792
 
7793
#endif /* GL_NV_path_rendering */
7794
 
7795
#ifdef GL_NV_pixel_data_range
7796
 
7797
static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)
7798
{
7799
  GLboolean r = GL_FALSE;
7800
 
7801
  r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;
7802
  r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;
7803
 
7804
  return r;
7805
}
7806
 
7807
#endif /* GL_NV_pixel_data_range */
7808
 
7809
#ifdef GL_NV_point_sprite
7810
 
7811
static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT)
7812
{
7813
  GLboolean r = GL_FALSE;
7814
 
7815
  r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;
7816
  r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;
7817
 
7818
  return r;
7819
}
7820
 
7821
#endif /* GL_NV_point_sprite */
7822
 
7823
#ifdef GL_NV_present_video
7824
 
7825
static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT)
7826
{
7827
  GLboolean r = GL_FALSE;
7828
 
7829
  r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r;
7830
  r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r;
7831
  r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r;
7832
  r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r;
7833
  r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r;
7834
  r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r;
7835
 
7836
  return r;
7837
}
7838
 
7839
#endif /* GL_NV_present_video */
7840
 
7841
#ifdef GL_NV_primitive_restart
7842
 
7843
static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT)
7844
{
7845
  GLboolean r = GL_FALSE;
7846
 
7847
  r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;
7848
  r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;
7849
 
7850
  return r;
7851
}
7852
 
7853
#endif /* GL_NV_primitive_restart */
7854
 
7855
#ifdef GL_NV_register_combiners
7856
 
7857
static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)
7858
{
7859
  GLboolean r = GL_FALSE;
7860
 
7861
  r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;
7862
  r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;
7863
  r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;
7864
  r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;
7865
  r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;
7866
  r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;
7867
  r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;
7868
  r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;
7869
  r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;
7870
  r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;
7871
  r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;
7872
  r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;
7873
  r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;
7874
 
7875
  return r;
7876
}
7877
 
7878
#endif /* GL_NV_register_combiners */
7879
 
7880
#ifdef GL_NV_register_combiners2
7881
 
7882
static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)
7883
{
7884
  GLboolean r = GL_FALSE;
7885
 
7886
  r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;
7887
  r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;
7888
 
7889
  return r;
7890
}
7891
 
7892
#endif /* GL_NV_register_combiners2 */
7893
 
7894
#ifdef GL_NV_shader_atomic_float
7895
 
7896
#endif /* GL_NV_shader_atomic_float */
7897
 
7898
#ifdef GL_NV_shader_buffer_load
7899
 
7900
static GLboolean _glewInit_GL_NV_shader_buffer_load (GLEW_CONTEXT_ARG_DEF_INIT)
7901
{
7902
  GLboolean r = GL_FALSE;
7903
 
7904
  r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r;
7905
  r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r;
7906
  r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r;
7907
  r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r;
7908
  r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r;
7909
  r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r;
7910
  r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r;
7911
  r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r;
7912
  r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r;
7913
  r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r;
7914
  r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r;
7915
  r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r;
7916
  r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r;
7917
 
7918
  return r;
7919
}
7920
 
7921
#endif /* GL_NV_shader_buffer_load */
7922
 
7923
#ifdef GL_NV_tessellation_program5
7924
 
7925
#endif /* GL_NV_tessellation_program5 */
7926
 
7927
#ifdef GL_NV_texgen_emboss
7928
 
7929
#endif /* GL_NV_texgen_emboss */
7930
 
7931
#ifdef GL_NV_texgen_reflection
7932
 
7933
#endif /* GL_NV_texgen_reflection */
7934
 
7935
#ifdef GL_NV_texture_barrier
7936
 
7937
static GLboolean _glewInit_GL_NV_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT)
7938
{
7939
  GLboolean r = GL_FALSE;
7940
 
7941
  r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r;
7942
 
7943
  return r;
7944
}
7945
 
7946
#endif /* GL_NV_texture_barrier */
7947
 
7948
#ifdef GL_NV_texture_compression_vtc
7949
 
7950
#endif /* GL_NV_texture_compression_vtc */
7951
 
7952
#ifdef GL_NV_texture_env_combine4
7953
 
7954
#endif /* GL_NV_texture_env_combine4 */
7955
 
7956
#ifdef GL_NV_texture_expand_normal
7957
 
7958
#endif /* GL_NV_texture_expand_normal */
7959
 
7960
#ifdef GL_NV_texture_multisample
7961
 
7962
static GLboolean _glewInit_GL_NV_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
7963
{
7964
  GLboolean r = GL_FALSE;
7965
 
7966
  r = ((glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisampleCoverageNV")) == NULL) || r;
7967
  r = ((glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisampleCoverageNV")) == NULL) || r;
7968
  r = ((glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleCoverageNV")) == NULL) || r;
7969
  r = ((glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleNV")) == NULL) || r;
7970
  r = ((glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleCoverageNV")) == NULL) || r;
7971
  r = ((glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleNV")) == NULL) || r;
7972
 
7973
  return r;
7974
}
7975
 
7976
#endif /* GL_NV_texture_multisample */
7977
 
7978
#ifdef GL_NV_texture_rectangle
7979
 
7980
#endif /* GL_NV_texture_rectangle */
7981
 
7982
#ifdef GL_NV_texture_shader
7983
 
7984
#endif /* GL_NV_texture_shader */
7985
 
7986
#ifdef GL_NV_texture_shader2
7987
 
7988
#endif /* GL_NV_texture_shader2 */
7989
 
7990
#ifdef GL_NV_texture_shader3
7991
 
7992
#endif /* GL_NV_texture_shader3 */
7993
 
7994
#ifdef GL_NV_transform_feedback
7995
 
7996
static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
7997
{
7998
  GLboolean r = GL_FALSE;
7999
 
8000
  r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r;
8001
  r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r;
8002
  r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r;
8003
  r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r;
8004
  r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r;
8005
  r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r;
8006
  r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r;
8007
  r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r;
8008
  r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r;
8009
  r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r;
8010
  r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r;
8011
 
8012
  return r;
8013
}
8014
 
8015
#endif /* GL_NV_transform_feedback */
8016
 
8017
#ifdef GL_NV_transform_feedback2
8018
 
8019
static GLboolean _glewInit_GL_NV_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
8020
{
8021
  GLboolean r = GL_FALSE;
8022
 
8023
  r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r;
8024
  r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r;
8025
  r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r;
8026
  r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r;
8027
  r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r;
8028
  r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r;
8029
  r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r;
8030
 
8031
  return r;
8032
}
8033
 
8034
#endif /* GL_NV_transform_feedback2 */
8035
 
8036
#ifdef GL_NV_vdpau_interop
8037
 
8038
static GLboolean _glewInit_GL_NV_vdpau_interop (GLEW_CONTEXT_ARG_DEF_INIT)
8039
{
8040
  GLboolean r = GL_FALSE;
8041
 
8042
  r = ((glVDPAUFiniNV = (PFNGLVDPAUFININVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUFiniNV")) == NULL) || r;
8043
  r = ((glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUGetSurfaceivNV")) == NULL) || r;
8044
  r = ((glVDPAUInitNV = (PFNGLVDPAUINITNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUInitNV")) == NULL) || r;
8045
  r = ((glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUIsSurfaceNV")) == NULL) || r;
8046
  r = ((glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUMapSurfacesNV")) == NULL) || r;
8047
  r = ((glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterOutputSurfaceNV")) == NULL) || r;
8048
  r = ((glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterVideoSurfaceNV")) == NULL) || r;
8049
  r = ((glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUSurfaceAccessNV")) == NULL) || r;
8050
  r = ((glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnmapSurfacesNV")) == NULL) || r;
8051
  r = ((glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnregisterSurfaceNV")) == NULL) || r;
8052
 
8053
  return r;
8054
}
8055
 
8056
#endif /* GL_NV_vdpau_interop */
8057
 
8058
#ifdef GL_NV_vertex_array_range
8059
 
8060
static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
8061
{
8062
  GLboolean r = GL_FALSE;
8063
 
8064
  r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;
8065
  r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;
8066
 
8067
  return r;
8068
}
8069
 
8070
#endif /* GL_NV_vertex_array_range */
8071
 
8072
#ifdef GL_NV_vertex_array_range2
8073
 
8074
#endif /* GL_NV_vertex_array_range2 */
8075
 
8076
#ifdef GL_NV_vertex_attrib_integer_64bit
8077
 
8078
static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
8079
{
8080
  GLboolean r = GL_FALSE;
8081
 
8082
  r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r;
8083
  r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r;
8084
  r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r;
8085
  r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r;
8086
  r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r;
8087
  r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r;
8088
  r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r;
8089
  r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r;
8090
  r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r;
8091
  r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r;
8092
  r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r;
8093
  r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r;
8094
  r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r;
8095
  r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r;
8096
  r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r;
8097
  r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r;
8098
  r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r;
8099
  r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r;
8100
  r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r;
8101
 
8102
  return r;
8103
}
8104
 
8105
#endif /* GL_NV_vertex_attrib_integer_64bit */
8106
 
8107
#ifdef GL_NV_vertex_buffer_unified_memory
8108
 
8109
static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (GLEW_CONTEXT_ARG_DEF_INIT)
8110
{
8111
  GLboolean r = GL_FALSE;
8112
 
8113
  r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r;
8114
  r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r;
8115
  r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r;
8116
  r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r;
8117
  r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r;
8118
  r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r;
8119
  r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r;
8120
  r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r;
8121
  r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r;
8122
  r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r;
8123
  r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r;
8124
  r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r;
8125
 
8126
  return r;
8127
}
8128
 
8129
#endif /* GL_NV_vertex_buffer_unified_memory */
8130
 
8131
#ifdef GL_NV_vertex_program
8132
 
8133
static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
8134
{
8135
  GLboolean r = GL_FALSE;
8136
 
8137
  r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;
8138
  r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;
8139
  r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;
8140
  r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;
8141
  r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;
8142
  r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;
8143
  r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;
8144
  r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;
8145
  r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;
8146
  r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;
8147
  r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;
8148
  r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;
8149
  r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;
8150
  r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;
8151
  r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;
8152
  r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;
8153
  r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;
8154
  r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;
8155
  r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;
8156
  r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;
8157
  r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;
8158
  r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;
8159
  r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;
8160
  r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;
8161
  r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;
8162
  r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;
8163
  r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;
8164
  r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;
8165
  r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;
8166
  r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;
8167
  r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;
8168
  r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;
8169
  r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;
8170
  r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;
8171
  r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;
8172
  r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;
8173
  r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;
8174
  r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;
8175
  r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;
8176
  r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;
8177
  r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;
8178
  r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;
8179
  r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;
8180
  r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;
8181
  r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;
8182
  r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;
8183
  r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;
8184
  r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;
8185
  r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;
8186
  r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;
8187
  r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;
8188
  r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;
8189
  r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;
8190
  r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;
8191
  r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;
8192
  r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;
8193
  r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;
8194
  r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;
8195
  r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;
8196
  r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;
8197
  r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;
8198
  r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;
8199
  r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;
8200
  r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;
8201
 
8202
  return r;
8203
}
8204
 
8205
#endif /* GL_NV_vertex_program */
8206
 
8207
#ifdef GL_NV_vertex_program1_1
8208
 
8209
#endif /* GL_NV_vertex_program1_1 */
8210
 
8211
#ifdef GL_NV_vertex_program2
8212
 
8213
#endif /* GL_NV_vertex_program2 */
8214
 
8215
#ifdef GL_NV_vertex_program2_option
8216
 
8217
#endif /* GL_NV_vertex_program2_option */
8218
 
8219
#ifdef GL_NV_vertex_program3
8220
 
8221
#endif /* GL_NV_vertex_program3 */
8222
 
8223
#ifdef GL_NV_vertex_program4
8224
 
8225
#endif /* GL_NV_vertex_program4 */
8226
 
8227
#ifdef GL_NV_video_capture
8228
 
8229
static GLboolean _glewInit_GL_NV_video_capture (GLEW_CONTEXT_ARG_DEF_INIT)
8230
{
8231
  GLboolean r = GL_FALSE;
8232
 
8233
  r = ((glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glBeginVideoCaptureNV")) == NULL) || r;
8234
  r = ((glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamBufferNV")) == NULL) || r;
8235
  r = ((glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamTextureNV")) == NULL) || r;
8236
  r = ((glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glEndVideoCaptureNV")) == NULL) || r;
8237
  r = ((glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamdvNV")) == NULL) || r;
8238
  r = ((glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamfvNV")) == NULL) || r;
8239
  r = ((glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamivNV")) == NULL) || r;
8240
  r = ((glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureivNV")) == NULL) || r;
8241
  r = ((glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureNV")) == NULL) || r;
8242
  r = ((glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterdvNV")) == NULL) || r;
8243
  r = ((glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterfvNV")) == NULL) || r;
8244
  r = ((glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterivNV")) == NULL) || r;
8245
 
8246
  return r;
8247
}
8248
 
8249
#endif /* GL_NV_video_capture */
8250
 
8251
#ifdef GL_OES_byte_coordinates
8252
 
8253
#endif /* GL_OES_byte_coordinates */
8254
 
8255
#ifdef GL_OES_compressed_paletted_texture
8256
 
8257
#endif /* GL_OES_compressed_paletted_texture */
8258
 
8259
#ifdef GL_OES_read_format
8260
 
8261
#endif /* GL_OES_read_format */
8262
 
8263
#ifdef GL_OES_single_precision
8264
 
8265
static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT)
8266
{
8267
  GLboolean r = GL_FALSE;
8268
 
8269
  r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r;
8270
  r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r;
8271
  r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r;
8272
  r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r;
8273
  r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r;
8274
  r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r;
8275
 
8276
  return r;
8277
}
8278
 
8279
#endif /* GL_OES_single_precision */
8280
 
8281
#ifdef GL_OML_interlace
8282
 
8283
#endif /* GL_OML_interlace */
8284
 
8285
#ifdef GL_OML_resample
8286
 
8287
#endif /* GL_OML_resample */
8288
 
8289
#ifdef GL_OML_subsample
8290
 
8291
#endif /* GL_OML_subsample */
8292
 
8293
#ifdef GL_PGI_misc_hints
8294
 
8295
#endif /* GL_PGI_misc_hints */
8296
 
8297
#ifdef GL_PGI_vertex_hints
8298
 
8299
#endif /* GL_PGI_vertex_hints */
8300
 
8301
#ifdef GL_REGAL_error_string
8302
 
8303
static GLboolean _glewInit_GL_REGAL_error_string (GLEW_CONTEXT_ARG_DEF_INIT)
8304
{
8305
  GLboolean r = GL_FALSE;
8306
 
8307
  r = ((glErrorStringREGAL = (PFNGLERRORSTRINGREGALPROC)glewGetProcAddress((const GLubyte*)"glErrorStringREGAL")) == NULL) || r;
8308
 
8309
  return r;
8310
}
8311
 
8312
#endif /* GL_REGAL_error_string */
8313
 
8314
#ifdef GL_REGAL_extension_query
8315
 
8316
static GLboolean _glewInit_GL_REGAL_extension_query (GLEW_CONTEXT_ARG_DEF_INIT)
8317
{
8318
  GLboolean r = GL_FALSE;
8319
 
8320
  r = ((glGetExtensionREGAL = (PFNGLGETEXTENSIONREGALPROC)glewGetProcAddress((const GLubyte*)"glGetExtensionREGAL")) == NULL) || r;
8321
  r = ((glIsSupportedREGAL = (PFNGLISSUPPORTEDREGALPROC)glewGetProcAddress((const GLubyte*)"glIsSupportedREGAL")) == NULL) || r;
8322
 
8323
  return r;
8324
}
8325
 
8326
#endif /* GL_REGAL_extension_query */
8327
 
8328
#ifdef GL_REGAL_log
8329
 
8330
#endif /* GL_REGAL_log */
8331
 
8332
#ifdef GL_REND_screen_coordinates
8333
 
8334
#endif /* GL_REND_screen_coordinates */
8335
 
8336
#ifdef GL_S3_s3tc
8337
 
8338
#endif /* GL_S3_s3tc */
8339
 
8340
#ifdef GL_SGIS_color_range
8341
 
8342
#endif /* GL_SGIS_color_range */
8343
 
8344
#ifdef GL_SGIS_detail_texture
8345
 
8346
static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT)
8347
{
8348
  GLboolean r = GL_FALSE;
8349
 
8350
  r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;
8351
  r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;
8352
 
8353
  return r;
8354
}
8355
 
8356
#endif /* GL_SGIS_detail_texture */
8357
 
8358
#ifdef GL_SGIS_fog_function
8359
 
8360
static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT)
8361
{
8362
  GLboolean r = GL_FALSE;
8363
 
8364
  r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;
8365
  r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;
8366
 
8367
  return r;
8368
}
8369
 
8370
#endif /* GL_SGIS_fog_function */
8371
 
8372
#ifdef GL_SGIS_generate_mipmap
8373
 
8374
#endif /* GL_SGIS_generate_mipmap */
8375
 
8376
#ifdef GL_SGIS_multisample
8377
 
8378
static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
8379
{
8380
  GLboolean r = GL_FALSE;
8381
 
8382
  r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;
8383
  r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;
8384
 
8385
  return r;
8386
}
8387
 
8388
#endif /* GL_SGIS_multisample */
8389
 
8390
#ifdef GL_SGIS_pixel_texture
8391
 
8392
#endif /* GL_SGIS_pixel_texture */
8393
 
8394
#ifdef GL_SGIS_point_line_texgen
8395
 
8396
#endif /* GL_SGIS_point_line_texgen */
8397
 
8398
#ifdef GL_SGIS_sharpen_texture
8399
 
8400
static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT)
8401
{
8402
  GLboolean r = GL_FALSE;
8403
 
8404
  r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;
8405
  r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;
8406
 
8407
  return r;
8408
}
8409
 
8410
#endif /* GL_SGIS_sharpen_texture */
8411
 
8412
#ifdef GL_SGIS_texture4D
8413
 
8414
static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT)
8415
{
8416
  GLboolean r = GL_FALSE;
8417
 
8418
  r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;
8419
  r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;
8420
 
8421
  return r;
8422
}
8423
 
8424
#endif /* GL_SGIS_texture4D */
8425
 
8426
#ifdef GL_SGIS_texture_border_clamp
8427
 
8428
#endif /* GL_SGIS_texture_border_clamp */
8429
 
8430
#ifdef GL_SGIS_texture_edge_clamp
8431
 
8432
#endif /* GL_SGIS_texture_edge_clamp */
8433
 
8434
#ifdef GL_SGIS_texture_filter4
8435
 
8436
static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT)
8437
{
8438
  GLboolean r = GL_FALSE;
8439
 
8440
  r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;
8441
  r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;
8442
 
8443
  return r;
8444
}
8445
 
8446
#endif /* GL_SGIS_texture_filter4 */
8447
 
8448
#ifdef GL_SGIS_texture_lod
8449
 
8450
#endif /* GL_SGIS_texture_lod */
8451
 
8452
#ifdef GL_SGIS_texture_select
8453
 
8454
#endif /* GL_SGIS_texture_select */
8455
 
8456
#ifdef GL_SGIX_async
8457
 
8458
static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT)
8459
{
8460
  GLboolean r = GL_FALSE;
8461
 
8462
  r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;
8463
  r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;
8464
  r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;
8465
  r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;
8466
  r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;
8467
  r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;
8468
 
8469
  return r;
8470
}
8471
 
8472
#endif /* GL_SGIX_async */
8473
 
8474
#ifdef GL_SGIX_async_histogram
8475
 
8476
#endif /* GL_SGIX_async_histogram */
8477
 
8478
#ifdef GL_SGIX_async_pixel
8479
 
8480
#endif /* GL_SGIX_async_pixel */
8481
 
8482
#ifdef GL_SGIX_blend_alpha_minmax
8483
 
8484
#endif /* GL_SGIX_blend_alpha_minmax */
8485
 
8486
#ifdef GL_SGIX_clipmap
8487
 
8488
#endif /* GL_SGIX_clipmap */
8489
 
8490
#ifdef GL_SGIX_convolution_accuracy
8491
 
8492
#endif /* GL_SGIX_convolution_accuracy */
8493
 
8494
#ifdef GL_SGIX_depth_texture
8495
 
8496
#endif /* GL_SGIX_depth_texture */
8497
 
8498
#ifdef GL_SGIX_flush_raster
8499
 
8500
static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT)
8501
{
8502
  GLboolean r = GL_FALSE;
8503
 
8504
  r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;
8505
 
8506
  return r;
8507
}
8508
 
8509
#endif /* GL_SGIX_flush_raster */
8510
 
8511
#ifdef GL_SGIX_fog_offset
8512
 
8513
#endif /* GL_SGIX_fog_offset */
8514
 
8515
#ifdef GL_SGIX_fog_texture
8516
 
8517
static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT)
8518
{
8519
  GLboolean r = GL_FALSE;
8520
 
8521
  r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;
8522
 
8523
  return r;
8524
}
8525
 
8526
#endif /* GL_SGIX_fog_texture */
8527
 
8528
#ifdef GL_SGIX_fragment_specular_lighting
8529
 
8530
static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT)
8531
{
8532
  GLboolean r = GL_FALSE;
8533
 
8534
  r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;
8535
  r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;
8536
  r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;
8537
  r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;
8538
  r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;
8539
  r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;
8540
  r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;
8541
  r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;
8542
  r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;
8543
  r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;
8544
  r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;
8545
  r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;
8546
  r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;
8547
  r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;
8548
  r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;
8549
  r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;
8550
  r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;
8551
 
8552
  return r;
8553
}
8554
 
8555
#endif /* GL_SGIX_fragment_specular_lighting */
8556
 
8557
#ifdef GL_SGIX_framezoom
8558
 
8559
static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT)
8560
{
8561
  GLboolean r = GL_FALSE;
8562
 
8563
  r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;
8564
 
8565
  return r;
8566
}
8567
 
8568
#endif /* GL_SGIX_framezoom */
8569
 
8570
#ifdef GL_SGIX_interlace
8571
 
8572
#endif /* GL_SGIX_interlace */
8573
 
8574
#ifdef GL_SGIX_ir_instrument1
8575
 
8576
#endif /* GL_SGIX_ir_instrument1 */
8577
 
8578
#ifdef GL_SGIX_list_priority
8579
 
8580
#endif /* GL_SGIX_list_priority */
8581
 
8582
#ifdef GL_SGIX_pixel_texture
8583
 
8584
static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT)
8585
{
8586
  GLboolean r = GL_FALSE;
8587
 
8588
  r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;
8589
 
8590
  return r;
8591
}
8592
 
8593
#endif /* GL_SGIX_pixel_texture */
8594
 
8595
#ifdef GL_SGIX_pixel_texture_bits
8596
 
8597
#endif /* GL_SGIX_pixel_texture_bits */
8598
 
8599
#ifdef GL_SGIX_reference_plane
8600
 
8601
static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT)
8602
{
8603
  GLboolean r = GL_FALSE;
8604
 
8605
  r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;
8606
 
8607
  return r;
8608
}
8609
 
8610
#endif /* GL_SGIX_reference_plane */
8611
 
8612
#ifdef GL_SGIX_resample
8613
 
8614
#endif /* GL_SGIX_resample */
8615
 
8616
#ifdef GL_SGIX_shadow
8617
 
8618
#endif /* GL_SGIX_shadow */
8619
 
8620
#ifdef GL_SGIX_shadow_ambient
8621
 
8622
#endif /* GL_SGIX_shadow_ambient */
8623
 
8624
#ifdef GL_SGIX_sprite
8625
 
8626
static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT)
8627
{
8628
  GLboolean r = GL_FALSE;
8629
 
8630
  r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;
8631
  r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;
8632
  r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;
8633
  r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;
8634
 
8635
  return r;
8636
}
8637
 
8638
#endif /* GL_SGIX_sprite */
8639
 
8640
#ifdef GL_SGIX_tag_sample_buffer
8641
 
8642
static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
8643
{
8644
  GLboolean r = GL_FALSE;
8645
 
8646
  r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;
8647
 
8648
  return r;
8649
}
8650
 
8651
#endif /* GL_SGIX_tag_sample_buffer */
8652
 
8653
#ifdef GL_SGIX_texture_add_env
8654
 
8655
#endif /* GL_SGIX_texture_add_env */
8656
 
8657
#ifdef GL_SGIX_texture_coordinate_clamp
8658
 
8659
#endif /* GL_SGIX_texture_coordinate_clamp */
8660
 
8661
#ifdef GL_SGIX_texture_lod_bias
8662
 
8663
#endif /* GL_SGIX_texture_lod_bias */
8664
 
8665
#ifdef GL_SGIX_texture_multi_buffer
8666
 
8667
#endif /* GL_SGIX_texture_multi_buffer */
8668
 
8669
#ifdef GL_SGIX_texture_range
8670
 
8671
#endif /* GL_SGIX_texture_range */
8672
 
8673
#ifdef GL_SGIX_texture_scale_bias
8674
 
8675
#endif /* GL_SGIX_texture_scale_bias */
8676
 
8677
#ifdef GL_SGIX_vertex_preclip
8678
 
8679
#endif /* GL_SGIX_vertex_preclip */
8680
 
8681
#ifdef GL_SGIX_vertex_preclip_hint
8682
 
8683
#endif /* GL_SGIX_vertex_preclip_hint */
8684
 
8685
#ifdef GL_SGIX_ycrcb
8686
 
8687
#endif /* GL_SGIX_ycrcb */
8688
 
8689
#ifdef GL_SGI_color_matrix
8690
 
8691
#endif /* GL_SGI_color_matrix */
8692
 
8693
#ifdef GL_SGI_color_table
8694
 
8695
static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT)
8696
{
8697
  GLboolean r = GL_FALSE;
8698
 
8699
  r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;
8700
  r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;
8701
  r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;
8702
  r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;
8703
  r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;
8704
  r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;
8705
  r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;
8706
 
8707
  return r;
8708
}
8709
 
8710
#endif /* GL_SGI_color_table */
8711
 
8712
#ifdef GL_SGI_texture_color_table
8713
 
8714
#endif /* GL_SGI_texture_color_table */
8715
 
8716
#ifdef GL_SUNX_constant_data
8717
 
8718
static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT)
8719
{
8720
  GLboolean r = GL_FALSE;
8721
 
8722
  r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;
8723
 
8724
  return r;
8725
}
8726
 
8727
#endif /* GL_SUNX_constant_data */
8728
 
8729
#ifdef GL_SUN_convolution_border_modes
8730
 
8731
#endif /* GL_SUN_convolution_border_modes */
8732
 
8733
#ifdef GL_SUN_global_alpha
8734
 
8735
static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT)
8736
{
8737
  GLboolean r = GL_FALSE;
8738
 
8739
  r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;
8740
  r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;
8741
  r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;
8742
  r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;
8743
  r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;
8744
  r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;
8745
  r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;
8746
  r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;
8747
 
8748
  return r;
8749
}
8750
 
8751
#endif /* GL_SUN_global_alpha */
8752
 
8753
#ifdef GL_SUN_mesh_array
8754
 
8755
#endif /* GL_SUN_mesh_array */
8756
 
8757
#ifdef GL_SUN_read_video_pixels
8758
 
8759
static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT)
8760
{
8761
  GLboolean r = GL_FALSE;
8762
 
8763
  r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;
8764
 
8765
  return r;
8766
}
8767
 
8768
#endif /* GL_SUN_read_video_pixels */
8769
 
8770
#ifdef GL_SUN_slice_accum
8771
 
8772
#endif /* GL_SUN_slice_accum */
8773
 
8774
#ifdef GL_SUN_triangle_list
8775
 
8776
static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT)
8777
{
8778
  GLboolean r = GL_FALSE;
8779
 
8780
  r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;
8781
  r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;
8782
  r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;
8783
  r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;
8784
  r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;
8785
  r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;
8786
  r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;
8787
 
8788
  return r;
8789
}
8790
 
8791
#endif /* GL_SUN_triangle_list */
8792
 
8793
#ifdef GL_SUN_vertex
8794
 
8795
static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
8796
{
8797
  GLboolean r = GL_FALSE;
8798
 
8799
  r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;
8800
  r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;
8801
  r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;
8802
  r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;
8803
  r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;
8804
  r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;
8805
  r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;
8806
  r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;
8807
  r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;
8808
  r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;
8809
  r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;
8810
  r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;
8811
  r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;
8812
  r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;
8813
  r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;
8814
  r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;
8815
  r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;
8816
  r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;
8817
  r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;
8818
  r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;
8819
  r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;
8820
  r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;
8821
  r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;
8822
  r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;
8823
  r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;
8824
  r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;
8825
  r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;
8826
  r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;
8827
  r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;
8828
  r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;
8829
  r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;
8830
  r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;
8831
  r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;
8832
  r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;
8833
  r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;
8834
  r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;
8835
  r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;
8836
  r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;
8837
  r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;
8838
  r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;
8839
 
8840
  return r;
8841
}
8842
 
8843
#endif /* GL_SUN_vertex */
8844
 
8845
#ifdef GL_WIN_phong_shading
8846
 
8847
#endif /* GL_WIN_phong_shading */
8848
 
8849
#ifdef GL_WIN_specular_fog
8850
 
8851
#endif /* GL_WIN_specular_fog */
8852
 
8853
#ifdef GL_WIN_swap_hint
8854
 
8855
static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT)
8856
{
8857
  GLboolean r = GL_FALSE;
8858
 
8859
  r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;
8860
 
8861
  return r;
8862
}
8863
 
8864
#endif /* GL_WIN_swap_hint */
8865
 
8866
/* ------------------------------------------------------------------------- */
8867
 
8868
GLboolean GLEWAPIENTRY glewGetExtension (const char* name)
8869
{    
8870
  const GLubyte* start;
8871
  const GLubyte* end;
8872
  start = (const GLubyte*)glGetString(GL_EXTENSIONS);
8873
  if (start == 0)
8874
    return GL_FALSE;
8875
  end = start + _glewStrLen(start);
8876
  return _glewSearchExtension(name, start, end);
8877
}
8878
 
8879
/* ------------------------------------------------------------------------- */
8880
 
8881
#ifndef GLEW_MX
8882
static
8883
#endif
8884
GLenum GLEWAPIENTRY glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
8885
{
8886
  const GLubyte* s;
8887
  GLuint dot;
8888
  GLint major, minor;
8889
  const GLubyte* extStart;
8890
  const GLubyte* extEnd;
8891
  /* query opengl version */
8892
  s = glGetString(GL_VERSION);
8893
  dot = _glewStrCLen(s, '.');
8894
  if (dot == 0)
8895
    return GLEW_ERROR_NO_GL_VERSION;
8896
 
8897
  major = s[dot-1]-'0';
8898
  minor = s[dot+1]-'0';
8899
 
8900
  if (minor < 0 || minor > 9)
8901
    minor = 0;
8902
  if (major<0 || major>9)
8903
    return GLEW_ERROR_NO_GL_VERSION;
8904
 
8905
 
8906
  if (major == 1 && minor == 0)
8907
  {
8908
    return GLEW_ERROR_GL_VERSION_10_ONLY;
8909
  }
8910
  else
8911
  {
8912
    CONST_CAST(GLEW_VERSION_4_3)   = ( major > 4 )                 || ( major == 4 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
8913
    CONST_CAST(GLEW_VERSION_4_2)   = GLEW_VERSION_4_3   == GL_TRUE || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
8914
    CONST_CAST(GLEW_VERSION_4_1)   = GLEW_VERSION_4_2   == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
8915
    CONST_CAST(GLEW_VERSION_4_0)   = GLEW_VERSION_4_1   == GL_TRUE || ( major == 4               ) ? GL_TRUE : GL_FALSE;
8916
    CONST_CAST(GLEW_VERSION_3_3)   = GLEW_VERSION_4_0   == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
8917
    CONST_CAST(GLEW_VERSION_3_2)   = GLEW_VERSION_3_3   == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
8918
    CONST_CAST(GLEW_VERSION_3_1)   = GLEW_VERSION_3_2   == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
8919
    CONST_CAST(GLEW_VERSION_3_0)   = GLEW_VERSION_3_1   == GL_TRUE || ( major == 3               ) ? GL_TRUE : GL_FALSE;
8920
    CONST_CAST(GLEW_VERSION_2_1)   = GLEW_VERSION_3_0   == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE;    
8921
    CONST_CAST(GLEW_VERSION_2_0)   = GLEW_VERSION_2_1   == GL_TRUE || ( major == 2               ) ? GL_TRUE : GL_FALSE;
8922
    CONST_CAST(GLEW_VERSION_1_5)   = GLEW_VERSION_2_0   == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE;
8923
    CONST_CAST(GLEW_VERSION_1_4)   = GLEW_VERSION_1_5   == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE;
8924
    CONST_CAST(GLEW_VERSION_1_3)   = GLEW_VERSION_1_4   == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
8925
    CONST_CAST(GLEW_VERSION_1_2_1) = GLEW_VERSION_1_3   == GL_TRUE                                 ? GL_TRUE : GL_FALSE; 
8926
    CONST_CAST(GLEW_VERSION_1_2)   = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
8927
    CONST_CAST(GLEW_VERSION_1_1)   = GLEW_VERSION_1_2   == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
8928
  }
8929
 
8930
  /* query opengl extensions string */
8931
  extStart = glGetString(GL_EXTENSIONS);
8932
  if (extStart == 0)
8933
    extStart = (const GLubyte*)"";
8934
  extEnd = extStart + _glewStrLen(extStart);
8935
 
8936
  /* initialize extensions */
8937
#ifdef GL_VERSION_1_2
8938
  if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);
8939
#endif /* GL_VERSION_1_2 */
8940
#ifdef GL_VERSION_1_2_1
8941
#endif /* GL_VERSION_1_2_1 */
8942
#ifdef GL_VERSION_1_3
8943
  if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
8944
#endif /* GL_VERSION_1_3 */
8945
#ifdef GL_VERSION_1_4
8946
  if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);
8947
#endif /* GL_VERSION_1_4 */
8948
#ifdef GL_VERSION_1_5
8949
  if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);
8950
#endif /* GL_VERSION_1_5 */
8951
#ifdef GL_VERSION_2_0
8952
  if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);
8953
#endif /* GL_VERSION_2_0 */
8954
#ifdef GL_VERSION_2_1
8955
  if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT);
8956
#endif /* GL_VERSION_2_1 */
8957
#ifdef GL_VERSION_3_0
8958
  if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT);
8959
#endif /* GL_VERSION_3_0 */
8960
#ifdef GL_VERSION_3_1
8961
  if (glewExperimental || GLEW_VERSION_3_1) CONST_CAST(GLEW_VERSION_3_1) = !_glewInit_GL_VERSION_3_1(GLEW_CONTEXT_ARG_VAR_INIT);
8962
#endif /* GL_VERSION_3_1 */
8963
#ifdef GL_VERSION_3_2
8964
  if (glewExperimental || GLEW_VERSION_3_2) CONST_CAST(GLEW_VERSION_3_2) = !_glewInit_GL_VERSION_3_2(GLEW_CONTEXT_ARG_VAR_INIT);
8965
#endif /* GL_VERSION_3_2 */
8966
#ifdef GL_VERSION_3_3
8967
  if (glewExperimental || GLEW_VERSION_3_3) CONST_CAST(GLEW_VERSION_3_3) = !_glewInit_GL_VERSION_3_3(GLEW_CONTEXT_ARG_VAR_INIT);
8968
#endif /* GL_VERSION_3_3 */
8969
#ifdef GL_VERSION_4_0
8970
  if (glewExperimental || GLEW_VERSION_4_0) CONST_CAST(GLEW_VERSION_4_0) = !_glewInit_GL_VERSION_4_0(GLEW_CONTEXT_ARG_VAR_INIT);
8971
#endif /* GL_VERSION_4_0 */
8972
#ifdef GL_VERSION_4_1
8973
#endif /* GL_VERSION_4_1 */
8974
#ifdef GL_VERSION_4_2
8975
#endif /* GL_VERSION_4_2 */
8976
#ifdef GL_VERSION_4_3
8977
#endif /* GL_VERSION_4_3 */
8978
#ifdef GL_3DFX_multisample
8979
  CONST_CAST(GLEW_3DFX_multisample) = _glewSearchExtension("GL_3DFX_multisample", extStart, extEnd);
8980
#endif /* GL_3DFX_multisample */
8981
#ifdef GL_3DFX_tbuffer
8982
  CONST_CAST(GLEW_3DFX_tbuffer) = _glewSearchExtension("GL_3DFX_tbuffer", extStart, extEnd);
8983
  if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
8984
#endif /* GL_3DFX_tbuffer */
8985
#ifdef GL_3DFX_texture_compression_FXT1
8986
  CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = _glewSearchExtension("GL_3DFX_texture_compression_FXT1", extStart, extEnd);
8987
#endif /* GL_3DFX_texture_compression_FXT1 */
8988
#ifdef GL_AMD_blend_minmax_factor
8989
  CONST_CAST(GLEW_AMD_blend_minmax_factor) = _glewSearchExtension("GL_AMD_blend_minmax_factor", extStart, extEnd);
8990
#endif /* GL_AMD_blend_minmax_factor */
8991
#ifdef GL_AMD_conservative_depth
8992
  CONST_CAST(GLEW_AMD_conservative_depth) = _glewSearchExtension("GL_AMD_conservative_depth", extStart, extEnd);
8993
#endif /* GL_AMD_conservative_depth */
8994
#ifdef GL_AMD_debug_output
8995
  CONST_CAST(GLEW_AMD_debug_output) = _glewSearchExtension("GL_AMD_debug_output", extStart, extEnd);
8996
  if (glewExperimental || GLEW_AMD_debug_output) CONST_CAST(GLEW_AMD_debug_output) = !_glewInit_GL_AMD_debug_output(GLEW_CONTEXT_ARG_VAR_INIT);
8997
#endif /* GL_AMD_debug_output */
8998
#ifdef GL_AMD_depth_clamp_separate
8999
  CONST_CAST(GLEW_AMD_depth_clamp_separate) = _glewSearchExtension("GL_AMD_depth_clamp_separate", extStart, extEnd);
9000
#endif /* GL_AMD_depth_clamp_separate */
9001
#ifdef GL_AMD_draw_buffers_blend
9002
  CONST_CAST(GLEW_AMD_draw_buffers_blend) = _glewSearchExtension("GL_AMD_draw_buffers_blend", extStart, extEnd);
9003
  if (glewExperimental || GLEW_AMD_draw_buffers_blend) CONST_CAST(GLEW_AMD_draw_buffers_blend) = !_glewInit_GL_AMD_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT);
9004
#endif /* GL_AMD_draw_buffers_blend */
9005
#ifdef GL_AMD_multi_draw_indirect
9006
  CONST_CAST(GLEW_AMD_multi_draw_indirect) = _glewSearchExtension("GL_AMD_multi_draw_indirect", extStart, extEnd);
9007
  if (glewExperimental || GLEW_AMD_multi_draw_indirect) CONST_CAST(GLEW_AMD_multi_draw_indirect) = !_glewInit_GL_AMD_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
9008
#endif /* GL_AMD_multi_draw_indirect */
9009
#ifdef GL_AMD_name_gen_delete
9010
  CONST_CAST(GLEW_AMD_name_gen_delete) = _glewSearchExtension("GL_AMD_name_gen_delete", extStart, extEnd);
9011
  if (glewExperimental || GLEW_AMD_name_gen_delete) CONST_CAST(GLEW_AMD_name_gen_delete) = !_glewInit_GL_AMD_name_gen_delete(GLEW_CONTEXT_ARG_VAR_INIT);
9012
#endif /* GL_AMD_name_gen_delete */
9013
#ifdef GL_AMD_performance_monitor
9014
  CONST_CAST(GLEW_AMD_performance_monitor) = _glewSearchExtension("GL_AMD_performance_monitor", extStart, extEnd);
9015
  if (glewExperimental || GLEW_AMD_performance_monitor) CONST_CAST(GLEW_AMD_performance_monitor) = !_glewInit_GL_AMD_performance_monitor(GLEW_CONTEXT_ARG_VAR_INIT);
9016
#endif /* GL_AMD_performance_monitor */
9017
#ifdef GL_AMD_pinned_memory
9018
  CONST_CAST(GLEW_AMD_pinned_memory) = _glewSearchExtension("GL_AMD_pinned_memory", extStart, extEnd);
9019
#endif /* GL_AMD_pinned_memory */
9020
#ifdef GL_AMD_query_buffer_object
9021
  CONST_CAST(GLEW_AMD_query_buffer_object) = _glewSearchExtension("GL_AMD_query_buffer_object", extStart, extEnd);
9022
#endif /* GL_AMD_query_buffer_object */
9023
#ifdef GL_AMD_sample_positions
9024
  CONST_CAST(GLEW_AMD_sample_positions) = _glewSearchExtension("GL_AMD_sample_positions", extStart, extEnd);
9025
  if (glewExperimental || GLEW_AMD_sample_positions) CONST_CAST(GLEW_AMD_sample_positions) = !_glewInit_GL_AMD_sample_positions(GLEW_CONTEXT_ARG_VAR_INIT);
9026
#endif /* GL_AMD_sample_positions */
9027
#ifdef GL_AMD_seamless_cubemap_per_texture
9028
  CONST_CAST(GLEW_AMD_seamless_cubemap_per_texture) = _glewSearchExtension("GL_AMD_seamless_cubemap_per_texture", extStart, extEnd);
9029
#endif /* GL_AMD_seamless_cubemap_per_texture */
9030
#ifdef GL_AMD_shader_stencil_export
9031
  CONST_CAST(GLEW_AMD_shader_stencil_export) = _glewSearchExtension("GL_AMD_shader_stencil_export", extStart, extEnd);
9032
#endif /* GL_AMD_shader_stencil_export */
9033
#ifdef GL_AMD_stencil_operation_extended
9034
  CONST_CAST(GLEW_AMD_stencil_operation_extended) = _glewSearchExtension("GL_AMD_stencil_operation_extended", extStart, extEnd);
9035
  if (glewExperimental || GLEW_AMD_stencil_operation_extended) CONST_CAST(GLEW_AMD_stencil_operation_extended) = !_glewInit_GL_AMD_stencil_operation_extended(GLEW_CONTEXT_ARG_VAR_INIT);
9036
#endif /* GL_AMD_stencil_operation_extended */
9037
#ifdef GL_AMD_texture_texture4
9038
  CONST_CAST(GLEW_AMD_texture_texture4) = _glewSearchExtension("GL_AMD_texture_texture4", extStart, extEnd);
9039
#endif /* GL_AMD_texture_texture4 */
9040
#ifdef GL_AMD_transform_feedback3_lines_triangles
9041
  CONST_CAST(GLEW_AMD_transform_feedback3_lines_triangles) = _glewSearchExtension("GL_AMD_transform_feedback3_lines_triangles", extStart, extEnd);
9042
#endif /* GL_AMD_transform_feedback3_lines_triangles */
9043
#ifdef GL_AMD_vertex_shader_layer
9044
  CONST_CAST(GLEW_AMD_vertex_shader_layer) = _glewSearchExtension("GL_AMD_vertex_shader_layer", extStart, extEnd);
9045
#endif /* GL_AMD_vertex_shader_layer */
9046
#ifdef GL_AMD_vertex_shader_tessellator
9047
  CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = _glewSearchExtension("GL_AMD_vertex_shader_tessellator", extStart, extEnd);
9048
  if (glewExperimental || GLEW_AMD_vertex_shader_tessellator) CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = !_glewInit_GL_AMD_vertex_shader_tessellator(GLEW_CONTEXT_ARG_VAR_INIT);
9049
#endif /* GL_AMD_vertex_shader_tessellator */
9050
#ifdef GL_AMD_vertex_shader_viewport_index
9051
  CONST_CAST(GLEW_AMD_vertex_shader_viewport_index) = _glewSearchExtension("GL_AMD_vertex_shader_viewport_index", extStart, extEnd);
9052
#endif /* GL_AMD_vertex_shader_viewport_index */
9053
#ifdef GL_APPLE_aux_depth_stencil
9054
  CONST_CAST(GLEW_APPLE_aux_depth_stencil) = _glewSearchExtension("GL_APPLE_aux_depth_stencil", extStart, extEnd);
9055
#endif /* GL_APPLE_aux_depth_stencil */
9056
#ifdef GL_APPLE_client_storage
9057
  CONST_CAST(GLEW_APPLE_client_storage) = _glewSearchExtension("GL_APPLE_client_storage", extStart, extEnd);
9058
#endif /* GL_APPLE_client_storage */
9059
#ifdef GL_APPLE_element_array
9060
  CONST_CAST(GLEW_APPLE_element_array) = _glewSearchExtension("GL_APPLE_element_array", extStart, extEnd);
9061
  if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT);
9062
#endif /* GL_APPLE_element_array */
9063
#ifdef GL_APPLE_fence
9064
  CONST_CAST(GLEW_APPLE_fence) = _glewSearchExtension("GL_APPLE_fence", extStart, extEnd);
9065
  if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT);
9066
#endif /* GL_APPLE_fence */
9067
#ifdef GL_APPLE_float_pixels
9068
  CONST_CAST(GLEW_APPLE_float_pixels) = _glewSearchExtension("GL_APPLE_float_pixels", extStart, extEnd);
9069
#endif /* GL_APPLE_float_pixels */
9070
#ifdef GL_APPLE_flush_buffer_range
9071
  CONST_CAST(GLEW_APPLE_flush_buffer_range) = _glewSearchExtension("GL_APPLE_flush_buffer_range", extStart, extEnd);
9072
  if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);
9073
#endif /* GL_APPLE_flush_buffer_range */
9074
#ifdef GL_APPLE_object_purgeable
9075
  CONST_CAST(GLEW_APPLE_object_purgeable) = _glewSearchExtension("GL_APPLE_object_purgeable", extStart, extEnd);
9076
  if (glewExperimental || GLEW_APPLE_object_purgeable) CONST_CAST(GLEW_APPLE_object_purgeable) = !_glewInit_GL_APPLE_object_purgeable(GLEW_CONTEXT_ARG_VAR_INIT);
9077
#endif /* GL_APPLE_object_purgeable */
9078
#ifdef GL_APPLE_pixel_buffer
9079
  CONST_CAST(GLEW_APPLE_pixel_buffer) = _glewSearchExtension("GL_APPLE_pixel_buffer", extStart, extEnd);
9080
#endif /* GL_APPLE_pixel_buffer */
9081
#ifdef GL_APPLE_rgb_422
9082
  CONST_CAST(GLEW_APPLE_rgb_422) = _glewSearchExtension("GL_APPLE_rgb_422", extStart, extEnd);
9083
#endif /* GL_APPLE_rgb_422 */
9084
#ifdef GL_APPLE_row_bytes
9085
  CONST_CAST(GLEW_APPLE_row_bytes) = _glewSearchExtension("GL_APPLE_row_bytes", extStart, extEnd);
9086
#endif /* GL_APPLE_row_bytes */
9087
#ifdef GL_APPLE_specular_vector
9088
  CONST_CAST(GLEW_APPLE_specular_vector) = _glewSearchExtension("GL_APPLE_specular_vector", extStart, extEnd);
9089
#endif /* GL_APPLE_specular_vector */
9090
#ifdef GL_APPLE_texture_range
9091
  CONST_CAST(GLEW_APPLE_texture_range) = _glewSearchExtension("GL_APPLE_texture_range", extStart, extEnd);
9092
  if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT);
9093
#endif /* GL_APPLE_texture_range */
9094
#ifdef GL_APPLE_transform_hint
9095
  CONST_CAST(GLEW_APPLE_transform_hint) = _glewSearchExtension("GL_APPLE_transform_hint", extStart, extEnd);
9096
#endif /* GL_APPLE_transform_hint */
9097
#ifdef GL_APPLE_vertex_array_object
9098
  CONST_CAST(GLEW_APPLE_vertex_array_object) = _glewSearchExtension("GL_APPLE_vertex_array_object", extStart, extEnd);
9099
  if (glewExperimental || GLEW_APPLE_vertex_array_object) CONST_CAST(GLEW_APPLE_vertex_array_object) = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
9100
#endif /* GL_APPLE_vertex_array_object */
9101
#ifdef GL_APPLE_vertex_array_range
9102
  CONST_CAST(GLEW_APPLE_vertex_array_range) = _glewSearchExtension("GL_APPLE_vertex_array_range", extStart, extEnd);
9103
  if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
9104
#endif /* GL_APPLE_vertex_array_range */
9105
#ifdef GL_APPLE_vertex_program_evaluators
9106
  CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = _glewSearchExtension("GL_APPLE_vertex_program_evaluators", extStart, extEnd);
9107
  if (glewExperimental || GLEW_APPLE_vertex_program_evaluators) CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = !_glewInit_GL_APPLE_vertex_program_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);
9108
#endif /* GL_APPLE_vertex_program_evaluators */
9109
#ifdef GL_APPLE_ycbcr_422
9110
  CONST_CAST(GLEW_APPLE_ycbcr_422) = _glewSearchExtension("GL_APPLE_ycbcr_422", extStart, extEnd);
9111
#endif /* GL_APPLE_ycbcr_422 */
9112
#ifdef GL_ARB_ES2_compatibility
9113
  CONST_CAST(GLEW_ARB_ES2_compatibility) = _glewSearchExtension("GL_ARB_ES2_compatibility", extStart, extEnd);
9114
  if (glewExperimental || GLEW_ARB_ES2_compatibility) CONST_CAST(GLEW_ARB_ES2_compatibility) = !_glewInit_GL_ARB_ES2_compatibility(GLEW_CONTEXT_ARG_VAR_INIT);
9115
#endif /* GL_ARB_ES2_compatibility */
9116
#ifdef GL_ARB_ES3_compatibility
9117
  CONST_CAST(GLEW_ARB_ES3_compatibility) = _glewSearchExtension("GL_ARB_ES3_compatibility", extStart, extEnd);
9118
#endif /* GL_ARB_ES3_compatibility */
9119
#ifdef GL_ARB_arrays_of_arrays
9120
  CONST_CAST(GLEW_ARB_arrays_of_arrays) = _glewSearchExtension("GL_ARB_arrays_of_arrays", extStart, extEnd);
9121
#endif /* GL_ARB_arrays_of_arrays */
9122
#ifdef GL_ARB_base_instance
9123
  CONST_CAST(GLEW_ARB_base_instance) = _glewSearchExtension("GL_ARB_base_instance", extStart, extEnd);
9124
  if (glewExperimental || GLEW_ARB_base_instance) CONST_CAST(GLEW_ARB_base_instance) = !_glewInit_GL_ARB_base_instance(GLEW_CONTEXT_ARG_VAR_INIT);
9125
#endif /* GL_ARB_base_instance */
9126
#ifdef GL_ARB_blend_func_extended
9127
  CONST_CAST(GLEW_ARB_blend_func_extended) = _glewSearchExtension("GL_ARB_blend_func_extended", extStart, extEnd);
9128
  if (glewExperimental || GLEW_ARB_blend_func_extended) CONST_CAST(GLEW_ARB_blend_func_extended) = !_glewInit_GL_ARB_blend_func_extended(GLEW_CONTEXT_ARG_VAR_INIT);
9129
#endif /* GL_ARB_blend_func_extended */
9130
#ifdef GL_ARB_cl_event
9131
  CONST_CAST(GLEW_ARB_cl_event) = _glewSearchExtension("GL_ARB_cl_event", extStart, extEnd);
9132
  if (glewExperimental || GLEW_ARB_cl_event) CONST_CAST(GLEW_ARB_cl_event) = !_glewInit_GL_ARB_cl_event(GLEW_CONTEXT_ARG_VAR_INIT);
9133
#endif /* GL_ARB_cl_event */
9134
#ifdef GL_ARB_clear_buffer_object
9135
  CONST_CAST(GLEW_ARB_clear_buffer_object) = _glewSearchExtension("GL_ARB_clear_buffer_object", extStart, extEnd);
9136
  if (glewExperimental || GLEW_ARB_clear_buffer_object) CONST_CAST(GLEW_ARB_clear_buffer_object) = !_glewInit_GL_ARB_clear_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9137
#endif /* GL_ARB_clear_buffer_object */
9138
#ifdef GL_ARB_color_buffer_float
9139
  CONST_CAST(GLEW_ARB_color_buffer_float) = _glewSearchExtension("GL_ARB_color_buffer_float", extStart, extEnd);
9140
  if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);
9141
#endif /* GL_ARB_color_buffer_float */
9142
#ifdef GL_ARB_compatibility
9143
  CONST_CAST(GLEW_ARB_compatibility) = _glewSearchExtension("GL_ARB_compatibility", extStart, extEnd);
9144
#endif /* GL_ARB_compatibility */
9145
#ifdef GL_ARB_compressed_texture_pixel_storage
9146
  CONST_CAST(GLEW_ARB_compressed_texture_pixel_storage) = _glewSearchExtension("GL_ARB_compressed_texture_pixel_storage", extStart, extEnd);
9147
#endif /* GL_ARB_compressed_texture_pixel_storage */
9148
#ifdef GL_ARB_compute_shader
9149
  CONST_CAST(GLEW_ARB_compute_shader) = _glewSearchExtension("GL_ARB_compute_shader", extStart, extEnd);
9150
  if (glewExperimental || GLEW_ARB_compute_shader) CONST_CAST(GLEW_ARB_compute_shader) = !_glewInit_GL_ARB_compute_shader(GLEW_CONTEXT_ARG_VAR_INIT);
9151
#endif /* GL_ARB_compute_shader */
9152
#ifdef GL_ARB_conservative_depth
9153
  CONST_CAST(GLEW_ARB_conservative_depth) = _glewSearchExtension("GL_ARB_conservative_depth", extStart, extEnd);
9154
#endif /* GL_ARB_conservative_depth */
9155
#ifdef GL_ARB_copy_buffer
9156
  CONST_CAST(GLEW_ARB_copy_buffer) = _glewSearchExtension("GL_ARB_copy_buffer", extStart, extEnd);
9157
  if (glewExperimental || GLEW_ARB_copy_buffer) CONST_CAST(GLEW_ARB_copy_buffer) = !_glewInit_GL_ARB_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
9158
#endif /* GL_ARB_copy_buffer */
9159
#ifdef GL_ARB_copy_image
9160
  CONST_CAST(GLEW_ARB_copy_image) = _glewSearchExtension("GL_ARB_copy_image", extStart, extEnd);
9161
  if (glewExperimental || GLEW_ARB_copy_image) CONST_CAST(GLEW_ARB_copy_image) = !_glewInit_GL_ARB_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
9162
#endif /* GL_ARB_copy_image */
9163
#ifdef GL_ARB_debug_output
9164
  CONST_CAST(GLEW_ARB_debug_output) = _glewSearchExtension("GL_ARB_debug_output", extStart, extEnd);
9165
  if (glewExperimental || GLEW_ARB_debug_output) CONST_CAST(GLEW_ARB_debug_output) = !_glewInit_GL_ARB_debug_output(GLEW_CONTEXT_ARG_VAR_INIT);
9166
#endif /* GL_ARB_debug_output */
9167
#ifdef GL_ARB_depth_buffer_float
9168
  CONST_CAST(GLEW_ARB_depth_buffer_float) = _glewSearchExtension("GL_ARB_depth_buffer_float", extStart, extEnd);
9169
#endif /* GL_ARB_depth_buffer_float */
9170
#ifdef GL_ARB_depth_clamp
9171
  CONST_CAST(GLEW_ARB_depth_clamp) = _glewSearchExtension("GL_ARB_depth_clamp", extStart, extEnd);
9172
#endif /* GL_ARB_depth_clamp */
9173
#ifdef GL_ARB_depth_texture
9174
  CONST_CAST(GLEW_ARB_depth_texture) = _glewSearchExtension("GL_ARB_depth_texture", extStart, extEnd);
9175
#endif /* GL_ARB_depth_texture */
9176
#ifdef GL_ARB_draw_buffers
9177
  CONST_CAST(GLEW_ARB_draw_buffers) = _glewSearchExtension("GL_ARB_draw_buffers", extStart, extEnd);
9178
  if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
9179
#endif /* GL_ARB_draw_buffers */
9180
#ifdef GL_ARB_draw_buffers_blend
9181
  CONST_CAST(GLEW_ARB_draw_buffers_blend) = _glewSearchExtension("GL_ARB_draw_buffers_blend", extStart, extEnd);
9182
  if (glewExperimental || GLEW_ARB_draw_buffers_blend) CONST_CAST(GLEW_ARB_draw_buffers_blend) = !_glewInit_GL_ARB_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT);
9183
#endif /* GL_ARB_draw_buffers_blend */
9184
#ifdef GL_ARB_draw_elements_base_vertex
9185
  CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = _glewSearchExtension("GL_ARB_draw_elements_base_vertex", extStart, extEnd);
9186
  if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = !_glewInit_GL_ARB_draw_elements_base_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
9187
#endif /* GL_ARB_draw_elements_base_vertex */
9188
#ifdef GL_ARB_draw_indirect
9189
  CONST_CAST(GLEW_ARB_draw_indirect) = _glewSearchExtension("GL_ARB_draw_indirect", extStart, extEnd);
9190
  if (glewExperimental || GLEW_ARB_draw_indirect) CONST_CAST(GLEW_ARB_draw_indirect) = !_glewInit_GL_ARB_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
9191
#endif /* GL_ARB_draw_indirect */
9192
#ifdef GL_ARB_draw_instanced
9193
  CONST_CAST(GLEW_ARB_draw_instanced) = _glewSearchExtension("GL_ARB_draw_instanced", extStart, extEnd);
9194
#endif /* GL_ARB_draw_instanced */
9195
#ifdef GL_ARB_explicit_attrib_location
9196
  CONST_CAST(GLEW_ARB_explicit_attrib_location) = _glewSearchExtension("GL_ARB_explicit_attrib_location", extStart, extEnd);
9197
#endif /* GL_ARB_explicit_attrib_location */
9198
#ifdef GL_ARB_explicit_uniform_location
9199
  CONST_CAST(GLEW_ARB_explicit_uniform_location) = _glewSearchExtension("GL_ARB_explicit_uniform_location", extStart, extEnd);
9200
#endif /* GL_ARB_explicit_uniform_location */
9201
#ifdef GL_ARB_fragment_coord_conventions
9202
  CONST_CAST(GLEW_ARB_fragment_coord_conventions) = _glewSearchExtension("GL_ARB_fragment_coord_conventions", extStart, extEnd);
9203
#endif /* GL_ARB_fragment_coord_conventions */
9204
#ifdef GL_ARB_fragment_layer_viewport
9205
  CONST_CAST(GLEW_ARB_fragment_layer_viewport) = _glewSearchExtension("GL_ARB_fragment_layer_viewport", extStart, extEnd);
9206
#endif /* GL_ARB_fragment_layer_viewport */
9207
#ifdef GL_ARB_fragment_program
9208
  CONST_CAST(GLEW_ARB_fragment_program) = _glewSearchExtension("GL_ARB_fragment_program", extStart, extEnd);
9209
#endif /* GL_ARB_fragment_program */
9210
#ifdef GL_ARB_fragment_program_shadow
9211
  CONST_CAST(GLEW_ARB_fragment_program_shadow) = _glewSearchExtension("GL_ARB_fragment_program_shadow", extStart, extEnd);
9212
#endif /* GL_ARB_fragment_program_shadow */
9213
#ifdef GL_ARB_fragment_shader
9214
  CONST_CAST(GLEW_ARB_fragment_shader) = _glewSearchExtension("GL_ARB_fragment_shader", extStart, extEnd);
9215
#endif /* GL_ARB_fragment_shader */
9216
#ifdef GL_ARB_framebuffer_no_attachments
9217
  CONST_CAST(GLEW_ARB_framebuffer_no_attachments) = _glewSearchExtension("GL_ARB_framebuffer_no_attachments", extStart, extEnd);
9218
  if (glewExperimental || GLEW_ARB_framebuffer_no_attachments) CONST_CAST(GLEW_ARB_framebuffer_no_attachments) = !_glewInit_GL_ARB_framebuffer_no_attachments(GLEW_CONTEXT_ARG_VAR_INIT);
9219
#endif /* GL_ARB_framebuffer_no_attachments */
9220
#ifdef GL_ARB_framebuffer_object
9221
  CONST_CAST(GLEW_ARB_framebuffer_object) = _glewSearchExtension("GL_ARB_framebuffer_object", extStart, extEnd);
9222
  if (glewExperimental || GLEW_ARB_framebuffer_object) CONST_CAST(GLEW_ARB_framebuffer_object) = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9223
#endif /* GL_ARB_framebuffer_object */
9224
#ifdef GL_ARB_framebuffer_sRGB
9225
  CONST_CAST(GLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GL_ARB_framebuffer_sRGB", extStart, extEnd);
9226
#endif /* GL_ARB_framebuffer_sRGB */
9227
#ifdef GL_ARB_geometry_shader4
9228
  CONST_CAST(GLEW_ARB_geometry_shader4) = _glewSearchExtension("GL_ARB_geometry_shader4", extStart, extEnd);
9229
  if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
9230
#endif /* GL_ARB_geometry_shader4 */
9231
#ifdef GL_ARB_get_program_binary
9232
  CONST_CAST(GLEW_ARB_get_program_binary) = _glewSearchExtension("GL_ARB_get_program_binary", extStart, extEnd);
9233
  if (glewExperimental || GLEW_ARB_get_program_binary) CONST_CAST(GLEW_ARB_get_program_binary) = !_glewInit_GL_ARB_get_program_binary(GLEW_CONTEXT_ARG_VAR_INIT);
9234
#endif /* GL_ARB_get_program_binary */
9235
#ifdef GL_ARB_gpu_shader5
9236
  CONST_CAST(GLEW_ARB_gpu_shader5) = _glewSearchExtension("GL_ARB_gpu_shader5", extStart, extEnd);
9237
#endif /* GL_ARB_gpu_shader5 */
9238
#ifdef GL_ARB_gpu_shader_fp64
9239
  CONST_CAST(GLEW_ARB_gpu_shader_fp64) = _glewSearchExtension("GL_ARB_gpu_shader_fp64", extStart, extEnd);
9240
  if (glewExperimental || GLEW_ARB_gpu_shader_fp64) CONST_CAST(GLEW_ARB_gpu_shader_fp64) = !_glewInit_GL_ARB_gpu_shader_fp64(GLEW_CONTEXT_ARG_VAR_INIT);
9241
#endif /* GL_ARB_gpu_shader_fp64 */
9242
#ifdef GL_ARB_half_float_pixel
9243
  CONST_CAST(GLEW_ARB_half_float_pixel) = _glewSearchExtension("GL_ARB_half_float_pixel", extStart, extEnd);
9244
#endif /* GL_ARB_half_float_pixel */
9245
#ifdef GL_ARB_half_float_vertex
9246
  CONST_CAST(GLEW_ARB_half_float_vertex) = _glewSearchExtension("GL_ARB_half_float_vertex", extStart, extEnd);
9247
#endif /* GL_ARB_half_float_vertex */
9248
#ifdef GL_ARB_imaging
9249
  CONST_CAST(GLEW_ARB_imaging) = _glewSearchExtension("GL_ARB_imaging", extStart, extEnd);
9250
  if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT);
9251
#endif /* GL_ARB_imaging */
9252
#ifdef GL_ARB_instanced_arrays
9253
  CONST_CAST(GLEW_ARB_instanced_arrays) = _glewSearchExtension("GL_ARB_instanced_arrays", extStart, extEnd);
9254
  if (glewExperimental || GLEW_ARB_instanced_arrays) CONST_CAST(GLEW_ARB_instanced_arrays) = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
9255
#endif /* GL_ARB_instanced_arrays */
9256
#ifdef GL_ARB_internalformat_query
9257
  CONST_CAST(GLEW_ARB_internalformat_query) = _glewSearchExtension("GL_ARB_internalformat_query", extStart, extEnd);
9258
  if (glewExperimental || GLEW_ARB_internalformat_query) CONST_CAST(GLEW_ARB_internalformat_query) = !_glewInit_GL_ARB_internalformat_query(GLEW_CONTEXT_ARG_VAR_INIT);
9259
#endif /* GL_ARB_internalformat_query */
9260
#ifdef GL_ARB_internalformat_query2
9261
  CONST_CAST(GLEW_ARB_internalformat_query2) = _glewSearchExtension("GL_ARB_internalformat_query2", extStart, extEnd);
9262
  if (glewExperimental || GLEW_ARB_internalformat_query2) CONST_CAST(GLEW_ARB_internalformat_query2) = !_glewInit_GL_ARB_internalformat_query2(GLEW_CONTEXT_ARG_VAR_INIT);
9263
#endif /* GL_ARB_internalformat_query2 */
9264
#ifdef GL_ARB_invalidate_subdata
9265
  CONST_CAST(GLEW_ARB_invalidate_subdata) = _glewSearchExtension("GL_ARB_invalidate_subdata", extStart, extEnd);
9266
  if (glewExperimental || GLEW_ARB_invalidate_subdata) CONST_CAST(GLEW_ARB_invalidate_subdata) = !_glewInit_GL_ARB_invalidate_subdata(GLEW_CONTEXT_ARG_VAR_INIT);
9267
#endif /* GL_ARB_invalidate_subdata */
9268
#ifdef GL_ARB_map_buffer_alignment
9269
  CONST_CAST(GLEW_ARB_map_buffer_alignment) = _glewSearchExtension("GL_ARB_map_buffer_alignment", extStart, extEnd);
9270
#endif /* GL_ARB_map_buffer_alignment */
9271
#ifdef GL_ARB_map_buffer_range
9272
  CONST_CAST(GLEW_ARB_map_buffer_range) = _glewSearchExtension("GL_ARB_map_buffer_range", extStart, extEnd);
9273
  if (glewExperimental || GLEW_ARB_map_buffer_range) CONST_CAST(GLEW_ARB_map_buffer_range) = !_glewInit_GL_ARB_map_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);
9274
#endif /* GL_ARB_map_buffer_range */
9275
#ifdef GL_ARB_matrix_palette
9276
  CONST_CAST(GLEW_ARB_matrix_palette) = _glewSearchExtension("GL_ARB_matrix_palette", extStart, extEnd);
9277
  if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT);
9278
#endif /* GL_ARB_matrix_palette */
9279
#ifdef GL_ARB_multi_draw_indirect
9280
  CONST_CAST(GLEW_ARB_multi_draw_indirect) = _glewSearchExtension("GL_ARB_multi_draw_indirect", extStart, extEnd);
9281
  if (glewExperimental || GLEW_ARB_multi_draw_indirect) CONST_CAST(GLEW_ARB_multi_draw_indirect) = !_glewInit_GL_ARB_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
9282
#endif /* GL_ARB_multi_draw_indirect */
9283
#ifdef GL_ARB_multisample
9284
  CONST_CAST(GLEW_ARB_multisample) = _glewSearchExtension("GL_ARB_multisample", extStart, extEnd);
9285
  if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9286
#endif /* GL_ARB_multisample */
9287
#ifdef GL_ARB_multitexture
9288
  CONST_CAST(GLEW_ARB_multitexture) = _glewSearchExtension("GL_ARB_multitexture", extStart, extEnd);
9289
  if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);
9290
#endif /* GL_ARB_multitexture */
9291
#ifdef GL_ARB_occlusion_query
9292
  CONST_CAST(GLEW_ARB_occlusion_query) = _glewSearchExtension("GL_ARB_occlusion_query", extStart, extEnd);
9293
  if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
9294
#endif /* GL_ARB_occlusion_query */
9295
#ifdef GL_ARB_occlusion_query2
9296
  CONST_CAST(GLEW_ARB_occlusion_query2) = _glewSearchExtension("GL_ARB_occlusion_query2", extStart, extEnd);
9297
#endif /* GL_ARB_occlusion_query2 */
9298
#ifdef GL_ARB_pixel_buffer_object
9299
  CONST_CAST(GLEW_ARB_pixel_buffer_object) = _glewSearchExtension("GL_ARB_pixel_buffer_object", extStart, extEnd);
9300
#endif /* GL_ARB_pixel_buffer_object */
9301
#ifdef GL_ARB_point_parameters
9302
  CONST_CAST(GLEW_ARB_point_parameters) = _glewSearchExtension("GL_ARB_point_parameters", extStart, extEnd);
9303
  if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
9304
#endif /* GL_ARB_point_parameters */
9305
#ifdef GL_ARB_point_sprite
9306
  CONST_CAST(GLEW_ARB_point_sprite) = _glewSearchExtension("GL_ARB_point_sprite", extStart, extEnd);
9307
#endif /* GL_ARB_point_sprite */
9308
#ifdef GL_ARB_program_interface_query
9309
  CONST_CAST(GLEW_ARB_program_interface_query) = _glewSearchExtension("GL_ARB_program_interface_query", extStart, extEnd);
9310
  if (glewExperimental || GLEW_ARB_program_interface_query) CONST_CAST(GLEW_ARB_program_interface_query) = !_glewInit_GL_ARB_program_interface_query(GLEW_CONTEXT_ARG_VAR_INIT);
9311
#endif /* GL_ARB_program_interface_query */
9312
#ifdef GL_ARB_provoking_vertex
9313
  CONST_CAST(GLEW_ARB_provoking_vertex) = _glewSearchExtension("GL_ARB_provoking_vertex", extStart, extEnd);
9314
  if (glewExperimental || GLEW_ARB_provoking_vertex) CONST_CAST(GLEW_ARB_provoking_vertex) = !_glewInit_GL_ARB_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
9315
#endif /* GL_ARB_provoking_vertex */
9316
#ifdef GL_ARB_robust_buffer_access_behavior
9317
  CONST_CAST(GLEW_ARB_robust_buffer_access_behavior) = _glewSearchExtension("GL_ARB_robust_buffer_access_behavior", extStart, extEnd);
9318
#endif /* GL_ARB_robust_buffer_access_behavior */
9319
#ifdef GL_ARB_robustness
9320
  CONST_CAST(GLEW_ARB_robustness) = _glewSearchExtension("GL_ARB_robustness", extStart, extEnd);
9321
  if (glewExperimental || GLEW_ARB_robustness) CONST_CAST(GLEW_ARB_robustness) = !_glewInit_GL_ARB_robustness(GLEW_CONTEXT_ARG_VAR_INIT);
9322
#endif /* GL_ARB_robustness */
9323
#ifdef GL_ARB_robustness_application_isolation
9324
  CONST_CAST(GLEW_ARB_robustness_application_isolation) = _glewSearchExtension("GL_ARB_robustness_application_isolation", extStart, extEnd);
9325
#endif /* GL_ARB_robustness_application_isolation */
9326
#ifdef GL_ARB_robustness_share_group_isolation
9327
  CONST_CAST(GLEW_ARB_robustness_share_group_isolation) = _glewSearchExtension("GL_ARB_robustness_share_group_isolation", extStart, extEnd);
9328
#endif /* GL_ARB_robustness_share_group_isolation */
9329
#ifdef GL_ARB_sample_shading
9330
  CONST_CAST(GLEW_ARB_sample_shading) = _glewSearchExtension("GL_ARB_sample_shading", extStart, extEnd);
9331
  if (glewExperimental || GLEW_ARB_sample_shading) CONST_CAST(GLEW_ARB_sample_shading) = !_glewInit_GL_ARB_sample_shading(GLEW_CONTEXT_ARG_VAR_INIT);
9332
#endif /* GL_ARB_sample_shading */
9333
#ifdef GL_ARB_sampler_objects
9334
  CONST_CAST(GLEW_ARB_sampler_objects) = _glewSearchExtension("GL_ARB_sampler_objects", extStart, extEnd);
9335
  if (glewExperimental || GLEW_ARB_sampler_objects) CONST_CAST(GLEW_ARB_sampler_objects) = !_glewInit_GL_ARB_sampler_objects(GLEW_CONTEXT_ARG_VAR_INIT);
9336
#endif /* GL_ARB_sampler_objects */
9337
#ifdef GL_ARB_seamless_cube_map
9338
  CONST_CAST(GLEW_ARB_seamless_cube_map) = _glewSearchExtension("GL_ARB_seamless_cube_map", extStart, extEnd);
9339
#endif /* GL_ARB_seamless_cube_map */
9340
#ifdef GL_ARB_separate_shader_objects
9341
  CONST_CAST(GLEW_ARB_separate_shader_objects) = _glewSearchExtension("GL_ARB_separate_shader_objects", extStart, extEnd);
9342
  if (glewExperimental || GLEW_ARB_separate_shader_objects) CONST_CAST(GLEW_ARB_separate_shader_objects) = !_glewInit_GL_ARB_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
9343
#endif /* GL_ARB_separate_shader_objects */
9344
#ifdef GL_ARB_shader_atomic_counters
9345
  CONST_CAST(GLEW_ARB_shader_atomic_counters) = _glewSearchExtension("GL_ARB_shader_atomic_counters", extStart, extEnd);
9346
  if (glewExperimental || GLEW_ARB_shader_atomic_counters) CONST_CAST(GLEW_ARB_shader_atomic_counters) = !_glewInit_GL_ARB_shader_atomic_counters(GLEW_CONTEXT_ARG_VAR_INIT);
9347
#endif /* GL_ARB_shader_atomic_counters */
9348
#ifdef GL_ARB_shader_bit_encoding
9349
  CONST_CAST(GLEW_ARB_shader_bit_encoding) = _glewSearchExtension("GL_ARB_shader_bit_encoding", extStart, extEnd);
9350
#endif /* GL_ARB_shader_bit_encoding */
9351
#ifdef GL_ARB_shader_image_load_store
9352
  CONST_CAST(GLEW_ARB_shader_image_load_store) = _glewSearchExtension("GL_ARB_shader_image_load_store", extStart, extEnd);
9353
  if (glewExperimental || GLEW_ARB_shader_image_load_store) CONST_CAST(GLEW_ARB_shader_image_load_store) = !_glewInit_GL_ARB_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT);
9354
#endif /* GL_ARB_shader_image_load_store */
9355
#ifdef GL_ARB_shader_image_size
9356
  CONST_CAST(GLEW_ARB_shader_image_size) = _glewSearchExtension("GL_ARB_shader_image_size", extStart, extEnd);
9357
#endif /* GL_ARB_shader_image_size */
9358
#ifdef GL_ARB_shader_objects
9359
  CONST_CAST(GLEW_ARB_shader_objects) = _glewSearchExtension("GL_ARB_shader_objects", extStart, extEnd);
9360
  if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
9361
#endif /* GL_ARB_shader_objects */
9362
#ifdef GL_ARB_shader_precision
9363
  CONST_CAST(GLEW_ARB_shader_precision) = _glewSearchExtension("GL_ARB_shader_precision", extStart, extEnd);
9364
#endif /* GL_ARB_shader_precision */
9365
#ifdef GL_ARB_shader_stencil_export
9366
  CONST_CAST(GLEW_ARB_shader_stencil_export) = _glewSearchExtension("GL_ARB_shader_stencil_export", extStart, extEnd);
9367
#endif /* GL_ARB_shader_stencil_export */
9368
#ifdef GL_ARB_shader_storage_buffer_object
9369
  CONST_CAST(GLEW_ARB_shader_storage_buffer_object) = _glewSearchExtension("GL_ARB_shader_storage_buffer_object", extStart, extEnd);
9370
  if (glewExperimental || GLEW_ARB_shader_storage_buffer_object) CONST_CAST(GLEW_ARB_shader_storage_buffer_object) = !_glewInit_GL_ARB_shader_storage_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9371
#endif /* GL_ARB_shader_storage_buffer_object */
9372
#ifdef GL_ARB_shader_subroutine
9373
  CONST_CAST(GLEW_ARB_shader_subroutine) = _glewSearchExtension("GL_ARB_shader_subroutine", extStart, extEnd);
9374
  if (glewExperimental || GLEW_ARB_shader_subroutine) CONST_CAST(GLEW_ARB_shader_subroutine) = !_glewInit_GL_ARB_shader_subroutine(GLEW_CONTEXT_ARG_VAR_INIT);
9375
#endif /* GL_ARB_shader_subroutine */
9376
#ifdef GL_ARB_shader_texture_lod
9377
  CONST_CAST(GLEW_ARB_shader_texture_lod) = _glewSearchExtension("GL_ARB_shader_texture_lod", extStart, extEnd);
9378
#endif /* GL_ARB_shader_texture_lod */
9379
#ifdef GL_ARB_shading_language_100
9380
  CONST_CAST(GLEW_ARB_shading_language_100) = _glewSearchExtension("GL_ARB_shading_language_100", extStart, extEnd);
9381
#endif /* GL_ARB_shading_language_100 */
9382
#ifdef GL_ARB_shading_language_420pack
9383
  CONST_CAST(GLEW_ARB_shading_language_420pack) = _glewSearchExtension("GL_ARB_shading_language_420pack", extStart, extEnd);
9384
#endif /* GL_ARB_shading_language_420pack */
9385
#ifdef GL_ARB_shading_language_include
9386
  CONST_CAST(GLEW_ARB_shading_language_include) = _glewSearchExtension("GL_ARB_shading_language_include", extStart, extEnd);
9387
  if (glewExperimental || GLEW_ARB_shading_language_include) CONST_CAST(GLEW_ARB_shading_language_include) = !_glewInit_GL_ARB_shading_language_include(GLEW_CONTEXT_ARG_VAR_INIT);
9388
#endif /* GL_ARB_shading_language_include */
9389
#ifdef GL_ARB_shading_language_packing
9390
  CONST_CAST(GLEW_ARB_shading_language_packing) = _glewSearchExtension("GL_ARB_shading_language_packing", extStart, extEnd);
9391
#endif /* GL_ARB_shading_language_packing */
9392
#ifdef GL_ARB_shadow
9393
  CONST_CAST(GLEW_ARB_shadow) = _glewSearchExtension("GL_ARB_shadow", extStart, extEnd);
9394
#endif /* GL_ARB_shadow */
9395
#ifdef GL_ARB_shadow_ambient
9396
  CONST_CAST(GLEW_ARB_shadow_ambient) = _glewSearchExtension("GL_ARB_shadow_ambient", extStart, extEnd);
9397
#endif /* GL_ARB_shadow_ambient */
9398
#ifdef GL_ARB_stencil_texturing
9399
  CONST_CAST(GLEW_ARB_stencil_texturing) = _glewSearchExtension("GL_ARB_stencil_texturing", extStart, extEnd);
9400
#endif /* GL_ARB_stencil_texturing */
9401
#ifdef GL_ARB_sync
9402
  CONST_CAST(GLEW_ARB_sync) = _glewSearchExtension("GL_ARB_sync", extStart, extEnd);
9403
  if (glewExperimental || GLEW_ARB_sync) CONST_CAST(GLEW_ARB_sync) = !_glewInit_GL_ARB_sync(GLEW_CONTEXT_ARG_VAR_INIT);
9404
#endif /* GL_ARB_sync */
9405
#ifdef GL_ARB_tessellation_shader
9406
  CONST_CAST(GLEW_ARB_tessellation_shader) = _glewSearchExtension("GL_ARB_tessellation_shader", extStart, extEnd);
9407
  if (glewExperimental || GLEW_ARB_tessellation_shader) CONST_CAST(GLEW_ARB_tessellation_shader) = !_glewInit_GL_ARB_tessellation_shader(GLEW_CONTEXT_ARG_VAR_INIT);
9408
#endif /* GL_ARB_tessellation_shader */
9409
#ifdef GL_ARB_texture_border_clamp
9410
  CONST_CAST(GLEW_ARB_texture_border_clamp) = _glewSearchExtension("GL_ARB_texture_border_clamp", extStart, extEnd);
9411
#endif /* GL_ARB_texture_border_clamp */
9412
#ifdef GL_ARB_texture_buffer_object
9413
  CONST_CAST(GLEW_ARB_texture_buffer_object) = _glewSearchExtension("GL_ARB_texture_buffer_object", extStart, extEnd);
9414
  if (glewExperimental || GLEW_ARB_texture_buffer_object) CONST_CAST(GLEW_ARB_texture_buffer_object) = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9415
#endif /* GL_ARB_texture_buffer_object */
9416
#ifdef GL_ARB_texture_buffer_object_rgb32
9417
  CONST_CAST(GLEW_ARB_texture_buffer_object_rgb32) = _glewSearchExtension("GL_ARB_texture_buffer_object_rgb32", extStart, extEnd);
9418
#endif /* GL_ARB_texture_buffer_object_rgb32 */
9419
#ifdef GL_ARB_texture_buffer_range
9420
  CONST_CAST(GLEW_ARB_texture_buffer_range) = _glewSearchExtension("GL_ARB_texture_buffer_range", extStart, extEnd);
9421
  if (glewExperimental || GLEW_ARB_texture_buffer_range) CONST_CAST(GLEW_ARB_texture_buffer_range) = !_glewInit_GL_ARB_texture_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);
9422
#endif /* GL_ARB_texture_buffer_range */
9423
#ifdef GL_ARB_texture_compression
9424
  CONST_CAST(GLEW_ARB_texture_compression) = _glewSearchExtension("GL_ARB_texture_compression", extStart, extEnd);
9425
  if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);
9426
#endif /* GL_ARB_texture_compression */
9427
#ifdef GL_ARB_texture_compression_bptc
9428
  CONST_CAST(GLEW_ARB_texture_compression_bptc) = _glewSearchExtension("GL_ARB_texture_compression_bptc", extStart, extEnd);
9429
#endif /* GL_ARB_texture_compression_bptc */
9430
#ifdef GL_ARB_texture_compression_rgtc
9431
  CONST_CAST(GLEW_ARB_texture_compression_rgtc) = _glewSearchExtension("GL_ARB_texture_compression_rgtc", extStart, extEnd);
9432
#endif /* GL_ARB_texture_compression_rgtc */
9433
#ifdef GL_ARB_texture_cube_map
9434
  CONST_CAST(GLEW_ARB_texture_cube_map) = _glewSearchExtension("GL_ARB_texture_cube_map", extStart, extEnd);
9435
#endif /* GL_ARB_texture_cube_map */
9436
#ifdef GL_ARB_texture_cube_map_array
9437
  CONST_CAST(GLEW_ARB_texture_cube_map_array) = _glewSearchExtension("GL_ARB_texture_cube_map_array", extStart, extEnd);
9438
#endif /* GL_ARB_texture_cube_map_array */
9439
#ifdef GL_ARB_texture_env_add
9440
  CONST_CAST(GLEW_ARB_texture_env_add) = _glewSearchExtension("GL_ARB_texture_env_add", extStart, extEnd);
9441
#endif /* GL_ARB_texture_env_add */
9442
#ifdef GL_ARB_texture_env_combine
9443
  CONST_CAST(GLEW_ARB_texture_env_combine) = _glewSearchExtension("GL_ARB_texture_env_combine", extStart, extEnd);
9444
#endif /* GL_ARB_texture_env_combine */
9445
#ifdef GL_ARB_texture_env_crossbar
9446
  CONST_CAST(GLEW_ARB_texture_env_crossbar) = _glewSearchExtension("GL_ARB_texture_env_crossbar", extStart, extEnd);
9447
#endif /* GL_ARB_texture_env_crossbar */
9448
#ifdef GL_ARB_texture_env_dot3
9449
  CONST_CAST(GLEW_ARB_texture_env_dot3) = _glewSearchExtension("GL_ARB_texture_env_dot3", extStart, extEnd);
9450
#endif /* GL_ARB_texture_env_dot3 */
9451
#ifdef GL_ARB_texture_float
9452
  CONST_CAST(GLEW_ARB_texture_float) = _glewSearchExtension("GL_ARB_texture_float", extStart, extEnd);
9453
#endif /* GL_ARB_texture_float */
9454
#ifdef GL_ARB_texture_gather
9455
  CONST_CAST(GLEW_ARB_texture_gather) = _glewSearchExtension("GL_ARB_texture_gather", extStart, extEnd);
9456
#endif /* GL_ARB_texture_gather */
9457
#ifdef GL_ARB_texture_mirrored_repeat
9458
  CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = _glewSearchExtension("GL_ARB_texture_mirrored_repeat", extStart, extEnd);
9459
#endif /* GL_ARB_texture_mirrored_repeat */
9460
#ifdef GL_ARB_texture_multisample
9461
  CONST_CAST(GLEW_ARB_texture_multisample) = _glewSearchExtension("GL_ARB_texture_multisample", extStart, extEnd);
9462
  if (glewExperimental || GLEW_ARB_texture_multisample) CONST_CAST(GLEW_ARB_texture_multisample) = !_glewInit_GL_ARB_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9463
#endif /* GL_ARB_texture_multisample */
9464
#ifdef GL_ARB_texture_non_power_of_two
9465
  CONST_CAST(GLEW_ARB_texture_non_power_of_two) = _glewSearchExtension("GL_ARB_texture_non_power_of_two", extStart, extEnd);
9466
#endif /* GL_ARB_texture_non_power_of_two */
9467
#ifdef GL_ARB_texture_query_levels
9468
  CONST_CAST(GLEW_ARB_texture_query_levels) = _glewSearchExtension("GL_ARB_texture_query_levels", extStart, extEnd);
9469
#endif /* GL_ARB_texture_query_levels */
9470
#ifdef GL_ARB_texture_query_lod
9471
  CONST_CAST(GLEW_ARB_texture_query_lod) = _glewSearchExtension("GL_ARB_texture_query_lod", extStart, extEnd);
9472
#endif /* GL_ARB_texture_query_lod */
9473
#ifdef GL_ARB_texture_rectangle
9474
  CONST_CAST(GLEW_ARB_texture_rectangle) = _glewSearchExtension("GL_ARB_texture_rectangle", extStart, extEnd);
9475
#endif /* GL_ARB_texture_rectangle */
9476
#ifdef GL_ARB_texture_rg
9477
  CONST_CAST(GLEW_ARB_texture_rg) = _glewSearchExtension("GL_ARB_texture_rg", extStart, extEnd);
9478
#endif /* GL_ARB_texture_rg */
9479
#ifdef GL_ARB_texture_rgb10_a2ui
9480
  CONST_CAST(GLEW_ARB_texture_rgb10_a2ui) = _glewSearchExtension("GL_ARB_texture_rgb10_a2ui", extStart, extEnd);
9481
#endif /* GL_ARB_texture_rgb10_a2ui */
9482
#ifdef GL_ARB_texture_storage
9483
  CONST_CAST(GLEW_ARB_texture_storage) = _glewSearchExtension("GL_ARB_texture_storage", extStart, extEnd);
9484
  if (glewExperimental || GLEW_ARB_texture_storage) CONST_CAST(GLEW_ARB_texture_storage) = !_glewInit_GL_ARB_texture_storage(GLEW_CONTEXT_ARG_VAR_INIT);
9485
#endif /* GL_ARB_texture_storage */
9486
#ifdef GL_ARB_texture_storage_multisample
9487
  CONST_CAST(GLEW_ARB_texture_storage_multisample) = _glewSearchExtension("GL_ARB_texture_storage_multisample", extStart, extEnd);
9488
  if (glewExperimental || GLEW_ARB_texture_storage_multisample) CONST_CAST(GLEW_ARB_texture_storage_multisample) = !_glewInit_GL_ARB_texture_storage_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9489
#endif /* GL_ARB_texture_storage_multisample */
9490
#ifdef GL_ARB_texture_swizzle
9491
  CONST_CAST(GLEW_ARB_texture_swizzle) = _glewSearchExtension("GL_ARB_texture_swizzle", extStart, extEnd);
9492
#endif /* GL_ARB_texture_swizzle */
9493
#ifdef GL_ARB_texture_view
9494
  CONST_CAST(GLEW_ARB_texture_view) = _glewSearchExtension("GL_ARB_texture_view", extStart, extEnd);
9495
  if (glewExperimental || GLEW_ARB_texture_view) CONST_CAST(GLEW_ARB_texture_view) = !_glewInit_GL_ARB_texture_view(GLEW_CONTEXT_ARG_VAR_INIT);
9496
#endif /* GL_ARB_texture_view */
9497
#ifdef GL_ARB_timer_query
9498
  CONST_CAST(GLEW_ARB_timer_query) = _glewSearchExtension("GL_ARB_timer_query", extStart, extEnd);
9499
  if (glewExperimental || GLEW_ARB_timer_query) CONST_CAST(GLEW_ARB_timer_query) = !_glewInit_GL_ARB_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
9500
#endif /* GL_ARB_timer_query */
9501
#ifdef GL_ARB_transform_feedback2
9502
  CONST_CAST(GLEW_ARB_transform_feedback2) = _glewSearchExtension("GL_ARB_transform_feedback2", extStart, extEnd);
9503
  if (glewExperimental || GLEW_ARB_transform_feedback2) CONST_CAST(GLEW_ARB_transform_feedback2) = !_glewInit_GL_ARB_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
9504
#endif /* GL_ARB_transform_feedback2 */
9505
#ifdef GL_ARB_transform_feedback3
9506
  CONST_CAST(GLEW_ARB_transform_feedback3) = _glewSearchExtension("GL_ARB_transform_feedback3", extStart, extEnd);
9507
  if (glewExperimental || GLEW_ARB_transform_feedback3) CONST_CAST(GLEW_ARB_transform_feedback3) = !_glewInit_GL_ARB_transform_feedback3(GLEW_CONTEXT_ARG_VAR_INIT);
9508
#endif /* GL_ARB_transform_feedback3 */
9509
#ifdef GL_ARB_transform_feedback_instanced
9510
  CONST_CAST(GLEW_ARB_transform_feedback_instanced) = _glewSearchExtension("GL_ARB_transform_feedback_instanced", extStart, extEnd);
9511
  if (glewExperimental || GLEW_ARB_transform_feedback_instanced) CONST_CAST(GLEW_ARB_transform_feedback_instanced) = !_glewInit_GL_ARB_transform_feedback_instanced(GLEW_CONTEXT_ARG_VAR_INIT);
9512
#endif /* GL_ARB_transform_feedback_instanced */
9513
#ifdef GL_ARB_transpose_matrix
9514
  CONST_CAST(GLEW_ARB_transpose_matrix) = _glewSearchExtension("GL_ARB_transpose_matrix", extStart, extEnd);
9515
  if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT);
9516
#endif /* GL_ARB_transpose_matrix */
9517
#ifdef GL_ARB_uniform_buffer_object
9518
  CONST_CAST(GLEW_ARB_uniform_buffer_object) = _glewSearchExtension("GL_ARB_uniform_buffer_object", extStart, extEnd);
9519
  if (glewExperimental || GLEW_ARB_uniform_buffer_object) CONST_CAST(GLEW_ARB_uniform_buffer_object) = !_glewInit_GL_ARB_uniform_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9520
#endif /* GL_ARB_uniform_buffer_object */
9521
#ifdef GL_ARB_vertex_array_bgra
9522
  CONST_CAST(GLEW_ARB_vertex_array_bgra) = _glewSearchExtension("GL_ARB_vertex_array_bgra", extStart, extEnd);
9523
#endif /* GL_ARB_vertex_array_bgra */
9524
#ifdef GL_ARB_vertex_array_object
9525
  CONST_CAST(GLEW_ARB_vertex_array_object) = _glewSearchExtension("GL_ARB_vertex_array_object", extStart, extEnd);
9526
  if (glewExperimental || GLEW_ARB_vertex_array_object) CONST_CAST(GLEW_ARB_vertex_array_object) = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
9527
#endif /* GL_ARB_vertex_array_object */
9528
#ifdef GL_ARB_vertex_attrib_64bit
9529
  CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = _glewSearchExtension("GL_ARB_vertex_attrib_64bit", extStart, extEnd);
9530
  if (glewExperimental || GLEW_ARB_vertex_attrib_64bit) CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = !_glewInit_GL_ARB_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
9531
#endif /* GL_ARB_vertex_attrib_64bit */
9532
#ifdef GL_ARB_vertex_attrib_binding
9533
  CONST_CAST(GLEW_ARB_vertex_attrib_binding) = _glewSearchExtension("GL_ARB_vertex_attrib_binding", extStart, extEnd);
9534
  if (glewExperimental || GLEW_ARB_vertex_attrib_binding) CONST_CAST(GLEW_ARB_vertex_attrib_binding) = !_glewInit_GL_ARB_vertex_attrib_binding(GLEW_CONTEXT_ARG_VAR_INIT);
9535
#endif /* GL_ARB_vertex_attrib_binding */
9536
#ifdef GL_ARB_vertex_blend
9537
  CONST_CAST(GLEW_ARB_vertex_blend) = _glewSearchExtension("GL_ARB_vertex_blend", extStart, extEnd);
9538
  if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT);
9539
#endif /* GL_ARB_vertex_blend */
9540
#ifdef GL_ARB_vertex_buffer_object
9541
  CONST_CAST(GLEW_ARB_vertex_buffer_object) = _glewSearchExtension("GL_ARB_vertex_buffer_object", extStart, extEnd);
9542
  if (glewExperimental || GLEW_ARB_vertex_buffer_object) CONST_CAST(GLEW_ARB_vertex_buffer_object) = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9543
#endif /* GL_ARB_vertex_buffer_object */
9544
#ifdef GL_ARB_vertex_program
9545
  CONST_CAST(GLEW_ARB_vertex_program) = _glewSearchExtension("GL_ARB_vertex_program", extStart, extEnd);
9546
  if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
9547
#endif /* GL_ARB_vertex_program */
9548
#ifdef GL_ARB_vertex_shader
9549
  CONST_CAST(GLEW_ARB_vertex_shader) = _glewSearchExtension("GL_ARB_vertex_shader", extStart, extEnd);
9550
  if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
9551
#endif /* GL_ARB_vertex_shader */
9552
#ifdef GL_ARB_vertex_type_2_10_10_10_rev
9553
  CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = _glewSearchExtension("GL_ARB_vertex_type_2_10_10_10_rev", extStart, extEnd);
9554
  if (glewExperimental || GLEW_ARB_vertex_type_2_10_10_10_rev) CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = !_glewInit_GL_ARB_vertex_type_2_10_10_10_rev(GLEW_CONTEXT_ARG_VAR_INIT);
9555
#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
9556
#ifdef GL_ARB_viewport_array
9557
  CONST_CAST(GLEW_ARB_viewport_array) = _glewSearchExtension("GL_ARB_viewport_array", extStart, extEnd);
9558
  if (glewExperimental || GLEW_ARB_viewport_array) CONST_CAST(GLEW_ARB_viewport_array) = !_glewInit_GL_ARB_viewport_array(GLEW_CONTEXT_ARG_VAR_INIT);
9559
#endif /* GL_ARB_viewport_array */
9560
#ifdef GL_ARB_window_pos
9561
  CONST_CAST(GLEW_ARB_window_pos) = _glewSearchExtension("GL_ARB_window_pos", extStart, extEnd);
9562
  if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
9563
#endif /* GL_ARB_window_pos */
9564
#ifdef GL_ATIX_point_sprites
9565
  CONST_CAST(GLEW_ATIX_point_sprites) = _glewSearchExtension("GL_ATIX_point_sprites", extStart, extEnd);
9566
#endif /* GL_ATIX_point_sprites */
9567
#ifdef GL_ATIX_texture_env_combine3
9568
  CONST_CAST(GLEW_ATIX_texture_env_combine3) = _glewSearchExtension("GL_ATIX_texture_env_combine3", extStart, extEnd);
9569
#endif /* GL_ATIX_texture_env_combine3 */
9570
#ifdef GL_ATIX_texture_env_route
9571
  CONST_CAST(GLEW_ATIX_texture_env_route) = _glewSearchExtension("GL_ATIX_texture_env_route", extStart, extEnd);
9572
#endif /* GL_ATIX_texture_env_route */
9573
#ifdef GL_ATIX_vertex_shader_output_point_size
9574
  CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = _glewSearchExtension("GL_ATIX_vertex_shader_output_point_size", extStart, extEnd);
9575
#endif /* GL_ATIX_vertex_shader_output_point_size */
9576
#ifdef GL_ATI_draw_buffers
9577
  CONST_CAST(GLEW_ATI_draw_buffers) = _glewSearchExtension("GL_ATI_draw_buffers", extStart, extEnd);
9578
  if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
9579
#endif /* GL_ATI_draw_buffers */
9580
#ifdef GL_ATI_element_array
9581
  CONST_CAST(GLEW_ATI_element_array) = _glewSearchExtension("GL_ATI_element_array", extStart, extEnd);
9582
  if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT);
9583
#endif /* GL_ATI_element_array */
9584
#ifdef GL_ATI_envmap_bumpmap
9585
  CONST_CAST(GLEW_ATI_envmap_bumpmap) = _glewSearchExtension("GL_ATI_envmap_bumpmap", extStart, extEnd);
9586
  if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT);
9587
#endif /* GL_ATI_envmap_bumpmap */
9588
#ifdef GL_ATI_fragment_shader
9589
  CONST_CAST(GLEW_ATI_fragment_shader) = _glewSearchExtension("GL_ATI_fragment_shader", extStart, extEnd);
9590
  if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);
9591
#endif /* GL_ATI_fragment_shader */
9592
#ifdef GL_ATI_map_object_buffer
9593
  CONST_CAST(GLEW_ATI_map_object_buffer) = _glewSearchExtension("GL_ATI_map_object_buffer", extStart, extEnd);
9594
  if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
9595
#endif /* GL_ATI_map_object_buffer */
9596
#ifdef GL_ATI_meminfo
9597
  CONST_CAST(GLEW_ATI_meminfo) = _glewSearchExtension("GL_ATI_meminfo", extStart, extEnd);
9598
#endif /* GL_ATI_meminfo */
9599
#ifdef GL_ATI_pn_triangles
9600
  CONST_CAST(GLEW_ATI_pn_triangles) = _glewSearchExtension("GL_ATI_pn_triangles", extStart, extEnd);
9601
  if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);
9602
#endif /* GL_ATI_pn_triangles */
9603
#ifdef GL_ATI_separate_stencil
9604
  CONST_CAST(GLEW_ATI_separate_stencil) = _glewSearchExtension("GL_ATI_separate_stencil", extStart, extEnd);
9605
  if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT);
9606
#endif /* GL_ATI_separate_stencil */
9607
#ifdef GL_ATI_shader_texture_lod
9608
  CONST_CAST(GLEW_ATI_shader_texture_lod) = _glewSearchExtension("GL_ATI_shader_texture_lod", extStart, extEnd);
9609
#endif /* GL_ATI_shader_texture_lod */
9610
#ifdef GL_ATI_text_fragment_shader
9611
  CONST_CAST(GLEW_ATI_text_fragment_shader) = _glewSearchExtension("GL_ATI_text_fragment_shader", extStart, extEnd);
9612
#endif /* GL_ATI_text_fragment_shader */
9613
#ifdef GL_ATI_texture_compression_3dc
9614
  CONST_CAST(GLEW_ATI_texture_compression_3dc) = _glewSearchExtension("GL_ATI_texture_compression_3dc", extStart, extEnd);
9615
#endif /* GL_ATI_texture_compression_3dc */
9616
#ifdef GL_ATI_texture_env_combine3
9617
  CONST_CAST(GLEW_ATI_texture_env_combine3) = _glewSearchExtension("GL_ATI_texture_env_combine3", extStart, extEnd);
9618
#endif /* GL_ATI_texture_env_combine3 */
9619
#ifdef GL_ATI_texture_float
9620
  CONST_CAST(GLEW_ATI_texture_float) = _glewSearchExtension("GL_ATI_texture_float", extStart, extEnd);
9621
#endif /* GL_ATI_texture_float */
9622
#ifdef GL_ATI_texture_mirror_once
9623
  CONST_CAST(GLEW_ATI_texture_mirror_once) = _glewSearchExtension("GL_ATI_texture_mirror_once", extStart, extEnd);
9624
#endif /* GL_ATI_texture_mirror_once */
9625
#ifdef GL_ATI_vertex_array_object
9626
  CONST_CAST(GLEW_ATI_vertex_array_object) = _glewSearchExtension("GL_ATI_vertex_array_object", extStart, extEnd);
9627
  if (glewExperimental || GLEW_ATI_vertex_array_object) CONST_CAST(GLEW_ATI_vertex_array_object) = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
9628
#endif /* GL_ATI_vertex_array_object */
9629
#ifdef GL_ATI_vertex_attrib_array_object
9630
  CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = _glewSearchExtension("GL_ATI_vertex_attrib_array_object", extStart, extEnd);
9631
  if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
9632
#endif /* GL_ATI_vertex_attrib_array_object */
9633
#ifdef GL_ATI_vertex_streams
9634
  CONST_CAST(GLEW_ATI_vertex_streams) = _glewSearchExtension("GL_ATI_vertex_streams", extStart, extEnd);
9635
  if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT);
9636
#endif /* GL_ATI_vertex_streams */
9637
#ifdef GL_EXT_422_pixels
9638
  CONST_CAST(GLEW_EXT_422_pixels) = _glewSearchExtension("GL_EXT_422_pixels", extStart, extEnd);
9639
#endif /* GL_EXT_422_pixels */
9640
#ifdef GL_EXT_Cg_shader
9641
  CONST_CAST(GLEW_EXT_Cg_shader) = _glewSearchExtension("GL_EXT_Cg_shader", extStart, extEnd);
9642
#endif /* GL_EXT_Cg_shader */
9643
#ifdef GL_EXT_abgr
9644
  CONST_CAST(GLEW_EXT_abgr) = _glewSearchExtension("GL_EXT_abgr", extStart, extEnd);
9645
#endif /* GL_EXT_abgr */
9646
#ifdef GL_EXT_bgra
9647
  CONST_CAST(GLEW_EXT_bgra) = _glewSearchExtension("GL_EXT_bgra", extStart, extEnd);
9648
#endif /* GL_EXT_bgra */
9649
#ifdef GL_EXT_bindable_uniform
9650
  CONST_CAST(GLEW_EXT_bindable_uniform) = _glewSearchExtension("GL_EXT_bindable_uniform", extStart, extEnd);
9651
  if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT);
9652
#endif /* GL_EXT_bindable_uniform */
9653
#ifdef GL_EXT_blend_color
9654
  CONST_CAST(GLEW_EXT_blend_color) = _glewSearchExtension("GL_EXT_blend_color", extStart, extEnd);
9655
  if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT);
9656
#endif /* GL_EXT_blend_color */
9657
#ifdef GL_EXT_blend_equation_separate
9658
  CONST_CAST(GLEW_EXT_blend_equation_separate) = _glewSearchExtension("GL_EXT_blend_equation_separate", extStart, extEnd);
9659
  if (glewExperimental || GLEW_EXT_blend_equation_separate) CONST_CAST(GLEW_EXT_blend_equation_separate) = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT);
9660
#endif /* GL_EXT_blend_equation_separate */
9661
#ifdef GL_EXT_blend_func_separate
9662
  CONST_CAST(GLEW_EXT_blend_func_separate) = _glewSearchExtension("GL_EXT_blend_func_separate", extStart, extEnd);
9663
  if (glewExperimental || GLEW_EXT_blend_func_separate) CONST_CAST(GLEW_EXT_blend_func_separate) = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT);
9664
#endif /* GL_EXT_blend_func_separate */
9665
#ifdef GL_EXT_blend_logic_op
9666
  CONST_CAST(GLEW_EXT_blend_logic_op) = _glewSearchExtension("GL_EXT_blend_logic_op", extStart, extEnd);
9667
#endif /* GL_EXT_blend_logic_op */
9668
#ifdef GL_EXT_blend_minmax
9669
  CONST_CAST(GLEW_EXT_blend_minmax) = _glewSearchExtension("GL_EXT_blend_minmax", extStart, extEnd);
9670
  if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT);
9671
#endif /* GL_EXT_blend_minmax */
9672
#ifdef GL_EXT_blend_subtract
9673
  CONST_CAST(GLEW_EXT_blend_subtract) = _glewSearchExtension("GL_EXT_blend_subtract", extStart, extEnd);
9674
#endif /* GL_EXT_blend_subtract */
9675
#ifdef GL_EXT_clip_volume_hint
9676
  CONST_CAST(GLEW_EXT_clip_volume_hint) = _glewSearchExtension("GL_EXT_clip_volume_hint", extStart, extEnd);
9677
#endif /* GL_EXT_clip_volume_hint */
9678
#ifdef GL_EXT_cmyka
9679
  CONST_CAST(GLEW_EXT_cmyka) = _glewSearchExtension("GL_EXT_cmyka", extStart, extEnd);
9680
#endif /* GL_EXT_cmyka */
9681
#ifdef GL_EXT_color_subtable
9682
  CONST_CAST(GLEW_EXT_color_subtable) = _glewSearchExtension("GL_EXT_color_subtable", extStart, extEnd);
9683
  if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT);
9684
#endif /* GL_EXT_color_subtable */
9685
#ifdef GL_EXT_compiled_vertex_array
9686
  CONST_CAST(GLEW_EXT_compiled_vertex_array) = _glewSearchExtension("GL_EXT_compiled_vertex_array", extStart, extEnd);
9687
  if (glewExperimental || GLEW_EXT_compiled_vertex_array) CONST_CAST(GLEW_EXT_compiled_vertex_array) = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);
9688
#endif /* GL_EXT_compiled_vertex_array */
9689
#ifdef GL_EXT_convolution
9690
  CONST_CAST(GLEW_EXT_convolution) = _glewSearchExtension("GL_EXT_convolution", extStart, extEnd);
9691
  if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT);
9692
#endif /* GL_EXT_convolution */
9693
#ifdef GL_EXT_coordinate_frame
9694
  CONST_CAST(GLEW_EXT_coordinate_frame) = _glewSearchExtension("GL_EXT_coordinate_frame", extStart, extEnd);
9695
  if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT);
9696
#endif /* GL_EXT_coordinate_frame */
9697
#ifdef GL_EXT_copy_texture
9698
  CONST_CAST(GLEW_EXT_copy_texture) = _glewSearchExtension("GL_EXT_copy_texture", extStart, extEnd);
9699
  if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT);
9700
#endif /* GL_EXT_copy_texture */
9701
#ifdef GL_EXT_cull_vertex
9702
  CONST_CAST(GLEW_EXT_cull_vertex) = _glewSearchExtension("GL_EXT_cull_vertex", extStart, extEnd);
9703
  if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
9704
#endif /* GL_EXT_cull_vertex */
9705
#ifdef GL_EXT_debug_marker
9706
  CONST_CAST(GLEW_EXT_debug_marker) = _glewSearchExtension("GL_EXT_debug_marker", extStart, extEnd);
9707
  if (glewExperimental || GLEW_EXT_debug_marker) CONST_CAST(GLEW_EXT_debug_marker) = !_glewInit_GL_EXT_debug_marker(GLEW_CONTEXT_ARG_VAR_INIT);
9708
#endif /* GL_EXT_debug_marker */
9709
#ifdef GL_EXT_depth_bounds_test
9710
  CONST_CAST(GLEW_EXT_depth_bounds_test) = _glewSearchExtension("GL_EXT_depth_bounds_test", extStart, extEnd);
9711
  if (glewExperimental || GLEW_EXT_depth_bounds_test) CONST_CAST(GLEW_EXT_depth_bounds_test) = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT);
9712
#endif /* GL_EXT_depth_bounds_test */
9713
#ifdef GL_EXT_direct_state_access
9714
  CONST_CAST(GLEW_EXT_direct_state_access) = _glewSearchExtension("GL_EXT_direct_state_access", extStart, extEnd);
9715
  if (glewExperimental || GLEW_EXT_direct_state_access) CONST_CAST(GLEW_EXT_direct_state_access) = !_glewInit_GL_EXT_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT);
9716
#endif /* GL_EXT_direct_state_access */
9717
#ifdef GL_EXT_draw_buffers2
9718
  CONST_CAST(GLEW_EXT_draw_buffers2) = _glewSearchExtension("GL_EXT_draw_buffers2", extStart, extEnd);
9719
  if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT);
9720
#endif /* GL_EXT_draw_buffers2 */
9721
#ifdef GL_EXT_draw_instanced
9722
  CONST_CAST(GLEW_EXT_draw_instanced) = _glewSearchExtension("GL_EXT_draw_instanced", extStart, extEnd);
9723
  if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);
9724
#endif /* GL_EXT_draw_instanced */
9725
#ifdef GL_EXT_draw_range_elements
9726
  CONST_CAST(GLEW_EXT_draw_range_elements) = _glewSearchExtension("GL_EXT_draw_range_elements", extStart, extEnd);
9727
  if (glewExperimental || GLEW_EXT_draw_range_elements) CONST_CAST(GLEW_EXT_draw_range_elements) = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT);
9728
#endif /* GL_EXT_draw_range_elements */
9729
#ifdef GL_EXT_fog_coord
9730
  CONST_CAST(GLEW_EXT_fog_coord) = _glewSearchExtension("GL_EXT_fog_coord", extStart, extEnd);
9731
  if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT);
9732
#endif /* GL_EXT_fog_coord */
9733
#ifdef GL_EXT_fragment_lighting
9734
  CONST_CAST(GLEW_EXT_fragment_lighting) = _glewSearchExtension("GL_EXT_fragment_lighting", extStart, extEnd);
9735
  if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT);
9736
#endif /* GL_EXT_fragment_lighting */
9737
#ifdef GL_EXT_framebuffer_blit
9738
  CONST_CAST(GLEW_EXT_framebuffer_blit) = _glewSearchExtension("GL_EXT_framebuffer_blit", extStart, extEnd);
9739
  if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT);
9740
#endif /* GL_EXT_framebuffer_blit */
9741
#ifdef GL_EXT_framebuffer_multisample
9742
  CONST_CAST(GLEW_EXT_framebuffer_multisample) = _glewSearchExtension("GL_EXT_framebuffer_multisample", extStart, extEnd);
9743
  if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9744
#endif /* GL_EXT_framebuffer_multisample */
9745
#ifdef GL_EXT_framebuffer_multisample_blit_scaled
9746
  CONST_CAST(GLEW_EXT_framebuffer_multisample_blit_scaled) = _glewSearchExtension("GL_EXT_framebuffer_multisample_blit_scaled", extStart, extEnd);
9747
#endif /* GL_EXT_framebuffer_multisample_blit_scaled */
9748
#ifdef GL_EXT_framebuffer_object
9749
  CONST_CAST(GLEW_EXT_framebuffer_object) = _glewSearchExtension("GL_EXT_framebuffer_object", extStart, extEnd);
9750
  if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9751
#endif /* GL_EXT_framebuffer_object */
9752
#ifdef GL_EXT_framebuffer_sRGB
9753
  CONST_CAST(GLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GL_EXT_framebuffer_sRGB", extStart, extEnd);
9754
#endif /* GL_EXT_framebuffer_sRGB */
9755
#ifdef GL_EXT_geometry_shader4
9756
  CONST_CAST(GLEW_EXT_geometry_shader4) = _glewSearchExtension("GL_EXT_geometry_shader4", extStart, extEnd);
9757
  if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
9758
#endif /* GL_EXT_geometry_shader4 */
9759
#ifdef GL_EXT_gpu_program_parameters
9760
  CONST_CAST(GLEW_EXT_gpu_program_parameters) = _glewSearchExtension("GL_EXT_gpu_program_parameters", extStart, extEnd);
9761
  if (glewExperimental || GLEW_EXT_gpu_program_parameters) CONST_CAST(GLEW_EXT_gpu_program_parameters) = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
9762
#endif /* GL_EXT_gpu_program_parameters */
9763
#ifdef GL_EXT_gpu_shader4
9764
  CONST_CAST(GLEW_EXT_gpu_shader4) = _glewSearchExtension("GL_EXT_gpu_shader4", extStart, extEnd);
9765
  if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
9766
#endif /* GL_EXT_gpu_shader4 */
9767
#ifdef GL_EXT_histogram
9768
  CONST_CAST(GLEW_EXT_histogram) = _glewSearchExtension("GL_EXT_histogram", extStart, extEnd);
9769
  if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT);
9770
#endif /* GL_EXT_histogram */
9771
#ifdef GL_EXT_index_array_formats
9772
  CONST_CAST(GLEW_EXT_index_array_formats) = _glewSearchExtension("GL_EXT_index_array_formats", extStart, extEnd);
9773
#endif /* GL_EXT_index_array_formats */
9774
#ifdef GL_EXT_index_func
9775
  CONST_CAST(GLEW_EXT_index_func) = _glewSearchExtension("GL_EXT_index_func", extStart, extEnd);
9776
  if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT);
9777
#endif /* GL_EXT_index_func */
9778
#ifdef GL_EXT_index_material
9779
  CONST_CAST(GLEW_EXT_index_material) = _glewSearchExtension("GL_EXT_index_material", extStart, extEnd);
9780
  if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT);
9781
#endif /* GL_EXT_index_material */
9782
#ifdef GL_EXT_index_texture
9783
  CONST_CAST(GLEW_EXT_index_texture) = _glewSearchExtension("GL_EXT_index_texture", extStart, extEnd);
9784
#endif /* GL_EXT_index_texture */
9785
#ifdef GL_EXT_light_texture
9786
  CONST_CAST(GLEW_EXT_light_texture) = _glewSearchExtension("GL_EXT_light_texture", extStart, extEnd);
9787
  if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT);
9788
#endif /* GL_EXT_light_texture */
9789
#ifdef GL_EXT_misc_attribute
9790
  CONST_CAST(GLEW_EXT_misc_attribute) = _glewSearchExtension("GL_EXT_misc_attribute", extStart, extEnd);
9791
#endif /* GL_EXT_misc_attribute */
9792
#ifdef GL_EXT_multi_draw_arrays
9793
  CONST_CAST(GLEW_EXT_multi_draw_arrays) = _glewSearchExtension("GL_EXT_multi_draw_arrays", extStart, extEnd);
9794
  if (glewExperimental || GLEW_EXT_multi_draw_arrays) CONST_CAST(GLEW_EXT_multi_draw_arrays) = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
9795
#endif /* GL_EXT_multi_draw_arrays */
9796
#ifdef GL_EXT_multisample
9797
  CONST_CAST(GLEW_EXT_multisample) = _glewSearchExtension("GL_EXT_multisample", extStart, extEnd);
9798
  if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9799
#endif /* GL_EXT_multisample */
9800
#ifdef GL_EXT_packed_depth_stencil
9801
  CONST_CAST(GLEW_EXT_packed_depth_stencil) = _glewSearchExtension("GL_EXT_packed_depth_stencil", extStart, extEnd);
9802
#endif /* GL_EXT_packed_depth_stencil */
9803
#ifdef GL_EXT_packed_float
9804
  CONST_CAST(GLEW_EXT_packed_float) = _glewSearchExtension("GL_EXT_packed_float", extStart, extEnd);
9805
#endif /* GL_EXT_packed_float */
9806
#ifdef GL_EXT_packed_pixels
9807
  CONST_CAST(GLEW_EXT_packed_pixels) = _glewSearchExtension("GL_EXT_packed_pixels", extStart, extEnd);
9808
#endif /* GL_EXT_packed_pixels */
9809
#ifdef GL_EXT_paletted_texture
9810
  CONST_CAST(GLEW_EXT_paletted_texture) = _glewSearchExtension("GL_EXT_paletted_texture", extStart, extEnd);
9811
  if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT);
9812
#endif /* GL_EXT_paletted_texture */
9813
#ifdef GL_EXT_pixel_buffer_object
9814
  CONST_CAST(GLEW_EXT_pixel_buffer_object) = _glewSearchExtension("GL_EXT_pixel_buffer_object", extStart, extEnd);
9815
#endif /* GL_EXT_pixel_buffer_object */
9816
#ifdef GL_EXT_pixel_transform
9817
  CONST_CAST(GLEW_EXT_pixel_transform) = _glewSearchExtension("GL_EXT_pixel_transform", extStart, extEnd);
9818
  if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT);
9819
#endif /* GL_EXT_pixel_transform */
9820
#ifdef GL_EXT_pixel_transform_color_table
9821
  CONST_CAST(GLEW_EXT_pixel_transform_color_table) = _glewSearchExtension("GL_EXT_pixel_transform_color_table", extStart, extEnd);
9822
#endif /* GL_EXT_pixel_transform_color_table */
9823
#ifdef GL_EXT_point_parameters
9824
  CONST_CAST(GLEW_EXT_point_parameters) = _glewSearchExtension("GL_EXT_point_parameters", extStart, extEnd);
9825
  if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
9826
#endif /* GL_EXT_point_parameters */
9827
#ifdef GL_EXT_polygon_offset
9828
  CONST_CAST(GLEW_EXT_polygon_offset) = _glewSearchExtension("GL_EXT_polygon_offset", extStart, extEnd);
9829
  if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);
9830
#endif /* GL_EXT_polygon_offset */
9831
#ifdef GL_EXT_provoking_vertex
9832
  CONST_CAST(GLEW_EXT_provoking_vertex) = _glewSearchExtension("GL_EXT_provoking_vertex", extStart, extEnd);
9833
  if (glewExperimental || GLEW_EXT_provoking_vertex) CONST_CAST(GLEW_EXT_provoking_vertex) = !_glewInit_GL_EXT_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
9834
#endif /* GL_EXT_provoking_vertex */
9835
#ifdef GL_EXT_rescale_normal
9836
  CONST_CAST(GLEW_EXT_rescale_normal) = _glewSearchExtension("GL_EXT_rescale_normal", extStart, extEnd);
9837
#endif /* GL_EXT_rescale_normal */
9838
#ifdef GL_EXT_scene_marker
9839
  CONST_CAST(GLEW_EXT_scene_marker) = _glewSearchExtension("GL_EXT_scene_marker", extStart, extEnd);
9840
  if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT);
9841
#endif /* GL_EXT_scene_marker */
9842
#ifdef GL_EXT_secondary_color
9843
  CONST_CAST(GLEW_EXT_secondary_color) = _glewSearchExtension("GL_EXT_secondary_color", extStart, extEnd);
9844
  if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);
9845
#endif /* GL_EXT_secondary_color */
9846
#ifdef GL_EXT_separate_shader_objects
9847
  CONST_CAST(GLEW_EXT_separate_shader_objects) = _glewSearchExtension("GL_EXT_separate_shader_objects", extStart, extEnd);
9848
  if (glewExperimental || GLEW_EXT_separate_shader_objects) CONST_CAST(GLEW_EXT_separate_shader_objects) = !_glewInit_GL_EXT_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
9849
#endif /* GL_EXT_separate_shader_objects */
9850
#ifdef GL_EXT_separate_specular_color
9851
  CONST_CAST(GLEW_EXT_separate_specular_color) = _glewSearchExtension("GL_EXT_separate_specular_color", extStart, extEnd);
9852
#endif /* GL_EXT_separate_specular_color */
9853
#ifdef GL_EXT_shader_image_load_store
9854
  CONST_CAST(GLEW_EXT_shader_image_load_store) = _glewSearchExtension("GL_EXT_shader_image_load_store", extStart, extEnd);
9855
  if (glewExperimental || GLEW_EXT_shader_image_load_store) CONST_CAST(GLEW_EXT_shader_image_load_store) = !_glewInit_GL_EXT_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT);
9856
#endif /* GL_EXT_shader_image_load_store */
9857
#ifdef GL_EXT_shadow_funcs
9858
  CONST_CAST(GLEW_EXT_shadow_funcs) = _glewSearchExtension("GL_EXT_shadow_funcs", extStart, extEnd);
9859
#endif /* GL_EXT_shadow_funcs */
9860
#ifdef GL_EXT_shared_texture_palette
9861
  CONST_CAST(GLEW_EXT_shared_texture_palette) = _glewSearchExtension("GL_EXT_shared_texture_palette", extStart, extEnd);
9862
#endif /* GL_EXT_shared_texture_palette */
9863
#ifdef GL_EXT_stencil_clear_tag
9864
  CONST_CAST(GLEW_EXT_stencil_clear_tag) = _glewSearchExtension("GL_EXT_stencil_clear_tag", extStart, extEnd);
9865
#endif /* GL_EXT_stencil_clear_tag */
9866
#ifdef GL_EXT_stencil_two_side
9867
  CONST_CAST(GLEW_EXT_stencil_two_side) = _glewSearchExtension("GL_EXT_stencil_two_side", extStart, extEnd);
9868
  if (glewExperimental || GLEW_EXT_stencil_two_side) CONST_CAST(GLEW_EXT_stencil_two_side) = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT);
9869
#endif /* GL_EXT_stencil_two_side */
9870
#ifdef GL_EXT_stencil_wrap
9871
  CONST_CAST(GLEW_EXT_stencil_wrap) = _glewSearchExtension("GL_EXT_stencil_wrap", extStart, extEnd);
9872
#endif /* GL_EXT_stencil_wrap */
9873
#ifdef GL_EXT_subtexture
9874
  CONST_CAST(GLEW_EXT_subtexture) = _glewSearchExtension("GL_EXT_subtexture", extStart, extEnd);
9875
  if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT);
9876
#endif /* GL_EXT_subtexture */
9877
#ifdef GL_EXT_texture
9878
  CONST_CAST(GLEW_EXT_texture) = _glewSearchExtension("GL_EXT_texture", extStart, extEnd);
9879
#endif /* GL_EXT_texture */
9880
#ifdef GL_EXT_texture3D
9881
  CONST_CAST(GLEW_EXT_texture3D) = _glewSearchExtension("GL_EXT_texture3D", extStart, extEnd);
9882
  if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT);
9883
#endif /* GL_EXT_texture3D */
9884
#ifdef GL_EXT_texture_array
9885
  CONST_CAST(GLEW_EXT_texture_array) = _glewSearchExtension("GL_EXT_texture_array", extStart, extEnd);
9886
  if (glewExperimental || GLEW_EXT_texture_array) CONST_CAST(GLEW_EXT_texture_array) = !_glewInit_GL_EXT_texture_array(GLEW_CONTEXT_ARG_VAR_INIT);
9887
#endif /* GL_EXT_texture_array */
9888
#ifdef GL_EXT_texture_buffer_object
9889
  CONST_CAST(GLEW_EXT_texture_buffer_object) = _glewSearchExtension("GL_EXT_texture_buffer_object", extStart, extEnd);
9890
  if (glewExperimental || GLEW_EXT_texture_buffer_object) CONST_CAST(GLEW_EXT_texture_buffer_object) = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9891
#endif /* GL_EXT_texture_buffer_object */
9892
#ifdef GL_EXT_texture_compression_dxt1
9893
  CONST_CAST(GLEW_EXT_texture_compression_dxt1) = _glewSearchExtension("GL_EXT_texture_compression_dxt1", extStart, extEnd);
9894
#endif /* GL_EXT_texture_compression_dxt1 */
9895
#ifdef GL_EXT_texture_compression_latc
9896
  CONST_CAST(GLEW_EXT_texture_compression_latc) = _glewSearchExtension("GL_EXT_texture_compression_latc", extStart, extEnd);
9897
#endif /* GL_EXT_texture_compression_latc */
9898
#ifdef GL_EXT_texture_compression_rgtc
9899
  CONST_CAST(GLEW_EXT_texture_compression_rgtc) = _glewSearchExtension("GL_EXT_texture_compression_rgtc", extStart, extEnd);
9900
#endif /* GL_EXT_texture_compression_rgtc */
9901
#ifdef GL_EXT_texture_compression_s3tc
9902
  CONST_CAST(GLEW_EXT_texture_compression_s3tc) = _glewSearchExtension("GL_EXT_texture_compression_s3tc", extStart, extEnd);
9903
#endif /* GL_EXT_texture_compression_s3tc */
9904
#ifdef GL_EXT_texture_cube_map
9905
  CONST_CAST(GLEW_EXT_texture_cube_map) = _glewSearchExtension("GL_EXT_texture_cube_map", extStart, extEnd);
9906
#endif /* GL_EXT_texture_cube_map */
9907
#ifdef GL_EXT_texture_edge_clamp
9908
  CONST_CAST(GLEW_EXT_texture_edge_clamp) = _glewSearchExtension("GL_EXT_texture_edge_clamp", extStart, extEnd);
9909
#endif /* GL_EXT_texture_edge_clamp */
9910
#ifdef GL_EXT_texture_env
9911
  CONST_CAST(GLEW_EXT_texture_env) = _glewSearchExtension("GL_EXT_texture_env", extStart, extEnd);
9912
#endif /* GL_EXT_texture_env */
9913
#ifdef GL_EXT_texture_env_add
9914
  CONST_CAST(GLEW_EXT_texture_env_add) = _glewSearchExtension("GL_EXT_texture_env_add", extStart, extEnd);
9915
#endif /* GL_EXT_texture_env_add */
9916
#ifdef GL_EXT_texture_env_combine
9917
  CONST_CAST(GLEW_EXT_texture_env_combine) = _glewSearchExtension("GL_EXT_texture_env_combine", extStart, extEnd);
9918
#endif /* GL_EXT_texture_env_combine */
9919
#ifdef GL_EXT_texture_env_dot3
9920
  CONST_CAST(GLEW_EXT_texture_env_dot3) = _glewSearchExtension("GL_EXT_texture_env_dot3", extStart, extEnd);
9921
#endif /* GL_EXT_texture_env_dot3 */
9922
#ifdef GL_EXT_texture_filter_anisotropic
9923
  CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = _glewSearchExtension("GL_EXT_texture_filter_anisotropic", extStart, extEnd);
9924
#endif /* GL_EXT_texture_filter_anisotropic */
9925
#ifdef GL_EXT_texture_integer
9926
  CONST_CAST(GLEW_EXT_texture_integer) = _glewSearchExtension("GL_EXT_texture_integer", extStart, extEnd);
9927
  if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT);
9928
#endif /* GL_EXT_texture_integer */
9929
#ifdef GL_EXT_texture_lod_bias
9930
  CONST_CAST(GLEW_EXT_texture_lod_bias) = _glewSearchExtension("GL_EXT_texture_lod_bias", extStart, extEnd);
9931
#endif /* GL_EXT_texture_lod_bias */
9932
#ifdef GL_EXT_texture_mirror_clamp
9933
  CONST_CAST(GLEW_EXT_texture_mirror_clamp) = _glewSearchExtension("GL_EXT_texture_mirror_clamp", extStart, extEnd);
9934
#endif /* GL_EXT_texture_mirror_clamp */
9935
#ifdef GL_EXT_texture_object
9936
  CONST_CAST(GLEW_EXT_texture_object) = _glewSearchExtension("GL_EXT_texture_object", extStart, extEnd);
9937
  if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT);
9938
#endif /* GL_EXT_texture_object */
9939
#ifdef GL_EXT_texture_perturb_normal
9940
  CONST_CAST(GLEW_EXT_texture_perturb_normal) = _glewSearchExtension("GL_EXT_texture_perturb_normal", extStart, extEnd);
9941
  if (glewExperimental || GLEW_EXT_texture_perturb_normal) CONST_CAST(GLEW_EXT_texture_perturb_normal) = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT);
9942
#endif /* GL_EXT_texture_perturb_normal */
9943
#ifdef GL_EXT_texture_rectangle
9944
  CONST_CAST(GLEW_EXT_texture_rectangle) = _glewSearchExtension("GL_EXT_texture_rectangle", extStart, extEnd);
9945
#endif /* GL_EXT_texture_rectangle */
9946
#ifdef GL_EXT_texture_sRGB
9947
  CONST_CAST(GLEW_EXT_texture_sRGB) = _glewSearchExtension("GL_EXT_texture_sRGB", extStart, extEnd);
9948
#endif /* GL_EXT_texture_sRGB */
9949
#ifdef GL_EXT_texture_sRGB_decode
9950
  CONST_CAST(GLEW_EXT_texture_sRGB_decode) = _glewSearchExtension("GL_EXT_texture_sRGB_decode", extStart, extEnd);
9951
#endif /* GL_EXT_texture_sRGB_decode */
9952
#ifdef GL_EXT_texture_shared_exponent
9953
  CONST_CAST(GLEW_EXT_texture_shared_exponent) = _glewSearchExtension("GL_EXT_texture_shared_exponent", extStart, extEnd);
9954
#endif /* GL_EXT_texture_shared_exponent */
9955
#ifdef GL_EXT_texture_snorm
9956
  CONST_CAST(GLEW_EXT_texture_snorm) = _glewSearchExtension("GL_EXT_texture_snorm", extStart, extEnd);
9957
#endif /* GL_EXT_texture_snorm */
9958
#ifdef GL_EXT_texture_swizzle
9959
  CONST_CAST(GLEW_EXT_texture_swizzle) = _glewSearchExtension("GL_EXT_texture_swizzle", extStart, extEnd);
9960
#endif /* GL_EXT_texture_swizzle */
9961
#ifdef GL_EXT_timer_query
9962
  CONST_CAST(GLEW_EXT_timer_query) = _glewSearchExtension("GL_EXT_timer_query", extStart, extEnd);
9963
  if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
9964
#endif /* GL_EXT_timer_query */
9965
#ifdef GL_EXT_transform_feedback
9966
  CONST_CAST(GLEW_EXT_transform_feedback) = _glewSearchExtension("GL_EXT_transform_feedback", extStart, extEnd);
9967
  if (glewExperimental || GLEW_EXT_transform_feedback) CONST_CAST(GLEW_EXT_transform_feedback) = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
9968
#endif /* GL_EXT_transform_feedback */
9969
#ifdef GL_EXT_vertex_array
9970
  CONST_CAST(GLEW_EXT_vertex_array) = _glewSearchExtension("GL_EXT_vertex_array", extStart, extEnd);
9971
  if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);
9972
#endif /* GL_EXT_vertex_array */
9973
#ifdef GL_EXT_vertex_array_bgra
9974
  CONST_CAST(GLEW_EXT_vertex_array_bgra) = _glewSearchExtension("GL_EXT_vertex_array_bgra", extStart, extEnd);
9975
#endif /* GL_EXT_vertex_array_bgra */
9976
#ifdef GL_EXT_vertex_attrib_64bit
9977
  CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = _glewSearchExtension("GL_EXT_vertex_attrib_64bit", extStart, extEnd);
9978
  if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = !_glewInit_GL_EXT_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
9979
#endif /* GL_EXT_vertex_attrib_64bit */
9980
#ifdef GL_EXT_vertex_shader
9981
  CONST_CAST(GLEW_EXT_vertex_shader) = _glewSearchExtension("GL_EXT_vertex_shader", extStart, extEnd);
9982
  if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
9983
#endif /* GL_EXT_vertex_shader */
9984
#ifdef GL_EXT_vertex_weighting
9985
  CONST_CAST(GLEW_EXT_vertex_weighting) = _glewSearchExtension("GL_EXT_vertex_weighting", extStart, extEnd);
9986
  if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT);
9987
#endif /* GL_EXT_vertex_weighting */
9988
#ifdef GL_EXT_x11_sync_object
9989
  CONST_CAST(GLEW_EXT_x11_sync_object) = _glewSearchExtension("GL_EXT_x11_sync_object", extStart, extEnd);
9990
  if (glewExperimental || GLEW_EXT_x11_sync_object) CONST_CAST(GLEW_EXT_x11_sync_object) = !_glewInit_GL_EXT_x11_sync_object(GLEW_CONTEXT_ARG_VAR_INIT);
9991
#endif /* GL_EXT_x11_sync_object */
9992
#ifdef GL_GREMEDY_frame_terminator
9993
  CONST_CAST(GLEW_GREMEDY_frame_terminator) = _glewSearchExtension("GL_GREMEDY_frame_terminator", extStart, extEnd);
9994
  if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT);
9995
#endif /* GL_GREMEDY_frame_terminator */
9996
#ifdef GL_GREMEDY_string_marker
9997
  CONST_CAST(GLEW_GREMEDY_string_marker) = _glewSearchExtension("GL_GREMEDY_string_marker", extStart, extEnd);
9998
  if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT);
9999
#endif /* GL_GREMEDY_string_marker */
10000
#ifdef GL_HP_convolution_border_modes
10001
  CONST_CAST(GLEW_HP_convolution_border_modes) = _glewSearchExtension("GL_HP_convolution_border_modes", extStart, extEnd);
10002
#endif /* GL_HP_convolution_border_modes */
10003
#ifdef GL_HP_image_transform
10004
  CONST_CAST(GLEW_HP_image_transform) = _glewSearchExtension("GL_HP_image_transform", extStart, extEnd);
10005
  if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT);
10006
#endif /* GL_HP_image_transform */
10007
#ifdef GL_HP_occlusion_test
10008
  CONST_CAST(GLEW_HP_occlusion_test) = _glewSearchExtension("GL_HP_occlusion_test", extStart, extEnd);
10009
#endif /* GL_HP_occlusion_test */
10010
#ifdef GL_HP_texture_lighting
10011
  CONST_CAST(GLEW_HP_texture_lighting) = _glewSearchExtension("GL_HP_texture_lighting", extStart, extEnd);
10012
#endif /* GL_HP_texture_lighting */
10013
#ifdef GL_IBM_cull_vertex
10014
  CONST_CAST(GLEW_IBM_cull_vertex) = _glewSearchExtension("GL_IBM_cull_vertex", extStart, extEnd);
10015
#endif /* GL_IBM_cull_vertex */
10016
#ifdef GL_IBM_multimode_draw_arrays
10017
  CONST_CAST(GLEW_IBM_multimode_draw_arrays) = _glewSearchExtension("GL_IBM_multimode_draw_arrays", extStart, extEnd);
10018
  if (glewExperimental || GLEW_IBM_multimode_draw_arrays) CONST_CAST(GLEW_IBM_multimode_draw_arrays) = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
10019
#endif /* GL_IBM_multimode_draw_arrays */
10020
#ifdef GL_IBM_rasterpos_clip
10021
  CONST_CAST(GLEW_IBM_rasterpos_clip) = _glewSearchExtension("GL_IBM_rasterpos_clip", extStart, extEnd);
10022
#endif /* GL_IBM_rasterpos_clip */
10023
#ifdef GL_IBM_static_data
10024
  CONST_CAST(GLEW_IBM_static_data) = _glewSearchExtension("GL_IBM_static_data", extStart, extEnd);
10025
#endif /* GL_IBM_static_data */
10026
#ifdef GL_IBM_texture_mirrored_repeat
10027
  CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = _glewSearchExtension("GL_IBM_texture_mirrored_repeat", extStart, extEnd);
10028
#endif /* GL_IBM_texture_mirrored_repeat */
10029
#ifdef GL_IBM_vertex_array_lists
10030
  CONST_CAST(GLEW_IBM_vertex_array_lists) = _glewSearchExtension("GL_IBM_vertex_array_lists", extStart, extEnd);
10031
  if (glewExperimental || GLEW_IBM_vertex_array_lists) CONST_CAST(GLEW_IBM_vertex_array_lists) = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT);
10032
#endif /* GL_IBM_vertex_array_lists */
10033
#ifdef GL_INGR_color_clamp
10034
  CONST_CAST(GLEW_INGR_color_clamp) = _glewSearchExtension("GL_INGR_color_clamp", extStart, extEnd);
10035
#endif /* GL_INGR_color_clamp */
10036
#ifdef GL_INGR_interlace_read
10037
  CONST_CAST(GLEW_INGR_interlace_read) = _glewSearchExtension("GL_INGR_interlace_read", extStart, extEnd);
10038
#endif /* GL_INGR_interlace_read */
10039
#ifdef GL_INTEL_parallel_arrays
10040
  CONST_CAST(GLEW_INTEL_parallel_arrays) = _glewSearchExtension("GL_INTEL_parallel_arrays", extStart, extEnd);
10041
  if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
10042
#endif /* GL_INTEL_parallel_arrays */
10043
#ifdef GL_INTEL_texture_scissor
10044
  CONST_CAST(GLEW_INTEL_texture_scissor) = _glewSearchExtension("GL_INTEL_texture_scissor", extStart, extEnd);
10045
  if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT);
10046
#endif /* GL_INTEL_texture_scissor */
10047
#ifdef GL_KHR_debug
10048
  CONST_CAST(GLEW_KHR_debug) = _glewSearchExtension("GL_KHR_debug", extStart, extEnd);
10049
  if (glewExperimental || GLEW_KHR_debug) CONST_CAST(GLEW_KHR_debug) = !_glewInit_GL_KHR_debug(GLEW_CONTEXT_ARG_VAR_INIT);
10050
#endif /* GL_KHR_debug */
10051
#ifdef GL_KHR_texture_compression_astc_ldr
10052
  CONST_CAST(GLEW_KHR_texture_compression_astc_ldr) = _glewSearchExtension("GL_KHR_texture_compression_astc_ldr", extStart, extEnd);
10053
#endif /* GL_KHR_texture_compression_astc_ldr */
10054
#ifdef GL_KTX_buffer_region
10055
  CONST_CAST(GLEW_KTX_buffer_region) = _glewSearchExtension("GL_KTX_buffer_region", extStart, extEnd);
10056
  if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
10057
#endif /* GL_KTX_buffer_region */
10058
#ifdef GL_MESAX_texture_stack
10059
  CONST_CAST(GLEW_MESAX_texture_stack) = _glewSearchExtension("GL_MESAX_texture_stack", extStart, extEnd);
10060
#endif /* GL_MESAX_texture_stack */
10061
#ifdef GL_MESA_pack_invert
10062
  CONST_CAST(GLEW_MESA_pack_invert) = _glewSearchExtension("GL_MESA_pack_invert", extStart, extEnd);
10063
#endif /* GL_MESA_pack_invert */
10064
#ifdef GL_MESA_resize_buffers
10065
  CONST_CAST(GLEW_MESA_resize_buffers) = _glewSearchExtension("GL_MESA_resize_buffers", extStart, extEnd);
10066
  if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
10067
#endif /* GL_MESA_resize_buffers */
10068
#ifdef GL_MESA_window_pos
10069
  CONST_CAST(GLEW_MESA_window_pos) = _glewSearchExtension("GL_MESA_window_pos", extStart, extEnd);
10070
  if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
10071
#endif /* GL_MESA_window_pos */
10072
#ifdef GL_MESA_ycbcr_texture
10073
  CONST_CAST(GLEW_MESA_ycbcr_texture) = _glewSearchExtension("GL_MESA_ycbcr_texture", extStart, extEnd);
10074
#endif /* GL_MESA_ycbcr_texture */
10075
#ifdef GL_NVX_gpu_memory_info
10076
  CONST_CAST(GLEW_NVX_gpu_memory_info) = _glewSearchExtension("GL_NVX_gpu_memory_info", extStart, extEnd);
10077
#endif /* GL_NVX_gpu_memory_info */
10078
#ifdef GL_NV_bindless_texture
10079
  CONST_CAST(GLEW_NV_bindless_texture) = _glewSearchExtension("GL_NV_bindless_texture", extStart, extEnd);
10080
  if (glewExperimental || GLEW_NV_bindless_texture) CONST_CAST(GLEW_NV_bindless_texture) = !_glewInit_GL_NV_bindless_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10081
#endif /* GL_NV_bindless_texture */
10082
#ifdef GL_NV_blend_square
10083
  CONST_CAST(GLEW_NV_blend_square) = _glewSearchExtension("GL_NV_blend_square", extStart, extEnd);
10084
#endif /* GL_NV_blend_square */
10085
#ifdef GL_NV_conditional_render
10086
  CONST_CAST(GLEW_NV_conditional_render) = _glewSearchExtension("GL_NV_conditional_render", extStart, extEnd);
10087
  if (glewExperimental || GLEW_NV_conditional_render) CONST_CAST(GLEW_NV_conditional_render) = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT);
10088
#endif /* GL_NV_conditional_render */
10089
#ifdef GL_NV_copy_depth_to_color
10090
  CONST_CAST(GLEW_NV_copy_depth_to_color) = _glewSearchExtension("GL_NV_copy_depth_to_color", extStart, extEnd);
10091
#endif /* GL_NV_copy_depth_to_color */
10092
#ifdef GL_NV_copy_image
10093
  CONST_CAST(GLEW_NV_copy_image) = _glewSearchExtension("GL_NV_copy_image", extStart, extEnd);
10094
  if (glewExperimental || GLEW_NV_copy_image) CONST_CAST(GLEW_NV_copy_image) = !_glewInit_GL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
10095
#endif /* GL_NV_copy_image */
10096
#ifdef GL_NV_depth_buffer_float
10097
  CONST_CAST(GLEW_NV_depth_buffer_float) = _glewSearchExtension("GL_NV_depth_buffer_float", extStart, extEnd);
10098
  if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);
10099
#endif /* GL_NV_depth_buffer_float */
10100
#ifdef GL_NV_depth_clamp
10101
  CONST_CAST(GLEW_NV_depth_clamp) = _glewSearchExtension("GL_NV_depth_clamp", extStart, extEnd);
10102
#endif /* GL_NV_depth_clamp */
10103
#ifdef GL_NV_depth_range_unclamped
10104
  CONST_CAST(GLEW_NV_depth_range_unclamped) = _glewSearchExtension("GL_NV_depth_range_unclamped", extStart, extEnd);
10105
#endif /* GL_NV_depth_range_unclamped */
10106
#ifdef GL_NV_evaluators
10107
  CONST_CAST(GLEW_NV_evaluators) = _glewSearchExtension("GL_NV_evaluators", extStart, extEnd);
10108
  if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);
10109
#endif /* GL_NV_evaluators */
10110
#ifdef GL_NV_explicit_multisample
10111
  CONST_CAST(GLEW_NV_explicit_multisample) = _glewSearchExtension("GL_NV_explicit_multisample", extStart, extEnd);
10112
  if (glewExperimental || GLEW_NV_explicit_multisample) CONST_CAST(GLEW_NV_explicit_multisample) = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10113
#endif /* GL_NV_explicit_multisample */
10114
#ifdef GL_NV_fence
10115
  CONST_CAST(GLEW_NV_fence) = _glewSearchExtension("GL_NV_fence", extStart, extEnd);
10116
  if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT);
10117
#endif /* GL_NV_fence */
10118
#ifdef GL_NV_float_buffer
10119
  CONST_CAST(GLEW_NV_float_buffer) = _glewSearchExtension("GL_NV_float_buffer", extStart, extEnd);
10120
#endif /* GL_NV_float_buffer */
10121
#ifdef GL_NV_fog_distance
10122
  CONST_CAST(GLEW_NV_fog_distance) = _glewSearchExtension("GL_NV_fog_distance", extStart, extEnd);
10123
#endif /* GL_NV_fog_distance */
10124
#ifdef GL_NV_fragment_program
10125
  CONST_CAST(GLEW_NV_fragment_program) = _glewSearchExtension("GL_NV_fragment_program", extStart, extEnd);
10126
  if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);
10127
#endif /* GL_NV_fragment_program */
10128
#ifdef GL_NV_fragment_program2
10129
  CONST_CAST(GLEW_NV_fragment_program2) = _glewSearchExtension("GL_NV_fragment_program2", extStart, extEnd);
10130
#endif /* GL_NV_fragment_program2 */
10131
#ifdef GL_NV_fragment_program4
10132
  CONST_CAST(GLEW_NV_fragment_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10133
#endif /* GL_NV_fragment_program4 */
10134
#ifdef GL_NV_fragment_program_option
10135
  CONST_CAST(GLEW_NV_fragment_program_option) = _glewSearchExtension("GL_NV_fragment_program_option", extStart, extEnd);
10136
#endif /* GL_NV_fragment_program_option */
10137
#ifdef GL_NV_framebuffer_multisample_coverage
10138
  CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = _glewSearchExtension("GL_NV_framebuffer_multisample_coverage", extStart, extEnd);
10139
  if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT);
10140
#endif /* GL_NV_framebuffer_multisample_coverage */
10141
#ifdef GL_NV_geometry_program4
10142
  CONST_CAST(GLEW_NV_geometry_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10143
  if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT);
10144
#endif /* GL_NV_geometry_program4 */
10145
#ifdef GL_NV_geometry_shader4
10146
  CONST_CAST(GLEW_NV_geometry_shader4) = _glewSearchExtension("GL_NV_geometry_shader4", extStart, extEnd);
10147
#endif /* GL_NV_geometry_shader4 */
10148
#ifdef GL_NV_gpu_program4
10149
  CONST_CAST(GLEW_NV_gpu_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10150
  if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT);
10151
#endif /* GL_NV_gpu_program4 */
10152
#ifdef GL_NV_gpu_program5
10153
  CONST_CAST(GLEW_NV_gpu_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd);
10154
#endif /* GL_NV_gpu_program5 */
10155
#ifdef GL_NV_gpu_program_fp64
10156
  CONST_CAST(GLEW_NV_gpu_program_fp64) = _glewSearchExtension("GL_NV_gpu_program_fp64", extStart, extEnd);
10157
#endif /* GL_NV_gpu_program_fp64 */
10158
#ifdef GL_NV_gpu_shader5
10159
  CONST_CAST(GLEW_NV_gpu_shader5) = _glewSearchExtension("GL_NV_gpu_shader5", extStart, extEnd);
10160
  if (glewExperimental || GLEW_NV_gpu_shader5) CONST_CAST(GLEW_NV_gpu_shader5) = !_glewInit_GL_NV_gpu_shader5(GLEW_CONTEXT_ARG_VAR_INIT);
10161
#endif /* GL_NV_gpu_shader5 */
10162
#ifdef GL_NV_half_float
10163
  CONST_CAST(GLEW_NV_half_float) = _glewSearchExtension("GL_NV_half_float", extStart, extEnd);
10164
  if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);
10165
#endif /* GL_NV_half_float */
10166
#ifdef GL_NV_light_max_exponent
10167
  CONST_CAST(GLEW_NV_light_max_exponent) = _glewSearchExtension("GL_NV_light_max_exponent", extStart, extEnd);
10168
#endif /* GL_NV_light_max_exponent */
10169
#ifdef GL_NV_multisample_coverage
10170
  CONST_CAST(GLEW_NV_multisample_coverage) = _glewSearchExtension("GL_NV_multisample_coverage", extStart, extEnd);
10171
#endif /* GL_NV_multisample_coverage */
10172
#ifdef GL_NV_multisample_filter_hint
10173
  CONST_CAST(GLEW_NV_multisample_filter_hint) = _glewSearchExtension("GL_NV_multisample_filter_hint", extStart, extEnd);
10174
#endif /* GL_NV_multisample_filter_hint */
10175
#ifdef GL_NV_occlusion_query
10176
  CONST_CAST(GLEW_NV_occlusion_query) = _glewSearchExtension("GL_NV_occlusion_query", extStart, extEnd);
10177
  if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
10178
#endif /* GL_NV_occlusion_query */
10179
#ifdef GL_NV_packed_depth_stencil
10180
  CONST_CAST(GLEW_NV_packed_depth_stencil) = _glewSearchExtension("GL_NV_packed_depth_stencil", extStart, extEnd);
10181
#endif /* GL_NV_packed_depth_stencil */
10182
#ifdef GL_NV_parameter_buffer_object
10183
  CONST_CAST(GLEW_NV_parameter_buffer_object) = _glewSearchExtension("GL_NV_parameter_buffer_object", extStart, extEnd);
10184
  if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
10185
#endif /* GL_NV_parameter_buffer_object */
10186
#ifdef GL_NV_parameter_buffer_object2
10187
  CONST_CAST(GLEW_NV_parameter_buffer_object2) = _glewSearchExtension("GL_NV_parameter_buffer_object2", extStart, extEnd);
10188
#endif /* GL_NV_parameter_buffer_object2 */
10189
#ifdef GL_NV_path_rendering
10190
  CONST_CAST(GLEW_NV_path_rendering) = _glewSearchExtension("GL_NV_path_rendering", extStart, extEnd);
10191
  if (glewExperimental || GLEW_NV_path_rendering) CONST_CAST(GLEW_NV_path_rendering) = !_glewInit_GL_NV_path_rendering(GLEW_CONTEXT_ARG_VAR_INIT);
10192
#endif /* GL_NV_path_rendering */
10193
#ifdef GL_NV_pixel_data_range
10194
  CONST_CAST(GLEW_NV_pixel_data_range) = _glewSearchExtension("GL_NV_pixel_data_range", extStart, extEnd);
10195
  if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT);
10196
#endif /* GL_NV_pixel_data_range */
10197
#ifdef GL_NV_point_sprite
10198
  CONST_CAST(GLEW_NV_point_sprite) = _glewSearchExtension("GL_NV_point_sprite", extStart, extEnd);
10199
  if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT);
10200
#endif /* GL_NV_point_sprite */
10201
#ifdef GL_NV_present_video
10202
  CONST_CAST(GLEW_NV_present_video) = _glewSearchExtension("GL_NV_present_video", extStart, extEnd);
10203
  if (glewExperimental || GLEW_NV_present_video) CONST_CAST(GLEW_NV_present_video) = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
10204
#endif /* GL_NV_present_video */
10205
#ifdef GL_NV_primitive_restart
10206
  CONST_CAST(GLEW_NV_primitive_restart) = _glewSearchExtension("GL_NV_primitive_restart", extStart, extEnd);
10207
  if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT);
10208
#endif /* GL_NV_primitive_restart */
10209
#ifdef GL_NV_register_combiners
10210
  CONST_CAST(GLEW_NV_register_combiners) = _glewSearchExtension("GL_NV_register_combiners", extStart, extEnd);
10211
  if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);
10212
#endif /* GL_NV_register_combiners */
10213
#ifdef GL_NV_register_combiners2
10214
  CONST_CAST(GLEW_NV_register_combiners2) = _glewSearchExtension("GL_NV_register_combiners2", extStart, extEnd);
10215
  if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);
10216
#endif /* GL_NV_register_combiners2 */
10217
#ifdef GL_NV_shader_atomic_float
10218
  CONST_CAST(GLEW_NV_shader_atomic_float) = _glewSearchExtension("GL_NV_shader_atomic_float", extStart, extEnd);
10219
#endif /* GL_NV_shader_atomic_float */
10220
#ifdef GL_NV_shader_buffer_load
10221
  CONST_CAST(GLEW_NV_shader_buffer_load) = _glewSearchExtension("GL_NV_shader_buffer_load", extStart, extEnd);
10222
  if (glewExperimental || GLEW_NV_shader_buffer_load) CONST_CAST(GLEW_NV_shader_buffer_load) = !_glewInit_GL_NV_shader_buffer_load(GLEW_CONTEXT_ARG_VAR_INIT);
10223
#endif /* GL_NV_shader_buffer_load */
10224
#ifdef GL_NV_tessellation_program5
10225
  CONST_CAST(GLEW_NV_tessellation_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd);
10226
#endif /* GL_NV_tessellation_program5 */
10227
#ifdef GL_NV_texgen_emboss
10228
  CONST_CAST(GLEW_NV_texgen_emboss) = _glewSearchExtension("GL_NV_texgen_emboss", extStart, extEnd);
10229
#endif /* GL_NV_texgen_emboss */
10230
#ifdef GL_NV_texgen_reflection
10231
  CONST_CAST(GLEW_NV_texgen_reflection) = _glewSearchExtension("GL_NV_texgen_reflection", extStart, extEnd);
10232
#endif /* GL_NV_texgen_reflection */
10233
#ifdef GL_NV_texture_barrier
10234
  CONST_CAST(GLEW_NV_texture_barrier) = _glewSearchExtension("GL_NV_texture_barrier", extStart, extEnd);
10235
  if (glewExperimental || GLEW_NV_texture_barrier) CONST_CAST(GLEW_NV_texture_barrier) = !_glewInit_GL_NV_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
10236
#endif /* GL_NV_texture_barrier */
10237
#ifdef GL_NV_texture_compression_vtc
10238
  CONST_CAST(GLEW_NV_texture_compression_vtc) = _glewSearchExtension("GL_NV_texture_compression_vtc", extStart, extEnd);
10239
#endif /* GL_NV_texture_compression_vtc */
10240
#ifdef GL_NV_texture_env_combine4
10241
  CONST_CAST(GLEW_NV_texture_env_combine4) = _glewSearchExtension("GL_NV_texture_env_combine4", extStart, extEnd);
10242
#endif /* GL_NV_texture_env_combine4 */
10243
#ifdef GL_NV_texture_expand_normal
10244
  CONST_CAST(GLEW_NV_texture_expand_normal) = _glewSearchExtension("GL_NV_texture_expand_normal", extStart, extEnd);
10245
#endif /* GL_NV_texture_expand_normal */
10246
#ifdef GL_NV_texture_multisample
10247
  CONST_CAST(GLEW_NV_texture_multisample) = _glewSearchExtension("GL_NV_texture_multisample", extStart, extEnd);
10248
  if (glewExperimental || GLEW_NV_texture_multisample) CONST_CAST(GLEW_NV_texture_multisample) = !_glewInit_GL_NV_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10249
#endif /* GL_NV_texture_multisample */
10250
#ifdef GL_NV_texture_rectangle
10251
  CONST_CAST(GLEW_NV_texture_rectangle) = _glewSearchExtension("GL_NV_texture_rectangle", extStart, extEnd);
10252
#endif /* GL_NV_texture_rectangle */
10253
#ifdef GL_NV_texture_shader
10254
  CONST_CAST(GLEW_NV_texture_shader) = _glewSearchExtension("GL_NV_texture_shader", extStart, extEnd);
10255
#endif /* GL_NV_texture_shader */
10256
#ifdef GL_NV_texture_shader2
10257
  CONST_CAST(GLEW_NV_texture_shader2) = _glewSearchExtension("GL_NV_texture_shader2", extStart, extEnd);
10258
#endif /* GL_NV_texture_shader2 */
10259
#ifdef GL_NV_texture_shader3
10260
  CONST_CAST(GLEW_NV_texture_shader3) = _glewSearchExtension("GL_NV_texture_shader3", extStart, extEnd);
10261
#endif /* GL_NV_texture_shader3 */
10262
#ifdef GL_NV_transform_feedback
10263
  CONST_CAST(GLEW_NV_transform_feedback) = _glewSearchExtension("GL_NV_transform_feedback", extStart, extEnd);
10264
  if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
10265
#endif /* GL_NV_transform_feedback */
10266
#ifdef GL_NV_transform_feedback2
10267
  CONST_CAST(GLEW_NV_transform_feedback2) = _glewSearchExtension("GL_NV_transform_feedback2", extStart, extEnd);
10268
  if (glewExperimental || GLEW_NV_transform_feedback2) CONST_CAST(GLEW_NV_transform_feedback2) = !_glewInit_GL_NV_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
10269
#endif /* GL_NV_transform_feedback2 */
10270
#ifdef GL_NV_vdpau_interop
10271
  CONST_CAST(GLEW_NV_vdpau_interop) = _glewSearchExtension("GL_NV_vdpau_interop", extStart, extEnd);
10272
  if (glewExperimental || GLEW_NV_vdpau_interop) CONST_CAST(GLEW_NV_vdpau_interop) = !_glewInit_GL_NV_vdpau_interop(GLEW_CONTEXT_ARG_VAR_INIT);
10273
#endif /* GL_NV_vdpau_interop */
10274
#ifdef GL_NV_vertex_array_range
10275
  CONST_CAST(GLEW_NV_vertex_array_range) = _glewSearchExtension("GL_NV_vertex_array_range", extStart, extEnd);
10276
  if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
10277
#endif /* GL_NV_vertex_array_range */
10278
#ifdef GL_NV_vertex_array_range2
10279
  CONST_CAST(GLEW_NV_vertex_array_range2) = _glewSearchExtension("GL_NV_vertex_array_range2", extStart, extEnd);
10280
#endif /* GL_NV_vertex_array_range2 */
10281
#ifdef GL_NV_vertex_attrib_integer_64bit
10282
  CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = _glewSearchExtension("GL_NV_vertex_attrib_integer_64bit", extStart, extEnd);
10283
  if (glewExperimental || GLEW_NV_vertex_attrib_integer_64bit) CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = !_glewInit_GL_NV_vertex_attrib_integer_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
10284
#endif /* GL_NV_vertex_attrib_integer_64bit */
10285
#ifdef GL_NV_vertex_buffer_unified_memory
10286
  CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = _glewSearchExtension("GL_NV_vertex_buffer_unified_memory", extStart, extEnd);
10287
  if (glewExperimental || GLEW_NV_vertex_buffer_unified_memory) CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = !_glewInit_GL_NV_vertex_buffer_unified_memory(GLEW_CONTEXT_ARG_VAR_INIT);
10288
#endif /* GL_NV_vertex_buffer_unified_memory */
10289
#ifdef GL_NV_vertex_program
10290
  CONST_CAST(GLEW_NV_vertex_program) = _glewSearchExtension("GL_NV_vertex_program", extStart, extEnd);
10291
  if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
10292
#endif /* GL_NV_vertex_program */
10293
#ifdef GL_NV_vertex_program1_1
10294
  CONST_CAST(GLEW_NV_vertex_program1_1) = _glewSearchExtension("GL_NV_vertex_program1_1", extStart, extEnd);
10295
#endif /* GL_NV_vertex_program1_1 */
10296
#ifdef GL_NV_vertex_program2
10297
  CONST_CAST(GLEW_NV_vertex_program2) = _glewSearchExtension("GL_NV_vertex_program2", extStart, extEnd);
10298
#endif /* GL_NV_vertex_program2 */
10299
#ifdef GL_NV_vertex_program2_option
10300
  CONST_CAST(GLEW_NV_vertex_program2_option) = _glewSearchExtension("GL_NV_vertex_program2_option", extStart, extEnd);
10301
#endif /* GL_NV_vertex_program2_option */
10302
#ifdef GL_NV_vertex_program3
10303
  CONST_CAST(GLEW_NV_vertex_program3) = _glewSearchExtension("GL_NV_vertex_program3", extStart, extEnd);
10304
#endif /* GL_NV_vertex_program3 */
10305
#ifdef GL_NV_vertex_program4
10306
  CONST_CAST(GLEW_NV_vertex_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10307
#endif /* GL_NV_vertex_program4 */
10308
#ifdef GL_NV_video_capture
10309
  CONST_CAST(GLEW_NV_video_capture) = _glewSearchExtension("GL_NV_video_capture", extStart, extEnd);
10310
  if (glewExperimental || GLEW_NV_video_capture) CONST_CAST(GLEW_NV_video_capture) = !_glewInit_GL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
10311
#endif /* GL_NV_video_capture */
10312
#ifdef GL_OES_byte_coordinates
10313
  CONST_CAST(GLEW_OES_byte_coordinates) = _glewSearchExtension("GL_OES_byte_coordinates", extStart, extEnd);
10314
#endif /* GL_OES_byte_coordinates */
10315
#ifdef GL_OES_compressed_paletted_texture
10316
  CONST_CAST(GLEW_OES_compressed_paletted_texture) = _glewSearchExtension("GL_OES_compressed_paletted_texture", extStart, extEnd);
10317
#endif /* GL_OES_compressed_paletted_texture */
10318
#ifdef GL_OES_read_format
10319
  CONST_CAST(GLEW_OES_read_format) = _glewSearchExtension("GL_OES_read_format", extStart, extEnd);
10320
#endif /* GL_OES_read_format */
10321
#ifdef GL_OES_single_precision
10322
  CONST_CAST(GLEW_OES_single_precision) = _glewSearchExtension("GL_OES_single_precision", extStart, extEnd);
10323
  if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT);
10324
#endif /* GL_OES_single_precision */
10325
#ifdef GL_OML_interlace
10326
  CONST_CAST(GLEW_OML_interlace) = _glewSearchExtension("GL_OML_interlace", extStart, extEnd);
10327
#endif /* GL_OML_interlace */
10328
#ifdef GL_OML_resample
10329
  CONST_CAST(GLEW_OML_resample) = _glewSearchExtension("GL_OML_resample", extStart, extEnd);
10330
#endif /* GL_OML_resample */
10331
#ifdef GL_OML_subsample
10332
  CONST_CAST(GLEW_OML_subsample) = _glewSearchExtension("GL_OML_subsample", extStart, extEnd);
10333
#endif /* GL_OML_subsample */
10334
#ifdef GL_PGI_misc_hints
10335
  CONST_CAST(GLEW_PGI_misc_hints) = _glewSearchExtension("GL_PGI_misc_hints", extStart, extEnd);
10336
#endif /* GL_PGI_misc_hints */
10337
#ifdef GL_PGI_vertex_hints
10338
  CONST_CAST(GLEW_PGI_vertex_hints) = _glewSearchExtension("GL_PGI_vertex_hints", extStart, extEnd);
10339
#endif /* GL_PGI_vertex_hints */
10340
#ifdef GL_REGAL_error_string
10341
  CONST_CAST(GLEW_REGAL_error_string) = _glewSearchExtension("GL_REGAL_error_string", extStart, extEnd);
10342
  if (glewExperimental || GLEW_REGAL_error_string) CONST_CAST(GLEW_REGAL_error_string) = !_glewInit_GL_REGAL_error_string(GLEW_CONTEXT_ARG_VAR_INIT);
10343
#endif /* GL_REGAL_error_string */
10344
#ifdef GL_REGAL_extension_query
10345
  CONST_CAST(GLEW_REGAL_extension_query) = _glewSearchExtension("GL_REGAL_extension_query", extStart, extEnd);
10346
  if (glewExperimental || GLEW_REGAL_extension_query) CONST_CAST(GLEW_REGAL_extension_query) = !_glewInit_GL_REGAL_extension_query(GLEW_CONTEXT_ARG_VAR_INIT);
10347
#endif /* GL_REGAL_extension_query */
10348
#ifdef GL_REGAL_log
10349
  CONST_CAST(GLEW_REGAL_log) = _glewSearchExtension("GL_REGAL_log", extStart, extEnd);
10350
#endif /* GL_REGAL_log */
10351
#ifdef GL_REND_screen_coordinates
10352
  CONST_CAST(GLEW_REND_screen_coordinates) = _glewSearchExtension("GL_REND_screen_coordinates", extStart, extEnd);
10353
#endif /* GL_REND_screen_coordinates */
10354
#ifdef GL_S3_s3tc
10355
  CONST_CAST(GLEW_S3_s3tc) = _glewSearchExtension("GL_S3_s3tc", extStart, extEnd);
10356
#endif /* GL_S3_s3tc */
10357
#ifdef GL_SGIS_color_range
10358
  CONST_CAST(GLEW_SGIS_color_range) = _glewSearchExtension("GL_SGIS_color_range", extStart, extEnd);
10359
#endif /* GL_SGIS_color_range */
10360
#ifdef GL_SGIS_detail_texture
10361
  CONST_CAST(GLEW_SGIS_detail_texture) = _glewSearchExtension("GL_SGIS_detail_texture", extStart, extEnd);
10362
  if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10363
#endif /* GL_SGIS_detail_texture */
10364
#ifdef GL_SGIS_fog_function
10365
  CONST_CAST(GLEW_SGIS_fog_function) = _glewSearchExtension("GL_SGIS_fog_function", extStart, extEnd);
10366
  if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT);
10367
#endif /* GL_SGIS_fog_function */
10368
#ifdef GL_SGIS_generate_mipmap
10369
  CONST_CAST(GLEW_SGIS_generate_mipmap) = _glewSearchExtension("GL_SGIS_generate_mipmap", extStart, extEnd);
10370
#endif /* GL_SGIS_generate_mipmap */
10371
#ifdef GL_SGIS_multisample
10372
  CONST_CAST(GLEW_SGIS_multisample) = _glewSearchExtension("GL_SGIS_multisample", extStart, extEnd);
10373
  if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10374
#endif /* GL_SGIS_multisample */
10375
#ifdef GL_SGIS_pixel_texture
10376
  CONST_CAST(GLEW_SGIS_pixel_texture) = _glewSearchExtension("GL_SGIS_pixel_texture", extStart, extEnd);
10377
#endif /* GL_SGIS_pixel_texture */
10378
#ifdef GL_SGIS_point_line_texgen
10379
  CONST_CAST(GLEW_SGIS_point_line_texgen) = _glewSearchExtension("GL_SGIS_point_line_texgen", extStart, extEnd);
10380
#endif /* GL_SGIS_point_line_texgen */
10381
#ifdef GL_SGIS_sharpen_texture
10382
  CONST_CAST(GLEW_SGIS_sharpen_texture) = _glewSearchExtension("GL_SGIS_sharpen_texture", extStart, extEnd);
10383
  if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10384
#endif /* GL_SGIS_sharpen_texture */
10385
#ifdef GL_SGIS_texture4D
10386
  CONST_CAST(GLEW_SGIS_texture4D) = _glewSearchExtension("GL_SGIS_texture4D", extStart, extEnd);
10387
  if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT);
10388
#endif /* GL_SGIS_texture4D */
10389
#ifdef GL_SGIS_texture_border_clamp
10390
  CONST_CAST(GLEW_SGIS_texture_border_clamp) = _glewSearchExtension("GL_SGIS_texture_border_clamp", extStart, extEnd);
10391
#endif /* GL_SGIS_texture_border_clamp */
10392
#ifdef GL_SGIS_texture_edge_clamp
10393
  CONST_CAST(GLEW_SGIS_texture_edge_clamp) = _glewSearchExtension("GL_SGIS_texture_edge_clamp", extStart, extEnd);
10394
#endif /* GL_SGIS_texture_edge_clamp */
10395
#ifdef GL_SGIS_texture_filter4
10396
  CONST_CAST(GLEW_SGIS_texture_filter4) = _glewSearchExtension("GL_SGIS_texture_filter4", extStart, extEnd);
10397
  if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT);
10398
#endif /* GL_SGIS_texture_filter4 */
10399
#ifdef GL_SGIS_texture_lod
10400
  CONST_CAST(GLEW_SGIS_texture_lod) = _glewSearchExtension("GL_SGIS_texture_lod", extStart, extEnd);
10401
#endif /* GL_SGIS_texture_lod */
10402
#ifdef GL_SGIS_texture_select
10403
  CONST_CAST(GLEW_SGIS_texture_select) = _glewSearchExtension("GL_SGIS_texture_select", extStart, extEnd);
10404
#endif /* GL_SGIS_texture_select */
10405
#ifdef GL_SGIX_async
10406
  CONST_CAST(GLEW_SGIX_async) = _glewSearchExtension("GL_SGIX_async", extStart, extEnd);
10407
  if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT);
10408
#endif /* GL_SGIX_async */
10409
#ifdef GL_SGIX_async_histogram
10410
  CONST_CAST(GLEW_SGIX_async_histogram) = _glewSearchExtension("GL_SGIX_async_histogram", extStart, extEnd);
10411
#endif /* GL_SGIX_async_histogram */
10412
#ifdef GL_SGIX_async_pixel
10413
  CONST_CAST(GLEW_SGIX_async_pixel) = _glewSearchExtension("GL_SGIX_async_pixel", extStart, extEnd);
10414
#endif /* GL_SGIX_async_pixel */
10415
#ifdef GL_SGIX_blend_alpha_minmax
10416
  CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = _glewSearchExtension("GL_SGIX_blend_alpha_minmax", extStart, extEnd);
10417
#endif /* GL_SGIX_blend_alpha_minmax */
10418
#ifdef GL_SGIX_clipmap
10419
  CONST_CAST(GLEW_SGIX_clipmap) = _glewSearchExtension("GL_SGIX_clipmap", extStart, extEnd);
10420
#endif /* GL_SGIX_clipmap */
10421
#ifdef GL_SGIX_convolution_accuracy
10422
  CONST_CAST(GLEW_SGIX_convolution_accuracy) = _glewSearchExtension("GL_SGIX_convolution_accuracy", extStart, extEnd);
10423
#endif /* GL_SGIX_convolution_accuracy */
10424
#ifdef GL_SGIX_depth_texture
10425
  CONST_CAST(GLEW_SGIX_depth_texture) = _glewSearchExtension("GL_SGIX_depth_texture", extStart, extEnd);
10426
#endif /* GL_SGIX_depth_texture */
10427
#ifdef GL_SGIX_flush_raster
10428
  CONST_CAST(GLEW_SGIX_flush_raster) = _glewSearchExtension("GL_SGIX_flush_raster", extStart, extEnd);
10429
  if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT);
10430
#endif /* GL_SGIX_flush_raster */
10431
#ifdef GL_SGIX_fog_offset
10432
  CONST_CAST(GLEW_SGIX_fog_offset) = _glewSearchExtension("GL_SGIX_fog_offset", extStart, extEnd);
10433
#endif /* GL_SGIX_fog_offset */
10434
#ifdef GL_SGIX_fog_texture
10435
  CONST_CAST(GLEW_SGIX_fog_texture) = _glewSearchExtension("GL_SGIX_fog_texture", extStart, extEnd);
10436
  if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10437
#endif /* GL_SGIX_fog_texture */
10438
#ifdef GL_SGIX_fragment_specular_lighting
10439
  CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = _glewSearchExtension("GL_SGIX_fragment_specular_lighting", extStart, extEnd);
10440
  if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT);
10441
#endif /* GL_SGIX_fragment_specular_lighting */
10442
#ifdef GL_SGIX_framezoom
10443
  CONST_CAST(GLEW_SGIX_framezoom) = _glewSearchExtension("GL_SGIX_framezoom", extStart, extEnd);
10444
  if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT);
10445
#endif /* GL_SGIX_framezoom */
10446
#ifdef GL_SGIX_interlace
10447
  CONST_CAST(GLEW_SGIX_interlace) = _glewSearchExtension("GL_SGIX_interlace", extStart, extEnd);
10448
#endif /* GL_SGIX_interlace */
10449
#ifdef GL_SGIX_ir_instrument1
10450
  CONST_CAST(GLEW_SGIX_ir_instrument1) = _glewSearchExtension("GL_SGIX_ir_instrument1", extStart, extEnd);
10451
#endif /* GL_SGIX_ir_instrument1 */
10452
#ifdef GL_SGIX_list_priority
10453
  CONST_CAST(GLEW_SGIX_list_priority) = _glewSearchExtension("GL_SGIX_list_priority", extStart, extEnd);
10454
#endif /* GL_SGIX_list_priority */
10455
#ifdef GL_SGIX_pixel_texture
10456
  CONST_CAST(GLEW_SGIX_pixel_texture) = _glewSearchExtension("GL_SGIX_pixel_texture", extStart, extEnd);
10457
  if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10458
#endif /* GL_SGIX_pixel_texture */
10459
#ifdef GL_SGIX_pixel_texture_bits
10460
  CONST_CAST(GLEW_SGIX_pixel_texture_bits) = _glewSearchExtension("GL_SGIX_pixel_texture_bits", extStart, extEnd);
10461
#endif /* GL_SGIX_pixel_texture_bits */
10462
#ifdef GL_SGIX_reference_plane
10463
  CONST_CAST(GLEW_SGIX_reference_plane) = _glewSearchExtension("GL_SGIX_reference_plane", extStart, extEnd);
10464
  if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT);
10465
#endif /* GL_SGIX_reference_plane */
10466
#ifdef GL_SGIX_resample
10467
  CONST_CAST(GLEW_SGIX_resample) = _glewSearchExtension("GL_SGIX_resample", extStart, extEnd);
10468
#endif /* GL_SGIX_resample */
10469
#ifdef GL_SGIX_shadow
10470
  CONST_CAST(GLEW_SGIX_shadow) = _glewSearchExtension("GL_SGIX_shadow", extStart, extEnd);
10471
#endif /* GL_SGIX_shadow */
10472
#ifdef GL_SGIX_shadow_ambient
10473
  CONST_CAST(GLEW_SGIX_shadow_ambient) = _glewSearchExtension("GL_SGIX_shadow_ambient", extStart, extEnd);
10474
#endif /* GL_SGIX_shadow_ambient */
10475
#ifdef GL_SGIX_sprite
10476
  CONST_CAST(GLEW_SGIX_sprite) = _glewSearchExtension("GL_SGIX_sprite", extStart, extEnd);
10477
  if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT);
10478
#endif /* GL_SGIX_sprite */
10479
#ifdef GL_SGIX_tag_sample_buffer
10480
  CONST_CAST(GLEW_SGIX_tag_sample_buffer) = _glewSearchExtension("GL_SGIX_tag_sample_buffer", extStart, extEnd);
10481
  if (glewExperimental || GLEW_SGIX_tag_sample_buffer) CONST_CAST(GLEW_SGIX_tag_sample_buffer) = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
10482
#endif /* GL_SGIX_tag_sample_buffer */
10483
#ifdef GL_SGIX_texture_add_env
10484
  CONST_CAST(GLEW_SGIX_texture_add_env) = _glewSearchExtension("GL_SGIX_texture_add_env", extStart, extEnd);
10485
#endif /* GL_SGIX_texture_add_env */
10486
#ifdef GL_SGIX_texture_coordinate_clamp
10487
  CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = _glewSearchExtension("GL_SGIX_texture_coordinate_clamp", extStart, extEnd);
10488
#endif /* GL_SGIX_texture_coordinate_clamp */
10489
#ifdef GL_SGIX_texture_lod_bias
10490
  CONST_CAST(GLEW_SGIX_texture_lod_bias) = _glewSearchExtension("GL_SGIX_texture_lod_bias", extStart, extEnd);
10491
#endif /* GL_SGIX_texture_lod_bias */
10492
#ifdef GL_SGIX_texture_multi_buffer
10493
  CONST_CAST(GLEW_SGIX_texture_multi_buffer) = _glewSearchExtension("GL_SGIX_texture_multi_buffer", extStart, extEnd);
10494
#endif /* GL_SGIX_texture_multi_buffer */
10495
#ifdef GL_SGIX_texture_range
10496
  CONST_CAST(GLEW_SGIX_texture_range) = _glewSearchExtension("GL_SGIX_texture_range", extStart, extEnd);
10497
#endif /* GL_SGIX_texture_range */
10498
#ifdef GL_SGIX_texture_scale_bias
10499
  CONST_CAST(GLEW_SGIX_texture_scale_bias) = _glewSearchExtension("GL_SGIX_texture_scale_bias", extStart, extEnd);
10500
#endif /* GL_SGIX_texture_scale_bias */
10501
#ifdef GL_SGIX_vertex_preclip
10502
  CONST_CAST(GLEW_SGIX_vertex_preclip) = _glewSearchExtension("GL_SGIX_vertex_preclip", extStart, extEnd);
10503
#endif /* GL_SGIX_vertex_preclip */
10504
#ifdef GL_SGIX_vertex_preclip_hint
10505
  CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = _glewSearchExtension("GL_SGIX_vertex_preclip_hint", extStart, extEnd);
10506
#endif /* GL_SGIX_vertex_preclip_hint */
10507
#ifdef GL_SGIX_ycrcb
10508
  CONST_CAST(GLEW_SGIX_ycrcb) = _glewSearchExtension("GL_SGIX_ycrcb", extStart, extEnd);
10509
#endif /* GL_SGIX_ycrcb */
10510
#ifdef GL_SGI_color_matrix
10511
  CONST_CAST(GLEW_SGI_color_matrix) = _glewSearchExtension("GL_SGI_color_matrix", extStart, extEnd);
10512
#endif /* GL_SGI_color_matrix */
10513
#ifdef GL_SGI_color_table
10514
  CONST_CAST(GLEW_SGI_color_table) = _glewSearchExtension("GL_SGI_color_table", extStart, extEnd);
10515
  if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT);
10516
#endif /* GL_SGI_color_table */
10517
#ifdef GL_SGI_texture_color_table
10518
  CONST_CAST(GLEW_SGI_texture_color_table) = _glewSearchExtension("GL_SGI_texture_color_table", extStart, extEnd);
10519
#endif /* GL_SGI_texture_color_table */
10520
#ifdef GL_SUNX_constant_data
10521
  CONST_CAST(GLEW_SUNX_constant_data) = _glewSearchExtension("GL_SUNX_constant_data", extStart, extEnd);
10522
  if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT);
10523
#endif /* GL_SUNX_constant_data */
10524
#ifdef GL_SUN_convolution_border_modes
10525
  CONST_CAST(GLEW_SUN_convolution_border_modes) = _glewSearchExtension("GL_SUN_convolution_border_modes", extStart, extEnd);
10526
#endif /* GL_SUN_convolution_border_modes */
10527
#ifdef GL_SUN_global_alpha
10528
  CONST_CAST(GLEW_SUN_global_alpha) = _glewSearchExtension("GL_SUN_global_alpha", extStart, extEnd);
10529
  if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT);
10530
#endif /* GL_SUN_global_alpha */
10531
#ifdef GL_SUN_mesh_array
10532
  CONST_CAST(GLEW_SUN_mesh_array) = _glewSearchExtension("GL_SUN_mesh_array", extStart, extEnd);
10533
#endif /* GL_SUN_mesh_array */
10534
#ifdef GL_SUN_read_video_pixels
10535
  CONST_CAST(GLEW_SUN_read_video_pixels) = _glewSearchExtension("GL_SUN_read_video_pixels", extStart, extEnd);
10536
  if (glewExperimental || GLEW_SUN_read_video_pixels) CONST_CAST(GLEW_SUN_read_video_pixels) = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT);
10537
#endif /* GL_SUN_read_video_pixels */
10538
#ifdef GL_SUN_slice_accum
10539
  CONST_CAST(GLEW_SUN_slice_accum) = _glewSearchExtension("GL_SUN_slice_accum", extStart, extEnd);
10540
#endif /* GL_SUN_slice_accum */
10541
#ifdef GL_SUN_triangle_list
10542
  CONST_CAST(GLEW_SUN_triangle_list) = _glewSearchExtension("GL_SUN_triangle_list", extStart, extEnd);
10543
  if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT);
10544
#endif /* GL_SUN_triangle_list */
10545
#ifdef GL_SUN_vertex
10546
  CONST_CAST(GLEW_SUN_vertex) = _glewSearchExtension("GL_SUN_vertex", extStart, extEnd);
10547
  if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
10548
#endif /* GL_SUN_vertex */
10549
#ifdef GL_WIN_phong_shading
10550
  CONST_CAST(GLEW_WIN_phong_shading) = _glewSearchExtension("GL_WIN_phong_shading", extStart, extEnd);
10551
#endif /* GL_WIN_phong_shading */
10552
#ifdef GL_WIN_specular_fog
10553
  CONST_CAST(GLEW_WIN_specular_fog) = _glewSearchExtension("GL_WIN_specular_fog", extStart, extEnd);
10554
#endif /* GL_WIN_specular_fog */
10555
#ifdef GL_WIN_swap_hint
10556
  CONST_CAST(GLEW_WIN_swap_hint) = _glewSearchExtension("GL_WIN_swap_hint", extStart, extEnd);
10557
  if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT);
10558
#endif /* GL_WIN_swap_hint */
10559
 
10560
  return GLEW_OK;
10561
}
10562
 
10563
 
10564
#if defined(_WIN32)
10565
 
10566
#if !defined(GLEW_MX)
10567
 
10568
PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;
10569
 
10570
PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL;
10571
PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL;
10572
PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL;
10573
PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL;
10574
PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL;
10575
PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL;
10576
PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL;
10577
PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL;
10578
PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL;
10579
 
10580
PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;
10581
PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;
10582
PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;
10583
PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;
10584
 
10585
PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL;
10586
 
10587
PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;
10588
 
10589
PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;
10590
PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;
10591
 
10592
PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;
10593
PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;
10594
PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;
10595
PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;
10596
PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;
10597
 
10598
PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;
10599
PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;
10600
PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;
10601
 
10602
PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;
10603
PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;
10604
PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;
10605
 
10606
PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;
10607
PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;
10608
PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;
10609
PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;
10610
 
10611
PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;
10612
 
10613
PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;
10614
PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;
10615
 
10616
PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;
10617
PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;
10618
PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;
10619
PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;
10620
PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;
10621
 
10622
PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;
10623
PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;
10624
PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;
10625
 
10626
PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;
10627
PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;
10628
 
10629
PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;
10630
PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;
10631
 
10632
PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;
10633
PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;
10634
PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;
10635
PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;
10636
 
10637
PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;
10638
PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;
10639
PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;
10640
PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;
10641
PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;
10642
PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;
10643
PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;
10644
PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;
10645
PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;
10646
PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;
10647
PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;
10648
PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;
10649
 
10650
PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;
10651
PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;
10652
PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;
10653
PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;
10654
 
10655
PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;
10656
PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;
10657
PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;
10658
PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;
10659
 
10660
PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;
10661
PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;
10662
PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;
10663
PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;
10664
 
10665
PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV = NULL;
10666
PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV = NULL;
10667
PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV = NULL;
10668
PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV = NULL;
10669
PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV = NULL;
10670
PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV = NULL;
10671
PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV = NULL;
10672
PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV = NULL;
10673
 
10674
PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL;
10675
 
10676
PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;
10677
PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;
10678
PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;
10679
PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL;
10680
PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL;
10681
 
10682
PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL;
10683
PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL;
10684
PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL;
10685
 
10686
PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL;
10687
PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL;
10688
PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL;
10689
PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL;
10690
PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL;
10691
PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL;
10692
 
10693
PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;
10694
PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;
10695
 
10696
PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV = NULL;
10697
PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV = NULL;
10698
PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV = NULL;
10699
PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV = NULL;
10700
PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV = NULL;
10701
 
10702
PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL;
10703
PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL;
10704
PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL;
10705
PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL;
10706
PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL;
10707
PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL;
10708
 
10709
PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;
10710
PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;
10711
PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;
10712
PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;
10713
PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;
10714
PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;
10715
GLboolean __WGLEW_3DFX_multisample = GL_FALSE;
10716
GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;
10717
GLboolean __WGLEW_AMD_gpu_association = GL_FALSE;
10718
GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;
10719
GLboolean __WGLEW_ARB_create_context = GL_FALSE;
10720
GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE;
10721
GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE;
10722
GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;
10723
GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE;
10724
GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;
10725
GLboolean __WGLEW_ARB_multisample = GL_FALSE;
10726
GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;
10727
GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;
10728
GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;
10729
GLboolean __WGLEW_ARB_render_texture = GL_FALSE;
10730
GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;
10731
GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;
10732
GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE;
10733
GLboolean __WGLEW_EXT_create_context_es_profile = GL_FALSE;
10734
GLboolean __WGLEW_EXT_depth_float = GL_FALSE;
10735
GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;
10736
GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;
10737
GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE;
10738
GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;
10739
GLboolean __WGLEW_EXT_multisample = GL_FALSE;
10740
GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;
10741
GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;
10742
GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE;
10743
GLboolean __WGLEW_EXT_swap_control = GL_FALSE;
10744
GLboolean __WGLEW_EXT_swap_control_tear = GL_FALSE;
10745
GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;
10746
GLboolean __WGLEW_I3D_gamma = GL_FALSE;
10747
GLboolean __WGLEW_I3D_genlock = GL_FALSE;
10748
GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;
10749
GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;
10750
GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;
10751
GLboolean __WGLEW_NV_DX_interop = GL_FALSE;
10752
GLboolean __WGLEW_NV_DX_interop2 = GL_FALSE;
10753
GLboolean __WGLEW_NV_copy_image = GL_FALSE;
10754
GLboolean __WGLEW_NV_float_buffer = GL_FALSE;
10755
GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;
10756
GLboolean __WGLEW_NV_multisample_coverage = GL_FALSE;
10757
GLboolean __WGLEW_NV_present_video = GL_FALSE;
10758
GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;
10759
GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;
10760
GLboolean __WGLEW_NV_swap_group = GL_FALSE;
10761
GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;
10762
GLboolean __WGLEW_NV_video_capture = GL_FALSE;
10763
GLboolean __WGLEW_NV_video_output = GL_FALSE;
10764
GLboolean __WGLEW_OML_sync_control = GL_FALSE;
10765
 
10766
#endif /* !GLEW_MX */
10767
 
10768
#ifdef WGL_3DFX_multisample
10769
 
10770
#endif /* WGL_3DFX_multisample */
10771
 
10772
#ifdef WGL_3DL_stereo_control
10773
 
10774
static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT)
10775
{
10776
  GLboolean r = GL_FALSE;
10777
 
10778
  r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r;
10779
 
10780
  return r;
10781
}
10782
 
10783
#endif /* WGL_3DL_stereo_control */
10784
 
10785
#ifdef WGL_AMD_gpu_association
10786
 
10787
static GLboolean _glewInit_WGL_AMD_gpu_association (WGLEW_CONTEXT_ARG_DEF_INIT)
10788
{
10789
  GLboolean r = GL_FALSE;
10790
 
10791
  r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r;
10792
  r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r;
10793
  r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r;
10794
  r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r;
10795
  r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r;
10796
  r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r;
10797
  r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r;
10798
  r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r;
10799
  r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r;
10800
 
10801
  return r;
10802
}
10803
 
10804
#endif /* WGL_AMD_gpu_association */
10805
 
10806
#ifdef WGL_ARB_buffer_region
10807
 
10808
static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)
10809
{
10810
  GLboolean r = GL_FALSE;
10811
 
10812
  r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;
10813
  r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;
10814
  r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;
10815
  r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;
10816
 
10817
  return r;
10818
}
10819
 
10820
#endif /* WGL_ARB_buffer_region */
10821
 
10822
#ifdef WGL_ARB_create_context
10823
 
10824
static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT)
10825
{
10826
  GLboolean r = GL_FALSE;
10827
 
10828
  r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r;
10829
 
10830
  return r;
10831
}
10832
 
10833
#endif /* WGL_ARB_create_context */
10834
 
10835
#ifdef WGL_ARB_create_context_profile
10836
 
10837
#endif /* WGL_ARB_create_context_profile */
10838
 
10839
#ifdef WGL_ARB_create_context_robustness
10840
 
10841
#endif /* WGL_ARB_create_context_robustness */
10842
 
10843
#ifdef WGL_ARB_extensions_string
10844
 
10845
static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
10846
{
10847
  GLboolean r = GL_FALSE;
10848
 
10849
  r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;
10850
 
10851
  return r;
10852
}
10853
 
10854
#endif /* WGL_ARB_extensions_string */
10855
 
10856
#ifdef WGL_ARB_framebuffer_sRGB
10857
 
10858
#endif /* WGL_ARB_framebuffer_sRGB */
10859
 
10860
#ifdef WGL_ARB_make_current_read
10861
 
10862
static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)
10863
{
10864
  GLboolean r = GL_FALSE;
10865
 
10866
  r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;
10867
  r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;
10868
 
10869
  return r;
10870
}
10871
 
10872
#endif /* WGL_ARB_make_current_read */
10873
 
10874
#ifdef WGL_ARB_multisample
10875
 
10876
#endif /* WGL_ARB_multisample */
10877
 
10878
#ifdef WGL_ARB_pbuffer
10879
 
10880
static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
10881
{
10882
  GLboolean r = GL_FALSE;
10883
 
10884
  r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;
10885
  r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;
10886
  r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;
10887
  r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;
10888
  r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;
10889
 
10890
  return r;
10891
}
10892
 
10893
#endif /* WGL_ARB_pbuffer */
10894
 
10895
#ifdef WGL_ARB_pixel_format
10896
 
10897
static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
10898
{
10899
  GLboolean r = GL_FALSE;
10900
 
10901
  r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;
10902
  r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;
10903
  r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;
10904
 
10905
  return r;
10906
}
10907
 
10908
#endif /* WGL_ARB_pixel_format */
10909
 
10910
#ifdef WGL_ARB_pixel_format_float
10911
 
10912
#endif /* WGL_ARB_pixel_format_float */
10913
 
10914
#ifdef WGL_ARB_render_texture
10915
 
10916
static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)
10917
{
10918
  GLboolean r = GL_FALSE;
10919
 
10920
  r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;
10921
  r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;
10922
  r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;
10923
 
10924
  return r;
10925
}
10926
 
10927
#endif /* WGL_ARB_render_texture */
10928
 
10929
#ifdef WGL_ATI_pixel_format_float
10930
 
10931
#endif /* WGL_ATI_pixel_format_float */
10932
 
10933
#ifdef WGL_ATI_render_texture_rectangle
10934
 
10935
#endif /* WGL_ATI_render_texture_rectangle */
10936
 
10937
#ifdef WGL_EXT_create_context_es2_profile
10938
 
10939
#endif /* WGL_EXT_create_context_es2_profile */
10940
 
10941
#ifdef WGL_EXT_create_context_es_profile
10942
 
10943
#endif /* WGL_EXT_create_context_es_profile */
10944
 
10945
#ifdef WGL_EXT_depth_float
10946
 
10947
#endif /* WGL_EXT_depth_float */
10948
 
10949
#ifdef WGL_EXT_display_color_table
10950
 
10951
static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT)
10952
{
10953
  GLboolean r = GL_FALSE;
10954
 
10955
  r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;
10956
  r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;
10957
  r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;
10958
  r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;
10959
 
10960
  return r;
10961
}
10962
 
10963
#endif /* WGL_EXT_display_color_table */
10964
 
10965
#ifdef WGL_EXT_extensions_string
10966
 
10967
static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
10968
{
10969
  GLboolean r = GL_FALSE;
10970
 
10971
  r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;
10972
 
10973
  return r;
10974
}
10975
 
10976
#endif /* WGL_EXT_extensions_string */
10977
 
10978
#ifdef WGL_EXT_framebuffer_sRGB
10979
 
10980
#endif /* WGL_EXT_framebuffer_sRGB */
10981
 
10982
#ifdef WGL_EXT_make_current_read
10983
 
10984
static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)
10985
{
10986
  GLboolean r = GL_FALSE;
10987
 
10988
  r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;
10989
  r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;
10990
 
10991
  return r;
10992
}
10993
 
10994
#endif /* WGL_EXT_make_current_read */
10995
 
10996
#ifdef WGL_EXT_multisample
10997
 
10998
#endif /* WGL_EXT_multisample */
10999
 
11000
#ifdef WGL_EXT_pbuffer
11001
 
11002
static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
11003
{
11004
  GLboolean r = GL_FALSE;
11005
 
11006
  r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;
11007
  r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;
11008
  r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;
11009
  r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;
11010
  r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;
11011
 
11012
  return r;
11013
}
11014
 
11015
#endif /* WGL_EXT_pbuffer */
11016
 
11017
#ifdef WGL_EXT_pixel_format
11018
 
11019
static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
11020
{
11021
  GLboolean r = GL_FALSE;
11022
 
11023
  r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;
11024
  r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;
11025
  r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;
11026
 
11027
  return r;
11028
}
11029
 
11030
#endif /* WGL_EXT_pixel_format */
11031
 
11032
#ifdef WGL_EXT_pixel_format_packed_float
11033
 
11034
#endif /* WGL_EXT_pixel_format_packed_float */
11035
 
11036
#ifdef WGL_EXT_swap_control
11037
 
11038
static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)
11039
{
11040
  GLboolean r = GL_FALSE;
11041
 
11042
  r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;
11043
  r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;
11044
 
11045
  return r;
11046
}
11047
 
11048
#endif /* WGL_EXT_swap_control */
11049
 
11050
#ifdef WGL_EXT_swap_control_tear
11051
 
11052
#endif /* WGL_EXT_swap_control_tear */
11053
 
11054
#ifdef WGL_I3D_digital_video_control
11055
 
11056
static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT)
11057
{
11058
  GLboolean r = GL_FALSE;
11059
 
11060
  r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;
11061
  r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;
11062
 
11063
  return r;
11064
}
11065
 
11066
#endif /* WGL_I3D_digital_video_control */
11067
 
11068
#ifdef WGL_I3D_gamma
11069
 
11070
static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT)
11071
{
11072
  GLboolean r = GL_FALSE;
11073
 
11074
  r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;
11075
  r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;
11076
  r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;
11077
  r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;
11078
 
11079
  return r;
11080
}
11081
 
11082
#endif /* WGL_I3D_gamma */
11083
 
11084
#ifdef WGL_I3D_genlock
11085
 
11086
static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT)
11087
{
11088
  GLboolean r = GL_FALSE;
11089
 
11090
  r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;
11091
  r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;
11092
  r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;
11093
  r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;
11094
  r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;
11095
  r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;
11096
  r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;
11097
  r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;
11098
  r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;
11099
  r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;
11100
  r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;
11101
  r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;
11102
 
11103
  return r;
11104
}
11105
 
11106
#endif /* WGL_I3D_genlock */
11107
 
11108
#ifdef WGL_I3D_image_buffer
11109
 
11110
static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT)
11111
{
11112
  GLboolean r = GL_FALSE;
11113
 
11114
  r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;
11115
  r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;
11116
  r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;
11117
  r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;
11118
 
11119
  return r;
11120
}
11121
 
11122
#endif /* WGL_I3D_image_buffer */
11123
 
11124
#ifdef WGL_I3D_swap_frame_lock
11125
 
11126
static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT)
11127
{
11128
  GLboolean r = GL_FALSE;
11129
 
11130
  r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;
11131
  r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;
11132
  r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;
11133
  r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;
11134
 
11135
  return r;
11136
}
11137
 
11138
#endif /* WGL_I3D_swap_frame_lock */
11139
 
11140
#ifdef WGL_I3D_swap_frame_usage
11141
 
11142
static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)
11143
{
11144
  GLboolean r = GL_FALSE;
11145
 
11146
  r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;
11147
  r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;
11148
  r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;
11149
  r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;
11150
 
11151
  return r;
11152
}
11153
 
11154
#endif /* WGL_I3D_swap_frame_usage */
11155
 
11156
#ifdef WGL_NV_DX_interop
11157
 
11158
static GLboolean _glewInit_WGL_NV_DX_interop (WGLEW_CONTEXT_ARG_DEF_INIT)
11159
{
11160
  GLboolean r = GL_FALSE;
11161
 
11162
  r = ((wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXCloseDeviceNV")) == NULL) || r;
11163
  r = ((wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXLockObjectsNV")) == NULL) || r;
11164
  r = ((wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXObjectAccessNV")) == NULL) || r;
11165
  r = ((wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXOpenDeviceNV")) == NULL) || r;
11166
  r = ((wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXRegisterObjectNV")) == NULL) || r;
11167
  r = ((wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"wglDXSetResourceShareHandleNV")) == NULL) || r;
11168
  r = ((wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnlockObjectsNV")) == NULL) || r;
11169
  r = ((wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnregisterObjectNV")) == NULL) || r;
11170
 
11171
  return r;
11172
}
11173
 
11174
#endif /* WGL_NV_DX_interop */
11175
 
11176
#ifdef WGL_NV_DX_interop2
11177
 
11178
#endif /* WGL_NV_DX_interop2 */
11179
 
11180
#ifdef WGL_NV_copy_image
11181
 
11182
static GLboolean _glewInit_WGL_NV_copy_image (WGLEW_CONTEXT_ARG_DEF_INIT)
11183
{
11184
  GLboolean r = GL_FALSE;
11185
 
11186
  r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r;
11187
 
11188
  return r;
11189
}
11190
 
11191
#endif /* WGL_NV_copy_image */
11192
 
11193
#ifdef WGL_NV_float_buffer
11194
 
11195
#endif /* WGL_NV_float_buffer */
11196
 
11197
#ifdef WGL_NV_gpu_affinity
11198
 
11199
static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT)
11200
{
11201
  GLboolean r = GL_FALSE;
11202
 
11203
  r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r;
11204
  r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r;
11205
  r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r;
11206
  r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r;
11207
  r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r;
11208
 
11209
  return r;
11210
}
11211
 
11212
#endif /* WGL_NV_gpu_affinity */
11213
 
11214
#ifdef WGL_NV_multisample_coverage
11215
 
11216
#endif /* WGL_NV_multisample_coverage */
11217
 
11218
#ifdef WGL_NV_present_video
11219
 
11220
static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT)
11221
{
11222
  GLboolean r = GL_FALSE;
11223
 
11224
  r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r;
11225
  r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r;
11226
  r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r;
11227
 
11228
  return r;
11229
}
11230
 
11231
#endif /* WGL_NV_present_video */
11232
 
11233
#ifdef WGL_NV_render_depth_texture
11234
 
11235
#endif /* WGL_NV_render_depth_texture */
11236
 
11237
#ifdef WGL_NV_render_texture_rectangle
11238
 
11239
#endif /* WGL_NV_render_texture_rectangle */
11240
 
11241
#ifdef WGL_NV_swap_group
11242
 
11243
static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT)
11244
{
11245
  GLboolean r = GL_FALSE;
11246
 
11247
  r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r;
11248
  r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r;
11249
  r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r;
11250
  r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r;
11251
  r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r;
11252
  r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r;
11253
 
11254
  return r;
11255
}
11256
 
11257
#endif /* WGL_NV_swap_group */
11258
 
11259
#ifdef WGL_NV_vertex_array_range
11260
 
11261
static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT)
11262
{
11263
  GLboolean r = GL_FALSE;
11264
 
11265
  r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;
11266
  r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;
11267
 
11268
  return r;
11269
}
11270
 
11271
#endif /* WGL_NV_vertex_array_range */
11272
 
11273
#ifdef WGL_NV_video_capture
11274
 
11275
static GLboolean _glewInit_WGL_NV_video_capture (WGLEW_CONTEXT_ARG_DEF_INIT)
11276
{
11277
  GLboolean r = GL_FALSE;
11278
 
11279
  r = ((wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoCaptureDeviceNV")) == NULL) || r;
11280
  r = ((wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoCaptureDevicesNV")) == NULL) || r;
11281
  r = ((wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglLockVideoCaptureDeviceNV")) == NULL) || r;
11282
  r = ((wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglQueryVideoCaptureDeviceNV")) == NULL) || r;
11283
  r = ((wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoCaptureDeviceNV")) == NULL) || r;
11284
 
11285
  return r;
11286
}
11287
 
11288
#endif /* WGL_NV_video_capture */
11289
 
11290
#ifdef WGL_NV_video_output
11291
 
11292
static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT)
11293
{
11294
  GLboolean r = GL_FALSE;
11295
 
11296
  r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r;
11297
  r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r;
11298
  r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r;
11299
  r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r;
11300
  r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r;
11301
  r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r;
11302
 
11303
  return r;
11304
}
11305
 
11306
#endif /* WGL_NV_video_output */
11307
 
11308
#ifdef WGL_OML_sync_control
11309
 
11310
static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT)
11311
{
11312
  GLboolean r = GL_FALSE;
11313
 
11314
  r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;
11315
  r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;
11316
  r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;
11317
  r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;
11318
  r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;
11319
  r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;
11320
 
11321
  return r;
11322
}
11323
 
11324
#endif /* WGL_OML_sync_control */
11325
 
11326
/* ------------------------------------------------------------------------- */
11327
 
11328
static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;
11329
static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;
11330
 
11331
GLboolean GLEWAPIENTRY wglewGetExtension (const char* name)
11332
{    
11333
  const GLubyte* start;
11334
  const GLubyte* end;
11335
  if (_wglewGetExtensionsStringARB == NULL)
11336
    if (_wglewGetExtensionsStringEXT == NULL)
11337
      return GL_FALSE;
11338
    else
11339
      start = (const GLubyte*)_wglewGetExtensionsStringEXT();
11340
  else
11341
    start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
11342
  if (start == 0)
11343
    return GL_FALSE;
11344
  end = start + _glewStrLen(start);
11345
  return _glewSearchExtension(name, start, end);
11346
}
11347
 
11348
GLenum GLEWAPIENTRY wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
11349
{
11350
  GLboolean crippled;
11351
  const GLubyte* extStart;
11352
  const GLubyte* extEnd;
11353
  /* find wgl extension string query functions */
11354
  _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");
11355
  _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");
11356
  /* query wgl extension string */
11357
  if (_wglewGetExtensionsStringARB == NULL)
11358
    if (_wglewGetExtensionsStringEXT == NULL)
11359
      extStart = (const GLubyte*)"";
11360
    else
11361
      extStart = (const GLubyte*)_wglewGetExtensionsStringEXT();
11362
  else
11363
    extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
11364
  extEnd = extStart + _glewStrLen(extStart);
11365
  /* initialize extensions */
11366
  crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;
11367
#ifdef WGL_3DFX_multisample
11368
  CONST_CAST(WGLEW_3DFX_multisample) = _glewSearchExtension("WGL_3DFX_multisample", extStart, extEnd);
11369
#endif /* WGL_3DFX_multisample */
11370
#ifdef WGL_3DL_stereo_control
11371
  CONST_CAST(WGLEW_3DL_stereo_control) = _glewSearchExtension("WGL_3DL_stereo_control", extStart, extEnd);
11372
  if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT);
11373
#endif /* WGL_3DL_stereo_control */
11374
#ifdef WGL_AMD_gpu_association
11375
  CONST_CAST(WGLEW_AMD_gpu_association) = _glewSearchExtension("WGL_AMD_gpu_association", extStart, extEnd);
11376
  if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) CONST_CAST(WGLEW_AMD_gpu_association)= !_glewInit_WGL_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT);
11377
#endif /* WGL_AMD_gpu_association */
11378
#ifdef WGL_ARB_buffer_region
11379
  CONST_CAST(WGLEW_ARB_buffer_region) = _glewSearchExtension("WGL_ARB_buffer_region", extStart, extEnd);
11380
  if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
11381
#endif /* WGL_ARB_buffer_region */
11382
#ifdef WGL_ARB_create_context
11383
  CONST_CAST(WGLEW_ARB_create_context) = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd);
11384
  if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
11385
#endif /* WGL_ARB_create_context */
11386
#ifdef WGL_ARB_create_context_profile
11387
  CONST_CAST(WGLEW_ARB_create_context_profile) = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd);
11388
#endif /* WGL_ARB_create_context_profile */
11389
#ifdef WGL_ARB_create_context_robustness
11390
  CONST_CAST(WGLEW_ARB_create_context_robustness) = _glewSearchExtension("WGL_ARB_create_context_robustness", extStart, extEnd);
11391
#endif /* WGL_ARB_create_context_robustness */
11392
#ifdef WGL_ARB_extensions_string
11393
  CONST_CAST(WGLEW_ARB_extensions_string) = _glewSearchExtension("WGL_ARB_extensions_string", extStart, extEnd);
11394
  if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
11395
#endif /* WGL_ARB_extensions_string */
11396
#ifdef WGL_ARB_framebuffer_sRGB
11397
  CONST_CAST(WGLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("WGL_ARB_framebuffer_sRGB", extStart, extEnd);
11398
#endif /* WGL_ARB_framebuffer_sRGB */
11399
#ifdef WGL_ARB_make_current_read
11400
  CONST_CAST(WGLEW_ARB_make_current_read) = _glewSearchExtension("WGL_ARB_make_current_read", extStart, extEnd);
11401
  if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) CONST_CAST(WGLEW_ARB_make_current_read)= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);
11402
#endif /* WGL_ARB_make_current_read */
11403
#ifdef WGL_ARB_multisample
11404
  CONST_CAST(WGLEW_ARB_multisample) = _glewSearchExtension("WGL_ARB_multisample", extStart, extEnd);
11405
#endif /* WGL_ARB_multisample */
11406
#ifdef WGL_ARB_pbuffer
11407
  CONST_CAST(WGLEW_ARB_pbuffer) = _glewSearchExtension("WGL_ARB_pbuffer", extStart, extEnd);
11408
  if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
11409
#endif /* WGL_ARB_pbuffer */
11410
#ifdef WGL_ARB_pixel_format
11411
  CONST_CAST(WGLEW_ARB_pixel_format) = _glewSearchExtension("WGL_ARB_pixel_format", extStart, extEnd);
11412
  if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
11413
#endif /* WGL_ARB_pixel_format */
11414
#ifdef WGL_ARB_pixel_format_float
11415
  CONST_CAST(WGLEW_ARB_pixel_format_float) = _glewSearchExtension("WGL_ARB_pixel_format_float", extStart, extEnd);
11416
#endif /* WGL_ARB_pixel_format_float */
11417
#ifdef WGL_ARB_render_texture
11418
  CONST_CAST(WGLEW_ARB_render_texture) = _glewSearchExtension("WGL_ARB_render_texture", extStart, extEnd);
11419
  if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
11420
#endif /* WGL_ARB_render_texture */
11421
#ifdef WGL_ATI_pixel_format_float
11422
  CONST_CAST(WGLEW_ATI_pixel_format_float) = _glewSearchExtension("WGL_ATI_pixel_format_float", extStart, extEnd);
11423
#endif /* WGL_ATI_pixel_format_float */
11424
#ifdef WGL_ATI_render_texture_rectangle
11425
  CONST_CAST(WGLEW_ATI_render_texture_rectangle) = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd);
11426
#endif /* WGL_ATI_render_texture_rectangle */
11427
#ifdef WGL_EXT_create_context_es2_profile
11428
  CONST_CAST(WGLEW_EXT_create_context_es2_profile) = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd);
11429
#endif /* WGL_EXT_create_context_es2_profile */
11430
#ifdef WGL_EXT_create_context_es_profile
11431
  CONST_CAST(WGLEW_EXT_create_context_es_profile) = _glewSearchExtension("WGL_EXT_create_context_es_profile", extStart, extEnd);
11432
#endif /* WGL_EXT_create_context_es_profile */
11433
#ifdef WGL_EXT_depth_float
11434
  CONST_CAST(WGLEW_EXT_depth_float) = _glewSearchExtension("WGL_EXT_depth_float", extStart, extEnd);
11435
#endif /* WGL_EXT_depth_float */
11436
#ifdef WGL_EXT_display_color_table
11437
  CONST_CAST(WGLEW_EXT_display_color_table) = _glewSearchExtension("WGL_EXT_display_color_table", extStart, extEnd);
11438
  if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) CONST_CAST(WGLEW_EXT_display_color_table)= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT);
11439
#endif /* WGL_EXT_display_color_table */
11440
#ifdef WGL_EXT_extensions_string
11441
  CONST_CAST(WGLEW_EXT_extensions_string) = _glewSearchExtension("WGL_EXT_extensions_string", extStart, extEnd);
11442
  if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
11443
#endif /* WGL_EXT_extensions_string */
11444
#ifdef WGL_EXT_framebuffer_sRGB
11445
  CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("WGL_EXT_framebuffer_sRGB", extStart, extEnd);
11446
#endif /* WGL_EXT_framebuffer_sRGB */
11447
#ifdef WGL_EXT_make_current_read
11448
  CONST_CAST(WGLEW_EXT_make_current_read) = _glewSearchExtension("WGL_EXT_make_current_read", extStart, extEnd);
11449
  if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) CONST_CAST(WGLEW_EXT_make_current_read)= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);
11450
#endif /* WGL_EXT_make_current_read */
11451
#ifdef WGL_EXT_multisample
11452
  CONST_CAST(WGLEW_EXT_multisample) = _glewSearchExtension("WGL_EXT_multisample", extStart, extEnd);
11453
#endif /* WGL_EXT_multisample */
11454
#ifdef WGL_EXT_pbuffer
11455
  CONST_CAST(WGLEW_EXT_pbuffer) = _glewSearchExtension("WGL_EXT_pbuffer", extStart, extEnd);
11456
  if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
11457
#endif /* WGL_EXT_pbuffer */
11458
#ifdef WGL_EXT_pixel_format
11459
  CONST_CAST(WGLEW_EXT_pixel_format) = _glewSearchExtension("WGL_EXT_pixel_format", extStart, extEnd);
11460
  if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
11461
#endif /* WGL_EXT_pixel_format */
11462
#ifdef WGL_EXT_pixel_format_packed_float
11463
  CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = _glewSearchExtension("WGL_EXT_pixel_format_packed_float", extStart, extEnd);
11464
#endif /* WGL_EXT_pixel_format_packed_float */
11465
#ifdef WGL_EXT_swap_control
11466
  CONST_CAST(WGLEW_EXT_swap_control) = _glewSearchExtension("WGL_EXT_swap_control", extStart, extEnd);
11467
  if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
11468
#endif /* WGL_EXT_swap_control */
11469
#ifdef WGL_EXT_swap_control_tear
11470
  CONST_CAST(WGLEW_EXT_swap_control_tear) = _glewSearchExtension("WGL_EXT_swap_control_tear", extStart, extEnd);
11471
#endif /* WGL_EXT_swap_control_tear */
11472
#ifdef WGL_I3D_digital_video_control
11473
  CONST_CAST(WGLEW_I3D_digital_video_control) = _glewSearchExtension("WGL_I3D_digital_video_control", extStart, extEnd);
11474
  if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) CONST_CAST(WGLEW_I3D_digital_video_control)= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT);
11475
#endif /* WGL_I3D_digital_video_control */
11476
#ifdef WGL_I3D_gamma
11477
  CONST_CAST(WGLEW_I3D_gamma) = _glewSearchExtension("WGL_I3D_gamma", extStart, extEnd);
11478
  if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT);
11479
#endif /* WGL_I3D_gamma */
11480
#ifdef WGL_I3D_genlock
11481
  CONST_CAST(WGLEW_I3D_genlock) = _glewSearchExtension("WGL_I3D_genlock", extStart, extEnd);
11482
  if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT);
11483
#endif /* WGL_I3D_genlock */
11484
#ifdef WGL_I3D_image_buffer
11485
  CONST_CAST(WGLEW_I3D_image_buffer) = _glewSearchExtension("WGL_I3D_image_buffer", extStart, extEnd);
11486
  if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
11487
#endif /* WGL_I3D_image_buffer */
11488
#ifdef WGL_I3D_swap_frame_lock
11489
  CONST_CAST(WGLEW_I3D_swap_frame_lock) = _glewSearchExtension("WGL_I3D_swap_frame_lock", extStart, extEnd);
11490
  if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_lock)= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT);
11491
#endif /* WGL_I3D_swap_frame_lock */
11492
#ifdef WGL_I3D_swap_frame_usage
11493
  CONST_CAST(WGLEW_I3D_swap_frame_usage) = _glewSearchExtension("WGL_I3D_swap_frame_usage", extStart, extEnd);
11494
  if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT);
11495
#endif /* WGL_I3D_swap_frame_usage */
11496
#ifdef WGL_NV_DX_interop
11497
  CONST_CAST(WGLEW_NV_DX_interop) = _glewSearchExtension("WGL_NV_DX_interop", extStart, extEnd);
11498
  if (glewExperimental || WGLEW_NV_DX_interop|| crippled) CONST_CAST(WGLEW_NV_DX_interop)= !_glewInit_WGL_NV_DX_interop(GLEW_CONTEXT_ARG_VAR_INIT);
11499
#endif /* WGL_NV_DX_interop */
11500
#ifdef WGL_NV_DX_interop2
11501
  CONST_CAST(WGLEW_NV_DX_interop2) = _glewSearchExtension("WGL_NV_DX_interop2", extStart, extEnd);
11502
#endif /* WGL_NV_DX_interop2 */
11503
#ifdef WGL_NV_copy_image
11504
  CONST_CAST(WGLEW_NV_copy_image) = _glewSearchExtension("WGL_NV_copy_image", extStart, extEnd);
11505
  if (glewExperimental || WGLEW_NV_copy_image|| crippled) CONST_CAST(WGLEW_NV_copy_image)= !_glewInit_WGL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
11506
#endif /* WGL_NV_copy_image */
11507
#ifdef WGL_NV_float_buffer
11508
  CONST_CAST(WGLEW_NV_float_buffer) = _glewSearchExtension("WGL_NV_float_buffer", extStart, extEnd);
11509
#endif /* WGL_NV_float_buffer */
11510
#ifdef WGL_NV_gpu_affinity
11511
  CONST_CAST(WGLEW_NV_gpu_affinity) = _glewSearchExtension("WGL_NV_gpu_affinity", extStart, extEnd);
11512
  if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT);
11513
#endif /* WGL_NV_gpu_affinity */
11514
#ifdef WGL_NV_multisample_coverage
11515
  CONST_CAST(WGLEW_NV_multisample_coverage) = _glewSearchExtension("WGL_NV_multisample_coverage", extStart, extEnd);
11516
#endif /* WGL_NV_multisample_coverage */
11517
#ifdef WGL_NV_present_video
11518
  CONST_CAST(WGLEW_NV_present_video) = _glewSearchExtension("WGL_NV_present_video", extStart, extEnd);
11519
  if (glewExperimental || WGLEW_NV_present_video|| crippled) CONST_CAST(WGLEW_NV_present_video)= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
11520
#endif /* WGL_NV_present_video */
11521
#ifdef WGL_NV_render_depth_texture
11522
  CONST_CAST(WGLEW_NV_render_depth_texture) = _glewSearchExtension("WGL_NV_render_depth_texture", extStart, extEnd);
11523
#endif /* WGL_NV_render_depth_texture */
11524
#ifdef WGL_NV_render_texture_rectangle
11525
  CONST_CAST(WGLEW_NV_render_texture_rectangle) = _glewSearchExtension("WGL_NV_render_texture_rectangle", extStart, extEnd);
11526
#endif /* WGL_NV_render_texture_rectangle */
11527
#ifdef WGL_NV_swap_group
11528
  CONST_CAST(WGLEW_NV_swap_group) = _glewSearchExtension("WGL_NV_swap_group", extStart, extEnd);
11529
  if (glewExperimental || WGLEW_NV_swap_group|| crippled) CONST_CAST(WGLEW_NV_swap_group)= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
11530
#endif /* WGL_NV_swap_group */
11531
#ifdef WGL_NV_vertex_array_range
11532
  CONST_CAST(WGLEW_NV_vertex_array_range) = _glewSearchExtension("WGL_NV_vertex_array_range", extStart, extEnd);
11533
  if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) CONST_CAST(WGLEW_NV_vertex_array_range)= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
11534
#endif /* WGL_NV_vertex_array_range */
11535
#ifdef WGL_NV_video_capture
11536
  CONST_CAST(WGLEW_NV_video_capture) = _glewSearchExtension("WGL_NV_video_capture", extStart, extEnd);
11537
  if (glewExperimental || WGLEW_NV_video_capture|| crippled) CONST_CAST(WGLEW_NV_video_capture)= !_glewInit_WGL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
11538
#endif /* WGL_NV_video_capture */
11539
#ifdef WGL_NV_video_output
11540
  CONST_CAST(WGLEW_NV_video_output) = _glewSearchExtension("WGL_NV_video_output", extStart, extEnd);
11541
  if (glewExperimental || WGLEW_NV_video_output|| crippled) CONST_CAST(WGLEW_NV_video_output)= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);
11542
#endif /* WGL_NV_video_output */
11543
#ifdef WGL_OML_sync_control
11544
  CONST_CAST(WGLEW_OML_sync_control) = _glewSearchExtension("WGL_OML_sync_control", extStart, extEnd);
11545
  if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);
11546
#endif /* WGL_OML_sync_control */
11547
 
11548
  return GLEW_OK;
11549
}
11550
 
11551
#elif !defined(__ANDROID__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))
11552
 
11553
PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;
11554
 
11555
PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;
11556
PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;
11557
PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;
11558
PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;
11559
PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;
11560
PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;
11561
PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;
11562
PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;
11563
PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;
11564
PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;
11565
PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;
11566
PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;
11567
PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;
11568
PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;
11569
PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;
11570
PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;
11571
PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;
11572
 
11573
PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL;
11574
 
11575
PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;
11576
PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;
11577
PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;
11578
 
11579
PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;
11580
PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;
11581
PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;
11582
PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;
11583
 
11584
PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL;
11585
 
11586
PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;
11587
PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;
11588
 
11589
PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;
11590
 
11591
PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;
11592
 
11593
PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;
11594
 
11595
PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;
11596
 
11597
PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;
11598
 
11599
PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA = NULL;
11600
PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA = NULL;
11601
 
11602
PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL;
11603
 
11604
PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL;
11605
PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL;
11606
 
11607
PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL;
11608
PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL;
11609
PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL;
11610
PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL;
11611
PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL;
11612
PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL;
11613
 
11614
PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;
11615
PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;
11616
 
11617
PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV = NULL;
11618
PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV = NULL;
11619
PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV = NULL;
11620
PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV = NULL;
11621
PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV = NULL;
11622
 
11623
PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL;
11624
PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL;
11625
PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL;
11626
PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL;
11627
PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL;
11628
PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL;
11629
 
11630
PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;
11631
PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;
11632
PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;
11633
PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;
11634
PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;
11635
 
11636
PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;
11637
PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;
11638
PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;
11639
PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;
11640
PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;
11641
PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;
11642
 
11643
PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL;
11644
PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL;
11645
PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL;
11646
PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL;
11647
PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL;
11648
PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL;
11649
PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL;
11650
PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL;
11651
 
11652
PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;
11653
PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;
11654
PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;
11655
PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;
11656
PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;
11657
 
11658
PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;
11659
PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;
11660
 
11661
PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;
11662
 
11663
PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;
11664
PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;
11665
PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;
11666
PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;
11667
PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;
11668
 
11669
PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;
11670
 
11671
PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;
11672
PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;
11673
 
11674
PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;
11675
 
11676
PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;
11677
PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;
11678
 
11679
PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;
11680
 
11681
PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;
11682
PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;
11683
 
11684
#if !defined(GLEW_MX)
11685
 
11686
GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;
11687
GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;
11688
GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;
11689
GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;
11690
GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;
11691
GLboolean __GLXEW_3DFX_multisample = GL_FALSE;
11692
GLboolean __GLXEW_AMD_gpu_association = GL_FALSE;
11693
GLboolean __GLXEW_ARB_create_context = GL_FALSE;
11694
GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE;
11695
GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE;
11696
GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;
11697
GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE;
11698
GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;
11699
GLboolean __GLXEW_ARB_multisample = GL_FALSE;
11700
GLboolean __GLXEW_ARB_robustness_application_isolation = GL_FALSE;
11701
GLboolean __GLXEW_ARB_robustness_share_group_isolation = GL_FALSE;
11702
GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE;
11703
GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;
11704
GLboolean __GLXEW_ATI_render_texture = GL_FALSE;
11705
GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE;
11706
GLboolean __GLXEW_EXT_create_context_es_profile = GL_FALSE;
11707
GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;
11708
GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;
11709
GLboolean __GLXEW_EXT_import_context = GL_FALSE;
11710
GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;
11711
GLboolean __GLXEW_EXT_swap_control = GL_FALSE;
11712
GLboolean __GLXEW_EXT_swap_control_tear = GL_FALSE;
11713
GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;
11714
GLboolean __GLXEW_EXT_visual_info = GL_FALSE;
11715
GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;
11716
GLboolean __GLXEW_INTEL_swap_event = GL_FALSE;
11717
GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;
11718
GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;
11719
GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;
11720
GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;
11721
GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;
11722
GLboolean __GLXEW_MESA_swap_control = GL_FALSE;
11723
GLboolean __GLXEW_NV_copy_image = GL_FALSE;
11724
GLboolean __GLXEW_NV_float_buffer = GL_FALSE;
11725
GLboolean __GLXEW_NV_multisample_coverage = GL_FALSE;
11726
GLboolean __GLXEW_NV_present_video = GL_FALSE;
11727
GLboolean __GLXEW_NV_swap_group = GL_FALSE;
11728
GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;
11729
GLboolean __GLXEW_NV_video_capture = GL_FALSE;
11730
GLboolean __GLXEW_NV_video_out = GL_FALSE;
11731
GLboolean __GLXEW_OML_swap_method = GL_FALSE;
11732
GLboolean __GLXEW_OML_sync_control = GL_FALSE;
11733
GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;
11734
GLboolean __GLXEW_SGIS_color_range = GL_FALSE;
11735
GLboolean __GLXEW_SGIS_multisample = GL_FALSE;
11736
GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;
11737
GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;
11738
GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE;
11739
GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;
11740
GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;
11741
GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;
11742
GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;
11743
GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;
11744
GLboolean __GLXEW_SGI_cushion = GL_FALSE;
11745
GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;
11746
GLboolean __GLXEW_SGI_swap_control = GL_FALSE;
11747
GLboolean __GLXEW_SGI_video_sync = GL_FALSE;
11748
GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;
11749
GLboolean __GLXEW_SUN_video_resize = GL_FALSE;
11750
 
11751
#endif /* !GLEW_MX */
11752
 
11753
#ifdef GLX_VERSION_1_2
11754
 
11755
static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT)
11756
{
11757
  GLboolean r = GL_FALSE;
11758
 
11759
  r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;
11760
 
11761
  return r;
11762
}
11763
 
11764
#endif /* GLX_VERSION_1_2 */
11765
 
11766
#ifdef GLX_VERSION_1_3
11767
 
11768
static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT)
11769
{
11770
  GLboolean r = GL_FALSE;
11771
 
11772
  r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;
11773
  r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;
11774
  r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;
11775
  r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;
11776
  r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;
11777
  r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;
11778
  r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;
11779
  r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;
11780
  r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;
11781
  r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;
11782
  r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;
11783
  r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;
11784
  r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;
11785
  r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;
11786
  r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;
11787
  r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;
11788
  r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;
11789
 
11790
  return r;
11791
}
11792
 
11793
#endif /* GLX_VERSION_1_3 */
11794
 
11795
#ifdef GLX_VERSION_1_4
11796
 
11797
#endif /* GLX_VERSION_1_4 */
11798
 
11799
#ifdef GLX_3DFX_multisample
11800
 
11801
#endif /* GLX_3DFX_multisample */
11802
 
11803
#ifdef GLX_AMD_gpu_association
11804
 
11805
#endif /* GLX_AMD_gpu_association */
11806
 
11807
#ifdef GLX_ARB_create_context
11808
 
11809
static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT)
11810
{
11811
  GLboolean r = GL_FALSE;
11812
 
11813
  r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r;
11814
 
11815
  return r;
11816
}
11817
 
11818
#endif /* GLX_ARB_create_context */
11819
 
11820
#ifdef GLX_ARB_create_context_profile
11821
 
11822
#endif /* GLX_ARB_create_context_profile */
11823
 
11824
#ifdef GLX_ARB_create_context_robustness
11825
 
11826
#endif /* GLX_ARB_create_context_robustness */
11827
 
11828
#ifdef GLX_ARB_fbconfig_float
11829
 
11830
#endif /* GLX_ARB_fbconfig_float */
11831
 
11832
#ifdef GLX_ARB_framebuffer_sRGB
11833
 
11834
#endif /* GLX_ARB_framebuffer_sRGB */
11835
 
11836
#ifdef GLX_ARB_get_proc_address
11837
 
11838
#endif /* GLX_ARB_get_proc_address */
11839
 
11840
#ifdef GLX_ARB_multisample
11841
 
11842
#endif /* GLX_ARB_multisample */
11843
 
11844
#ifdef GLX_ARB_robustness_application_isolation
11845
 
11846
#endif /* GLX_ARB_robustness_application_isolation */
11847
 
11848
#ifdef GLX_ARB_robustness_share_group_isolation
11849
 
11850
#endif /* GLX_ARB_robustness_share_group_isolation */
11851
 
11852
#ifdef GLX_ARB_vertex_buffer_object
11853
 
11854
#endif /* GLX_ARB_vertex_buffer_object */
11855
 
11856
#ifdef GLX_ATI_pixel_format_float
11857
 
11858
#endif /* GLX_ATI_pixel_format_float */
11859
 
11860
#ifdef GLX_ATI_render_texture
11861
 
11862
static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT)
11863
{
11864
  GLboolean r = GL_FALSE;
11865
 
11866
  r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;
11867
  r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;
11868
  r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;
11869
 
11870
  return r;
11871
}
11872
 
11873
#endif /* GLX_ATI_render_texture */
11874
 
11875
#ifdef GLX_EXT_create_context_es2_profile
11876
 
11877
#endif /* GLX_EXT_create_context_es2_profile */
11878
 
11879
#ifdef GLX_EXT_create_context_es_profile
11880
 
11881
#endif /* GLX_EXT_create_context_es_profile */
11882
 
11883
#ifdef GLX_EXT_fbconfig_packed_float
11884
 
11885
#endif /* GLX_EXT_fbconfig_packed_float */
11886
 
11887
#ifdef GLX_EXT_framebuffer_sRGB
11888
 
11889
#endif /* GLX_EXT_framebuffer_sRGB */
11890
 
11891
#ifdef GLX_EXT_import_context
11892
 
11893
static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)
11894
{
11895
  GLboolean r = GL_FALSE;
11896
 
11897
  r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;
11898
  r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;
11899
  r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;
11900
  r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;
11901
 
11902
  return r;
11903
}
11904
 
11905
#endif /* GLX_EXT_import_context */
11906
 
11907
#ifdef GLX_EXT_scene_marker
11908
 
11909
#endif /* GLX_EXT_scene_marker */
11910
 
11911
#ifdef GLX_EXT_swap_control
11912
 
11913
static GLboolean _glewInit_GLX_EXT_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
11914
{
11915
  GLboolean r = GL_FALSE;
11916
 
11917
  r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r;
11918
 
11919
  return r;
11920
}
11921
 
11922
#endif /* GLX_EXT_swap_control */
11923
 
11924
#ifdef GLX_EXT_swap_control_tear
11925
 
11926
#endif /* GLX_EXT_swap_control_tear */
11927
 
11928
#ifdef GLX_EXT_texture_from_pixmap
11929
 
11930
static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT)
11931
{
11932
  GLboolean r = GL_FALSE;
11933
 
11934
  r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r;
11935
  r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r;
11936
 
11937
  return r;
11938
}
11939
 
11940
#endif /* GLX_EXT_texture_from_pixmap */
11941
 
11942
#ifdef GLX_EXT_visual_info
11943
 
11944
#endif /* GLX_EXT_visual_info */
11945
 
11946
#ifdef GLX_EXT_visual_rating
11947
 
11948
#endif /* GLX_EXT_visual_rating */
11949
 
11950
#ifdef GLX_INTEL_swap_event
11951
 
11952
#endif /* GLX_INTEL_swap_event */
11953
 
11954
#ifdef GLX_MESA_agp_offset
11955
 
11956
static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)
11957
{
11958
  GLboolean r = GL_FALSE;
11959
 
11960
  r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;
11961
 
11962
  return r;
11963
}
11964
 
11965
#endif /* GLX_MESA_agp_offset */
11966
 
11967
#ifdef GLX_MESA_copy_sub_buffer
11968
 
11969
static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT)
11970
{
11971
  GLboolean r = GL_FALSE;
11972
 
11973
  r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;
11974
 
11975
  return r;
11976
}
11977
 
11978
#endif /* GLX_MESA_copy_sub_buffer */
11979
 
11980
#ifdef GLX_MESA_pixmap_colormap
11981
 
11982
static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT)
11983
{
11984
  GLboolean r = GL_FALSE;
11985
 
11986
  r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;
11987
 
11988
  return r;
11989
}
11990
 
11991
#endif /* GLX_MESA_pixmap_colormap */
11992
 
11993
#ifdef GLX_MESA_release_buffers
11994
 
11995
static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT)
11996
{
11997
  GLboolean r = GL_FALSE;
11998
 
11999
  r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;
12000
 
12001
  return r;
12002
}
12003
 
12004
#endif /* GLX_MESA_release_buffers */
12005
 
12006
#ifdef GLX_MESA_set_3dfx_mode
12007
 
12008
static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)
12009
{
12010
  GLboolean r = GL_FALSE;
12011
 
12012
  r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;
12013
 
12014
  return r;
12015
}
12016
 
12017
#endif /* GLX_MESA_set_3dfx_mode */
12018
 
12019
#ifdef GLX_MESA_swap_control
12020
 
12021
static GLboolean _glewInit_GLX_MESA_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
12022
{
12023
  GLboolean r = GL_FALSE;
12024
 
12025
  r = ((glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetSwapIntervalMESA")) == NULL) || r;
12026
  r = ((glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalMESA")) == NULL) || r;
12027
 
12028
  return r;
12029
}
12030
 
12031
#endif /* GLX_MESA_swap_control */
12032
 
12033
#ifdef GLX_NV_copy_image
12034
 
12035
static GLboolean _glewInit_GLX_NV_copy_image (GLXEW_CONTEXT_ARG_DEF_INIT)
12036
{
12037
  GLboolean r = GL_FALSE;
12038
 
12039
  r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r;
12040
 
12041
  return r;
12042
}
12043
 
12044
#endif /* GLX_NV_copy_image */
12045
 
12046
#ifdef GLX_NV_float_buffer
12047
 
12048
#endif /* GLX_NV_float_buffer */
12049
 
12050
#ifdef GLX_NV_multisample_coverage
12051
 
12052
#endif /* GLX_NV_multisample_coverage */
12053
 
12054
#ifdef GLX_NV_present_video
12055
 
12056
static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT)
12057
{
12058
  GLboolean r = GL_FALSE;
12059
 
12060
  r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;
12061
  r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r;
12062
 
12063
  return r;
12064
}
12065
 
12066
#endif /* GLX_NV_present_video */
12067
 
12068
#ifdef GLX_NV_swap_group
12069
 
12070
static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)
12071
{
12072
  GLboolean r = GL_FALSE;
12073
 
12074
  r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r;
12075
  r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r;
12076
  r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r;
12077
  r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r;
12078
  r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r;
12079
  r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r;
12080
 
12081
  return r;
12082
}
12083
 
12084
#endif /* GLX_NV_swap_group */
12085
 
12086
#ifdef GLX_NV_vertex_array_range
12087
 
12088
static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT)
12089
{
12090
  GLboolean r = GL_FALSE;
12091
 
12092
  r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;
12093
  r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;
12094
 
12095
  return r;
12096
}
12097
 
12098
#endif /* GLX_NV_vertex_array_range */
12099
 
12100
#ifdef GLX_NV_video_capture
12101
 
12102
static GLboolean _glewInit_GLX_NV_video_capture (GLXEW_CONTEXT_ARG_DEF_INIT)
12103
{
12104
  GLboolean r = GL_FALSE;
12105
 
12106
  r = ((glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoCaptureDeviceNV")) == NULL) || r;
12107
  r = ((glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoCaptureDevicesNV")) == NULL) || r;
12108
  r = ((glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXLockVideoCaptureDeviceNV")) == NULL) || r;
12109
  r = ((glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXQueryVideoCaptureDeviceNV")) == NULL) || r;
12110
  r = ((glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoCaptureDeviceNV")) == NULL) || r;
12111
 
12112
  return r;
12113
}
12114
 
12115
#endif /* GLX_NV_video_capture */
12116
 
12117
#ifdef GLX_NV_video_out
12118
 
12119
static GLboolean _glewInit_GLX_NV_video_out (GLXEW_CONTEXT_ARG_DEF_INIT)
12120
{
12121
  GLboolean r = GL_FALSE;
12122
 
12123
  r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r;
12124
  r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r;
12125
  r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r;
12126
  r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r;
12127
  r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r;
12128
  r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r;
12129
 
12130
  return r;
12131
}
12132
 
12133
#endif /* GLX_NV_video_out */
12134
 
12135
#ifdef GLX_OML_swap_method
12136
 
12137
#endif /* GLX_OML_swap_method */
12138
 
12139
#ifdef GLX_OML_sync_control
12140
 
12141
static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT)
12142
{
12143
  GLboolean r = GL_FALSE;
12144
 
12145
  r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;
12146
  r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;
12147
  r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;
12148
  r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;
12149
  r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;
12150
 
12151
  return r;
12152
}
12153
 
12154
#endif /* GLX_OML_sync_control */
12155
 
12156
#ifdef GLX_SGIS_blended_overlay
12157
 
12158
#endif /* GLX_SGIS_blended_overlay */
12159
 
12160
#ifdef GLX_SGIS_color_range
12161
 
12162
#endif /* GLX_SGIS_color_range */
12163
 
12164
#ifdef GLX_SGIS_multisample
12165
 
12166
#endif /* GLX_SGIS_multisample */
12167
 
12168
#ifdef GLX_SGIS_shared_multisample
12169
 
12170
#endif /* GLX_SGIS_shared_multisample */
12171
 
12172
#ifdef GLX_SGIX_fbconfig
12173
 
12174
static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT)
12175
{
12176
  GLboolean r = GL_FALSE;
12177
 
12178
  r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;
12179
  r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;
12180
  r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;
12181
  r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;
12182
  r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;
12183
  r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;
12184
 
12185
  return r;
12186
}
12187
 
12188
#endif /* GLX_SGIX_fbconfig */
12189
 
12190
#ifdef GLX_SGIX_hyperpipe
12191
 
12192
static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT)
12193
{
12194
  GLboolean r = GL_FALSE;
12195
 
12196
  r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r;
12197
  r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r;
12198
  r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r;
12199
  r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r;
12200
  r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r;
12201
  r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r;
12202
  r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r;
12203
  r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r;
12204
 
12205
  return r;
12206
}
12207
 
12208
#endif /* GLX_SGIX_hyperpipe */
12209
 
12210
#ifdef GLX_SGIX_pbuffer
12211
 
12212
static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT)
12213
{
12214
  GLboolean r = GL_FALSE;
12215
 
12216
  r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;
12217
  r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;
12218
  r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;
12219
  r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;
12220
  r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;
12221
 
12222
  return r;
12223
}
12224
 
12225
#endif /* GLX_SGIX_pbuffer */
12226
 
12227
#ifdef GLX_SGIX_swap_barrier
12228
 
12229
static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT)
12230
{
12231
  GLboolean r = GL_FALSE;
12232
 
12233
  r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;
12234
  r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;
12235
 
12236
  return r;
12237
}
12238
 
12239
#endif /* GLX_SGIX_swap_barrier */
12240
 
12241
#ifdef GLX_SGIX_swap_group
12242
 
12243
static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)
12244
{
12245
  GLboolean r = GL_FALSE;
12246
 
12247
  r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;
12248
 
12249
  return r;
12250
}
12251
 
12252
#endif /* GLX_SGIX_swap_group */
12253
 
12254
#ifdef GLX_SGIX_video_resize
12255
 
12256
static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)
12257
{
12258
  GLboolean r = GL_FALSE;
12259
 
12260
  r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;
12261
  r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;
12262
  r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;
12263
  r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;
12264
  r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;
12265
 
12266
  return r;
12267
}
12268
 
12269
#endif /* GLX_SGIX_video_resize */
12270
 
12271
#ifdef GLX_SGIX_visual_select_group
12272
 
12273
#endif /* GLX_SGIX_visual_select_group */
12274
 
12275
#ifdef GLX_SGI_cushion
12276
 
12277
static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT)
12278
{
12279
  GLboolean r = GL_FALSE;
12280
 
12281
  r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;
12282
 
12283
  return r;
12284
}
12285
 
12286
#endif /* GLX_SGI_cushion */
12287
 
12288
#ifdef GLX_SGI_make_current_read
12289
 
12290
static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT)
12291
{
12292
  GLboolean r = GL_FALSE;
12293
 
12294
  r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;
12295
  r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;
12296
 
12297
  return r;
12298
}
12299
 
12300
#endif /* GLX_SGI_make_current_read */
12301
 
12302
#ifdef GLX_SGI_swap_control
12303
 
12304
static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
12305
{
12306
  GLboolean r = GL_FALSE;
12307
 
12308
  r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;
12309
 
12310
  return r;
12311
}
12312
 
12313
#endif /* GLX_SGI_swap_control */
12314
 
12315
#ifdef GLX_SGI_video_sync
12316
 
12317
static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT)
12318
{
12319
  GLboolean r = GL_FALSE;
12320
 
12321
  r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;
12322
  r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;
12323
 
12324
  return r;
12325
}
12326
 
12327
#endif /* GLX_SGI_video_sync */
12328
 
12329
#ifdef GLX_SUN_get_transparent_index
12330
 
12331
static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT)
12332
{
12333
  GLboolean r = GL_FALSE;
12334
 
12335
  r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;
12336
 
12337
  return r;
12338
}
12339
 
12340
#endif /* GLX_SUN_get_transparent_index */
12341
 
12342
#ifdef GLX_SUN_video_resize
12343
 
12344
static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)
12345
{
12346
  GLboolean r = GL_FALSE;
12347
 
12348
  r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;
12349
  r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;
12350
 
12351
  return r;
12352
}
12353
 
12354
#endif /* GLX_SUN_video_resize */
12355
 
12356
/* ------------------------------------------------------------------------ */
12357
 
12358
GLboolean glxewGetExtension (const char* name)
12359
{    
12360
  const GLubyte* start;
12361
  const GLubyte* end;
12362
 
12363
  if (glXGetCurrentDisplay == NULL) return GL_FALSE;
12364
  start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
12365
  if (0 == start) return GL_FALSE;
12366
  end = start + _glewStrLen(start);
12367
  return _glewSearchExtension(name, start, end);
12368
}
12369
 
12370
GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
12371
{
12372
  int major, minor;
12373
  const GLubyte* extStart;
12374
  const GLubyte* extEnd;
12375
  /* initialize core GLX 1.2 */
12376
  if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY;
12377
  /* initialize flags */
12378
  CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE;
12379
  CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE;
12380
  CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE;
12381
  CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE;
12382
  CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE;
12383
  /* query GLX version */
12384
  glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
12385
  if (major == 1 && minor <= 3)
12386
  {
12387
    switch (minor)
12388
    {
12389
      case 3:
12390
      CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;
12391
      break;
12392
      case 2:
12393
      CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;
12394
      CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE;
12395
      break;
12396
      default:
12397
      return GLEW_ERROR_GLX_VERSION_11_ONLY;
12398
      break;
12399
    }
12400
  }
12401
  /* query GLX extension string */
12402
  extStart = 0;
12403
  if (glXGetCurrentDisplay != NULL)
12404
    extStart = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
12405
  if (extStart == 0)
12406
    extStart = (const GLubyte *)"";
12407
  extEnd = extStart + _glewStrLen(extStart);
12408
  /* initialize extensions */
12409
#ifdef GLX_VERSION_1_3
12410
  if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
12411
#endif /* GLX_VERSION_1_3 */
12412
#ifdef GLX_3DFX_multisample
12413
  CONST_CAST(GLXEW_3DFX_multisample) = _glewSearchExtension("GLX_3DFX_multisample", extStart, extEnd);
12414
#endif /* GLX_3DFX_multisample */
12415
#ifdef GLX_AMD_gpu_association
12416
  CONST_CAST(GLXEW_AMD_gpu_association) = _glewSearchExtension("GLX_AMD_gpu_association", extStart, extEnd);
12417
#endif /* GLX_AMD_gpu_association */
12418
#ifdef GLX_ARB_create_context
12419
  CONST_CAST(GLXEW_ARB_create_context) = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd);
12420
  if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
12421
#endif /* GLX_ARB_create_context */
12422
#ifdef GLX_ARB_create_context_profile
12423
  CONST_CAST(GLXEW_ARB_create_context_profile) = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd);
12424
#endif /* GLX_ARB_create_context_profile */
12425
#ifdef GLX_ARB_create_context_robustness
12426
  CONST_CAST(GLXEW_ARB_create_context_robustness) = _glewSearchExtension("GLX_ARB_create_context_robustness", extStart, extEnd);
12427
#endif /* GLX_ARB_create_context_robustness */
12428
#ifdef GLX_ARB_fbconfig_float
12429
  CONST_CAST(GLXEW_ARB_fbconfig_float) = _glewSearchExtension("GLX_ARB_fbconfig_float", extStart, extEnd);
12430
#endif /* GLX_ARB_fbconfig_float */
12431
#ifdef GLX_ARB_framebuffer_sRGB
12432
  CONST_CAST(GLXEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GLX_ARB_framebuffer_sRGB", extStart, extEnd);
12433
#endif /* GLX_ARB_framebuffer_sRGB */
12434
#ifdef GLX_ARB_get_proc_address
12435
  CONST_CAST(GLXEW_ARB_get_proc_address) = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd);
12436
#endif /* GLX_ARB_get_proc_address */
12437
#ifdef GLX_ARB_multisample
12438
  CONST_CAST(GLXEW_ARB_multisample) = _glewSearchExtension("GLX_ARB_multisample", extStart, extEnd);
12439
#endif /* GLX_ARB_multisample */
12440
#ifdef GLX_ARB_robustness_application_isolation
12441
  CONST_CAST(GLXEW_ARB_robustness_application_isolation) = _glewSearchExtension("GLX_ARB_robustness_application_isolation", extStart, extEnd);
12442
#endif /* GLX_ARB_robustness_application_isolation */
12443
#ifdef GLX_ARB_robustness_share_group_isolation
12444
  CONST_CAST(GLXEW_ARB_robustness_share_group_isolation) = _glewSearchExtension("GLX_ARB_robustness_share_group_isolation", extStart, extEnd);
12445
#endif /* GLX_ARB_robustness_share_group_isolation */
12446
#ifdef GLX_ARB_vertex_buffer_object
12447
  CONST_CAST(GLXEW_ARB_vertex_buffer_object) = _glewSearchExtension("GLX_ARB_vertex_buffer_object", extStart, extEnd);
12448
#endif /* GLX_ARB_vertex_buffer_object */
12449
#ifdef GLX_ATI_pixel_format_float
12450
  CONST_CAST(GLXEW_ATI_pixel_format_float) = _glewSearchExtension("GLX_ATI_pixel_format_float", extStart, extEnd);
12451
#endif /* GLX_ATI_pixel_format_float */
12452
#ifdef GLX_ATI_render_texture
12453
  CONST_CAST(GLXEW_ATI_render_texture) = _glewSearchExtension("GLX_ATI_render_texture", extStart, extEnd);
12454
  if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
12455
#endif /* GLX_ATI_render_texture */
12456
#ifdef GLX_EXT_create_context_es2_profile
12457
  CONST_CAST(GLXEW_EXT_create_context_es2_profile) = _glewSearchExtension("GLX_EXT_create_context_es2_profile", extStart, extEnd);
12458
#endif /* GLX_EXT_create_context_es2_profile */
12459
#ifdef GLX_EXT_create_context_es_profile
12460
  CONST_CAST(GLXEW_EXT_create_context_es_profile) = _glewSearchExtension("GLX_EXT_create_context_es_profile", extStart, extEnd);
12461
#endif /* GLX_EXT_create_context_es_profile */
12462
#ifdef GLX_EXT_fbconfig_packed_float
12463
  CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = _glewSearchExtension("GLX_EXT_fbconfig_packed_float", extStart, extEnd);
12464
#endif /* GLX_EXT_fbconfig_packed_float */
12465
#ifdef GLX_EXT_framebuffer_sRGB
12466
  CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd);
12467
#endif /* GLX_EXT_framebuffer_sRGB */
12468
#ifdef GLX_EXT_import_context
12469
  CONST_CAST(GLXEW_EXT_import_context) = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd);
12470
  if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT);
12471
#endif /* GLX_EXT_import_context */
12472
#ifdef GLX_EXT_scene_marker
12473
  CONST_CAST(GLXEW_EXT_scene_marker) = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd);
12474
#endif /* GLX_EXT_scene_marker */
12475
#ifdef GLX_EXT_swap_control
12476
  CONST_CAST(GLXEW_EXT_swap_control) = _glewSearchExtension("GLX_EXT_swap_control", extStart, extEnd);
12477
  if (glewExperimental || GLXEW_EXT_swap_control) CONST_CAST(GLXEW_EXT_swap_control) = !_glewInit_GLX_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
12478
#endif /* GLX_EXT_swap_control */
12479
#ifdef GLX_EXT_swap_control_tear
12480
  CONST_CAST(GLXEW_EXT_swap_control_tear) = _glewSearchExtension("GLX_EXT_swap_control_tear", extStart, extEnd);
12481
#endif /* GLX_EXT_swap_control_tear */
12482
#ifdef GLX_EXT_texture_from_pixmap
12483
  CONST_CAST(GLXEW_EXT_texture_from_pixmap) = _glewSearchExtension("GLX_EXT_texture_from_pixmap", extStart, extEnd);
12484
  if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT);
12485
#endif /* GLX_EXT_texture_from_pixmap */
12486
#ifdef GLX_EXT_visual_info
12487
  CONST_CAST(GLXEW_EXT_visual_info) = _glewSearchExtension("GLX_EXT_visual_info", extStart, extEnd);
12488
#endif /* GLX_EXT_visual_info */
12489
#ifdef GLX_EXT_visual_rating
12490
  CONST_CAST(GLXEW_EXT_visual_rating) = _glewSearchExtension("GLX_EXT_visual_rating", extStart, extEnd);
12491
#endif /* GLX_EXT_visual_rating */
12492
#ifdef GLX_INTEL_swap_event
12493
  CONST_CAST(GLXEW_INTEL_swap_event) = _glewSearchExtension("GLX_INTEL_swap_event", extStart, extEnd);
12494
#endif /* GLX_INTEL_swap_event */
12495
#ifdef GLX_MESA_agp_offset
12496
  CONST_CAST(GLXEW_MESA_agp_offset) = _glewSearchExtension("GLX_MESA_agp_offset", extStart, extEnd);
12497
  if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);
12498
#endif /* GLX_MESA_agp_offset */
12499
#ifdef GLX_MESA_copy_sub_buffer
12500
  CONST_CAST(GLXEW_MESA_copy_sub_buffer) = _glewSearchExtension("GLX_MESA_copy_sub_buffer", extStart, extEnd);
12501
  if (glewExperimental || GLXEW_MESA_copy_sub_buffer) CONST_CAST(GLXEW_MESA_copy_sub_buffer) = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
12502
#endif /* GLX_MESA_copy_sub_buffer */
12503
#ifdef GLX_MESA_pixmap_colormap
12504
  CONST_CAST(GLXEW_MESA_pixmap_colormap) = _glewSearchExtension("GLX_MESA_pixmap_colormap", extStart, extEnd);
12505
  if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT);
12506
#endif /* GLX_MESA_pixmap_colormap */
12507
#ifdef GLX_MESA_release_buffers
12508
  CONST_CAST(GLXEW_MESA_release_buffers) = _glewSearchExtension("GLX_MESA_release_buffers", extStart, extEnd);
12509
  if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
12510
#endif /* GLX_MESA_release_buffers */
12511
#ifdef GLX_MESA_set_3dfx_mode
12512
  CONST_CAST(GLXEW_MESA_set_3dfx_mode) = _glewSearchExtension("GLX_MESA_set_3dfx_mode", extStart, extEnd);
12513
  if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT);
12514
#endif /* GLX_MESA_set_3dfx_mode */
12515
#ifdef GLX_MESA_swap_control
12516
  CONST_CAST(GLXEW_MESA_swap_control) = _glewSearchExtension("GLX_MESA_swap_control", extStart, extEnd);
12517
  if (glewExperimental || GLXEW_MESA_swap_control) CONST_CAST(GLXEW_MESA_swap_control) = !_glewInit_GLX_MESA_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
12518
#endif /* GLX_MESA_swap_control */
12519
#ifdef GLX_NV_copy_image
12520
  CONST_CAST(GLXEW_NV_copy_image) = _glewSearchExtension("GLX_NV_copy_image", extStart, extEnd);
12521
  if (glewExperimental || GLXEW_NV_copy_image) CONST_CAST(GLXEW_NV_copy_image) = !_glewInit_GLX_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
12522
#endif /* GLX_NV_copy_image */
12523
#ifdef GLX_NV_float_buffer
12524
  CONST_CAST(GLXEW_NV_float_buffer) = _glewSearchExtension("GLX_NV_float_buffer", extStart, extEnd);
12525
#endif /* GLX_NV_float_buffer */
12526
#ifdef GLX_NV_multisample_coverage
12527
  CONST_CAST(GLXEW_NV_multisample_coverage) = _glewSearchExtension("GLX_NV_multisample_coverage", extStart, extEnd);
12528
#endif /* GLX_NV_multisample_coverage */
12529
#ifdef GLX_NV_present_video
12530
  CONST_CAST(GLXEW_NV_present_video) = _glewSearchExtension("GLX_NV_present_video", extStart, extEnd);
12531
  if (glewExperimental || GLXEW_NV_present_video) CONST_CAST(GLXEW_NV_present_video) = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
12532
#endif /* GLX_NV_present_video */
12533
#ifdef GLX_NV_swap_group
12534
  CONST_CAST(GLXEW_NV_swap_group) = _glewSearchExtension("GLX_NV_swap_group", extStart, extEnd);
12535
  if (glewExperimental || GLXEW_NV_swap_group) CONST_CAST(GLXEW_NV_swap_group) = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
12536
#endif /* GLX_NV_swap_group */
12537
#ifdef GLX_NV_vertex_array_range
12538
  CONST_CAST(GLXEW_NV_vertex_array_range) = _glewSearchExtension("GLX_NV_vertex_array_range", extStart, extEnd);
12539
  if (glewExperimental || GLXEW_NV_vertex_array_range) CONST_CAST(GLXEW_NV_vertex_array_range) = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
12540
#endif /* GLX_NV_vertex_array_range */
12541
#ifdef GLX_NV_video_capture
12542
  CONST_CAST(GLXEW_NV_video_capture) = _glewSearchExtension("GLX_NV_video_capture", extStart, extEnd);
12543
  if (glewExperimental || GLXEW_NV_video_capture) CONST_CAST(GLXEW_NV_video_capture) = !_glewInit_GLX_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
12544
#endif /* GLX_NV_video_capture */
12545
#ifdef GLX_NV_video_out
12546
  CONST_CAST(GLXEW_NV_video_out) = _glewSearchExtension("GLX_NV_video_out", extStart, extEnd);
12547
  if (glewExperimental || GLXEW_NV_video_out) CONST_CAST(GLXEW_NV_video_out) = !_glewInit_GLX_NV_video_out(GLEW_CONTEXT_ARG_VAR_INIT);
12548
#endif /* GLX_NV_video_out */
12549
#ifdef GLX_OML_swap_method
12550
  CONST_CAST(GLXEW_OML_swap_method) = _glewSearchExtension("GLX_OML_swap_method", extStart, extEnd);
12551
#endif /* GLX_OML_swap_method */
12552
#ifdef GLX_OML_sync_control
12553
  CONST_CAST(GLXEW_OML_sync_control) = _glewSearchExtension("GLX_OML_sync_control", extStart, extEnd);
12554
  if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);
12555
#endif /* GLX_OML_sync_control */
12556
#ifdef GLX_SGIS_blended_overlay
12557
  CONST_CAST(GLXEW_SGIS_blended_overlay) = _glewSearchExtension("GLX_SGIS_blended_overlay", extStart, extEnd);
12558
#endif /* GLX_SGIS_blended_overlay */
12559
#ifdef GLX_SGIS_color_range
12560
  CONST_CAST(GLXEW_SGIS_color_range) = _glewSearchExtension("GLX_SGIS_color_range", extStart, extEnd);
12561
#endif /* GLX_SGIS_color_range */
12562
#ifdef GLX_SGIS_multisample
12563
  CONST_CAST(GLXEW_SGIS_multisample) = _glewSearchExtension("GLX_SGIS_multisample", extStart, extEnd);
12564
#endif /* GLX_SGIS_multisample */
12565
#ifdef GLX_SGIS_shared_multisample
12566
  CONST_CAST(GLXEW_SGIS_shared_multisample) = _glewSearchExtension("GLX_SGIS_shared_multisample", extStart, extEnd);
12567
#endif /* GLX_SGIS_shared_multisample */
12568
#ifdef GLX_SGIX_fbconfig
12569
  CONST_CAST(GLXEW_SGIX_fbconfig) = _glewSearchExtension("GLX_SGIX_fbconfig", extStart, extEnd);
12570
  if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT);
12571
#endif /* GLX_SGIX_fbconfig */
12572
#ifdef GLX_SGIX_hyperpipe
12573
  CONST_CAST(GLXEW_SGIX_hyperpipe) = _glewSearchExtension("GLX_SGIX_hyperpipe", extStart, extEnd);
12574
  if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT);
12575
#endif /* GLX_SGIX_hyperpipe */
12576
#ifdef GLX_SGIX_pbuffer
12577
  CONST_CAST(GLXEW_SGIX_pbuffer) = _glewSearchExtension("GLX_SGIX_pbuffer", extStart, extEnd);
12578
  if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
12579
#endif /* GLX_SGIX_pbuffer */
12580
#ifdef GLX_SGIX_swap_barrier
12581
  CONST_CAST(GLXEW_SGIX_swap_barrier) = _glewSearchExtension("GLX_SGIX_swap_barrier", extStart, extEnd);
12582
  if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
12583
#endif /* GLX_SGIX_swap_barrier */
12584
#ifdef GLX_SGIX_swap_group
12585
  CONST_CAST(GLXEW_SGIX_swap_group) = _glewSearchExtension("GLX_SGIX_swap_group", extStart, extEnd);
12586
  if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
12587
#endif /* GLX_SGIX_swap_group */
12588
#ifdef GLX_SGIX_video_resize
12589
  CONST_CAST(GLXEW_SGIX_video_resize) = _glewSearchExtension("GLX_SGIX_video_resize", extStart, extEnd);
12590
  if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);
12591
#endif /* GLX_SGIX_video_resize */
12592
#ifdef GLX_SGIX_visual_select_group
12593
  CONST_CAST(GLXEW_SGIX_visual_select_group) = _glewSearchExtension("GLX_SGIX_visual_select_group", extStart, extEnd);
12594
#endif /* GLX_SGIX_visual_select_group */
12595
#ifdef GLX_SGI_cushion
12596
  CONST_CAST(GLXEW_SGI_cushion) = _glewSearchExtension("GLX_SGI_cushion", extStart, extEnd);
12597
  if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT);
12598
#endif /* GLX_SGI_cushion */
12599
#ifdef GLX_SGI_make_current_read
12600
  CONST_CAST(GLXEW_SGI_make_current_read) = _glewSearchExtension("GLX_SGI_make_current_read", extStart, extEnd);
12601
  if (glewExperimental || GLXEW_SGI_make_current_read) CONST_CAST(GLXEW_SGI_make_current_read) = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);
12602
#endif /* GLX_SGI_make_current_read */
12603
#ifdef GLX_SGI_swap_control
12604
  CONST_CAST(GLXEW_SGI_swap_control) = _glewSearchExtension("GLX_SGI_swap_control", extStart, extEnd);
12605
  if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
12606
#endif /* GLX_SGI_swap_control */
12607
#ifdef GLX_SGI_video_sync
12608
  CONST_CAST(GLXEW_SGI_video_sync) = _glewSearchExtension("GLX_SGI_video_sync", extStart, extEnd);
12609
  if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT);
12610
#endif /* GLX_SGI_video_sync */
12611
#ifdef GLX_SUN_get_transparent_index
12612
  CONST_CAST(GLXEW_SUN_get_transparent_index) = _glewSearchExtension("GLX_SUN_get_transparent_index", extStart, extEnd);
12613
  if (glewExperimental || GLXEW_SUN_get_transparent_index) CONST_CAST(GLXEW_SUN_get_transparent_index) = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT);
12614
#endif /* GLX_SUN_get_transparent_index */
12615
#ifdef GLX_SUN_video_resize
12616
  CONST_CAST(GLXEW_SUN_video_resize) = _glewSearchExtension("GLX_SUN_video_resize", extStart, extEnd);
12617
  if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);
12618
#endif /* GLX_SUN_video_resize */
12619
 
12620
  return GLEW_OK;
12621
}
12622
 
12623
#endif /* !defined(__ANDROID__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) */
12624
 
12625
/* ------------------------------------------------------------------------ */
12626
 
12627
const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error)
12628
{
12629
  static const GLubyte* _glewErrorString[] =
12630
  {
12631
    (const GLubyte*)"No error",
12632
    (const GLubyte*)"Missing GL version",
12633
    (const GLubyte*)"GL 1.1 and up are not supported",
12634
    (const GLubyte*)"GLX 1.2 and up are not supported",
12635
    (const GLubyte*)"Unknown error"
12636
  };
12637
  const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;
12638
  return _glewErrorString[(int)error > max_error ? max_error : (int)error];
12639
}
12640
 
12641
const GLubyte * GLEWAPIENTRY glewGetString (GLenum name)
12642
{
12643
  static const GLubyte* _glewString[] =
12644
  {
12645
    (const GLubyte*)NULL,
12646
    (const GLubyte*)"1.9.0",
12647
    (const GLubyte*)"1",
12648
    (const GLubyte*)"9",
12649
    (const GLubyte*)"0"
12650
  };
12651
  const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;
12652
  return _glewString[(int)name > max_string ? 0 : (int)name];
12653
}
12654
 
12655
/* ------------------------------------------------------------------------ */
12656
 
12657
GLboolean glewExperimental = GL_FALSE;
12658
 
12659
#if !defined(GLEW_MX)
12660
 
12661
#if defined(_WIN32)
12662
extern GLenum GLEWAPIENTRY wglewContextInit (void);
12663
#elif !defined(__ANDROID__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))
12664
extern GLenum GLEWAPIENTRY glxewContextInit (void);
12665
#endif /* _WIN32 */
12666
 
12667
GLenum GLEWAPIENTRY glewInit (void)
12668
{
12669
  GLenum r;
12670
  r = glewContextInit();
12671
  if ( r != 0 ) return r;
12672
#if defined(_WIN32)
12673
  return wglewContextInit();
12674
#elif !defined(__ANDROID__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) /* _UNIX */
12675
  return glxewContextInit();
12676
#else
12677
  return r;
12678
#endif /* _WIN32 */
12679
}
12680
 
12681
#endif /* !GLEW_MX */
12682
#ifdef GLEW_MX
12683
GLboolean GLEWAPIENTRY glewContextIsSupported (const GLEWContext* ctx, const char* name)
12684
#else
12685
GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
12686
#endif
12687
{
12688
  GLubyte* pos = (GLubyte*)name;
12689
  GLuint len = _glewStrLen(pos);
12690
  GLboolean ret = GL_TRUE;
12691
  while (ret && len > 0)
12692
  {
12693
    if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))
12694
    {
12695
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))
12696
      {
12697
#ifdef GL_VERSION_1_2
12698
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))
12699
        {
12700
          ret = GLEW_VERSION_1_2;
12701
          continue;
12702
        }
12703
#endif
12704
#ifdef GL_VERSION_1_2_1
12705
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5))
12706
        {
12707
          ret = GLEW_VERSION_1_2_1;
12708
          continue;
12709
        }
12710
#endif
12711
#ifdef GL_VERSION_1_3
12712
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))
12713
        {
12714
          ret = GLEW_VERSION_1_3;
12715
          continue;
12716
        }
12717
#endif
12718
#ifdef GL_VERSION_1_4
12719
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))
12720
        {
12721
          ret = GLEW_VERSION_1_4;
12722
          continue;
12723
        }
12724
#endif
12725
#ifdef GL_VERSION_1_5
12726
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))
12727
        {
12728
          ret = GLEW_VERSION_1_5;
12729
          continue;
12730
        }
12731
#endif
12732
#ifdef GL_VERSION_2_0
12733
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))
12734
        {
12735
          ret = GLEW_VERSION_2_0;
12736
          continue;
12737
        }
12738
#endif
12739
#ifdef GL_VERSION_2_1
12740
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3))
12741
        {
12742
          ret = GLEW_VERSION_2_1;
12743
          continue;
12744
        }
12745
#endif
12746
#ifdef GL_VERSION_3_0
12747
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3))
12748
        {
12749
          ret = GLEW_VERSION_3_0;
12750
          continue;
12751
        }
12752
#endif
12753
#ifdef GL_VERSION_3_1
12754
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3))
12755
        {
12756
          ret = GLEW_VERSION_3_1;
12757
          continue;
12758
        }
12759
#endif
12760
#ifdef GL_VERSION_3_2
12761
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3))
12762
        {
12763
          ret = GLEW_VERSION_3_2;
12764
          continue;
12765
        }
12766
#endif
12767
#ifdef GL_VERSION_3_3
12768
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3))
12769
        {
12770
          ret = GLEW_VERSION_3_3;
12771
          continue;
12772
        }
12773
#endif
12774
#ifdef GL_VERSION_4_0
12775
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3))
12776
        {
12777
          ret = GLEW_VERSION_4_0;
12778
          continue;
12779
        }
12780
#endif
12781
#ifdef GL_VERSION_4_1
12782
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3))
12783
        {
12784
          ret = GLEW_VERSION_4_1;
12785
          continue;
12786
        }
12787
#endif
12788
#ifdef GL_VERSION_4_2
12789
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3))
12790
        {
12791
          ret = GLEW_VERSION_4_2;
12792
          continue;
12793
        }
12794
#endif
12795
#ifdef GL_VERSION_4_3
12796
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_3", 3))
12797
        {
12798
          ret = GLEW_VERSION_4_3;
12799
          continue;
12800
        }
12801
#endif
12802
      }
12803
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
12804
      {
12805
#ifdef GL_3DFX_multisample
12806
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
12807
        {
12808
          ret = GLEW_3DFX_multisample;
12809
          continue;
12810
        }
12811
#endif
12812
#ifdef GL_3DFX_tbuffer
12813
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))
12814
        {
12815
          ret = GLEW_3DFX_tbuffer;
12816
          continue;
12817
        }
12818
#endif
12819
#ifdef GL_3DFX_texture_compression_FXT1
12820
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))
12821
        {
12822
          ret = GLEW_3DFX_texture_compression_FXT1;
12823
          continue;
12824
        }
12825
#endif
12826
      }
12827
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
12828
      {
12829
#ifdef GL_AMD_blend_minmax_factor
12830
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19))
12831
        {
12832
          ret = GLEW_AMD_blend_minmax_factor;
12833
          continue;
12834
        }
12835
#endif
12836
#ifdef GL_AMD_conservative_depth
12837
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
12838
        {
12839
          ret = GLEW_AMD_conservative_depth;
12840
          continue;
12841
        }
12842
#endif
12843
#ifdef GL_AMD_debug_output
12844
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))
12845
        {
12846
          ret = GLEW_AMD_debug_output;
12847
          continue;
12848
        }
12849
#endif
12850
#ifdef GL_AMD_depth_clamp_separate
12851
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp_separate", 20))
12852
        {
12853
          ret = GLEW_AMD_depth_clamp_separate;
12854
          continue;
12855
        }
12856
#endif
12857
#ifdef GL_AMD_draw_buffers_blend
12858
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
12859
        {
12860
          ret = GLEW_AMD_draw_buffers_blend;
12861
          continue;
12862
        }
12863
#endif
12864
#ifdef GL_AMD_multi_draw_indirect
12865
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))
12866
        {
12867
          ret = GLEW_AMD_multi_draw_indirect;
12868
          continue;
12869
        }
12870
#endif
12871
#ifdef GL_AMD_name_gen_delete
12872
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"name_gen_delete", 15))
12873
        {
12874
          ret = GLEW_AMD_name_gen_delete;
12875
          continue;
12876
        }
12877
#endif
12878
#ifdef GL_AMD_performance_monitor
12879
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19))
12880
        {
12881
          ret = GLEW_AMD_performance_monitor;
12882
          continue;
12883
        }
12884
#endif
12885
#ifdef GL_AMD_pinned_memory
12886
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pinned_memory", 13))
12887
        {
12888
          ret = GLEW_AMD_pinned_memory;
12889
          continue;
12890
        }
12891
#endif
12892
#ifdef GL_AMD_query_buffer_object
12893
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19))
12894
        {
12895
          ret = GLEW_AMD_query_buffer_object;
12896
          continue;
12897
        }
12898
#endif
12899
#ifdef GL_AMD_sample_positions
12900
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_positions", 16))
12901
        {
12902
          ret = GLEW_AMD_sample_positions;
12903
          continue;
12904
        }
12905
#endif
12906
#ifdef GL_AMD_seamless_cubemap_per_texture
12907
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))
12908
        {
12909
          ret = GLEW_AMD_seamless_cubemap_per_texture;
12910
          continue;
12911
        }
12912
#endif
12913
#ifdef GL_AMD_shader_stencil_export
12914
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
12915
        {
12916
          ret = GLEW_AMD_shader_stencil_export;
12917
          continue;
12918
        }
12919
#endif
12920
#ifdef GL_AMD_stencil_operation_extended
12921
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_operation_extended", 26))
12922
        {
12923
          ret = GLEW_AMD_stencil_operation_extended;
12924
          continue;
12925
        }
12926
#endif
12927
#ifdef GL_AMD_texture_texture4
12928
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16))
12929
        {
12930
          ret = GLEW_AMD_texture_texture4;
12931
          continue;
12932
        }
12933
#endif
12934
#ifdef GL_AMD_transform_feedback3_lines_triangles
12935
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3_lines_triangles", 35))
12936
        {
12937
          ret = GLEW_AMD_transform_feedback3_lines_triangles;
12938
          continue;
12939
        }
12940
#endif
12941
#ifdef GL_AMD_vertex_shader_layer
12942
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_layer", 19))
12943
        {
12944
          ret = GLEW_AMD_vertex_shader_layer;
12945
          continue;
12946
        }
12947
#endif
12948
#ifdef GL_AMD_vertex_shader_tessellator
12949
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25))
12950
        {
12951
          ret = GLEW_AMD_vertex_shader_tessellator;
12952
          continue;
12953
        }
12954
#endif
12955
#ifdef GL_AMD_vertex_shader_viewport_index
12956
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_viewport_index", 28))
12957
        {
12958
          ret = GLEW_AMD_vertex_shader_viewport_index;
12959
          continue;
12960
        }
12961
#endif
12962
      }
12963
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))
12964
      {
12965
#ifdef GL_APPLE_aux_depth_stencil
12966
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17))
12967
        {
12968
          ret = GLEW_APPLE_aux_depth_stencil;
12969
          continue;
12970
        }
12971
#endif
12972
#ifdef GL_APPLE_client_storage
12973
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))
12974
        {
12975
          ret = GLEW_APPLE_client_storage;
12976
          continue;
12977
        }
12978
#endif
12979
#ifdef GL_APPLE_element_array
12980
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))
12981
        {
12982
          ret = GLEW_APPLE_element_array;
12983
          continue;
12984
        }
12985
#endif
12986
#ifdef GL_APPLE_fence
12987
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))
12988
        {
12989
          ret = GLEW_APPLE_fence;
12990
          continue;
12991
        }
12992
#endif
12993
#ifdef GL_APPLE_float_pixels
12994
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))
12995
        {
12996
          ret = GLEW_APPLE_float_pixels;
12997
          continue;
12998
        }
12999
#endif
13000
#ifdef GL_APPLE_flush_buffer_range
13001
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18))
13002
        {
13003
          ret = GLEW_APPLE_flush_buffer_range;
13004
          continue;
13005
        }
13006
#endif
13007
#ifdef GL_APPLE_object_purgeable
13008
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16))
13009
        {
13010
          ret = GLEW_APPLE_object_purgeable;
13011
          continue;
13012
        }
13013
#endif
13014
#ifdef GL_APPLE_pixel_buffer
13015
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))
13016
        {
13017
          ret = GLEW_APPLE_pixel_buffer;
13018
          continue;
13019
        }
13020
#endif
13021
#ifdef GL_APPLE_rgb_422
13022
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7))
13023
        {
13024
          ret = GLEW_APPLE_rgb_422;
13025
          continue;
13026
        }
13027
#endif
13028
#ifdef GL_APPLE_row_bytes
13029
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9))
13030
        {
13031
          ret = GLEW_APPLE_row_bytes;
13032
          continue;
13033
        }
13034
#endif
13035
#ifdef GL_APPLE_specular_vector
13036
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))
13037
        {
13038
          ret = GLEW_APPLE_specular_vector;
13039
          continue;
13040
        }
13041
#endif
13042
#ifdef GL_APPLE_texture_range
13043
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))
13044
        {
13045
          ret = GLEW_APPLE_texture_range;
13046
          continue;
13047
        }
13048
#endif
13049
#ifdef GL_APPLE_transform_hint
13050
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))
13051
        {
13052
          ret = GLEW_APPLE_transform_hint;
13053
          continue;
13054
        }
13055
#endif
13056
#ifdef GL_APPLE_vertex_array_object
13057
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
13058
        {
13059
          ret = GLEW_APPLE_vertex_array_object;
13060
          continue;
13061
        }
13062
#endif
13063
#ifdef GL_APPLE_vertex_array_range
13064
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
13065
        {
13066
          ret = GLEW_APPLE_vertex_array_range;
13067
          continue;
13068
        }
13069
#endif
13070
#ifdef GL_APPLE_vertex_program_evaluators
13071
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25))
13072
        {
13073
          ret = GLEW_APPLE_vertex_program_evaluators;
13074
          continue;
13075
        }
13076
#endif
13077
#ifdef GL_APPLE_ycbcr_422
13078
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))
13079
        {
13080
          ret = GLEW_APPLE_ycbcr_422;
13081
          continue;
13082
        }
13083
#endif
13084
      }
13085
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
13086
      {
13087
#ifdef GL_ARB_ES2_compatibility
13088
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES2_compatibility", 17))
13089
        {
13090
          ret = GLEW_ARB_ES2_compatibility;
13091
          continue;
13092
        }
13093
#endif
13094
#ifdef GL_ARB_ES3_compatibility
13095
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_compatibility", 17))
13096
        {
13097
          ret = GLEW_ARB_ES3_compatibility;
13098
          continue;
13099
        }
13100
#endif
13101
#ifdef GL_ARB_arrays_of_arrays
13102
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"arrays_of_arrays", 16))
13103
        {
13104
          ret = GLEW_ARB_arrays_of_arrays;
13105
          continue;
13106
        }
13107
#endif
13108
#ifdef GL_ARB_base_instance
13109
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13))
13110
        {
13111
          ret = GLEW_ARB_base_instance;
13112
          continue;
13113
        }
13114
#endif
13115
#ifdef GL_ARB_blend_func_extended
13116
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19))
13117
        {
13118
          ret = GLEW_ARB_blend_func_extended;
13119
          continue;
13120
        }
13121
#endif
13122
#ifdef GL_ARB_cl_event
13123
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8))
13124
        {
13125
          ret = GLEW_ARB_cl_event;
13126
          continue;
13127
        }
13128
#endif
13129
#ifdef GL_ARB_clear_buffer_object
13130
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_buffer_object", 19))
13131
        {
13132
          ret = GLEW_ARB_clear_buffer_object;
13133
          continue;
13134
        }
13135
#endif
13136
#ifdef GL_ARB_color_buffer_float
13137
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))
13138
        {
13139
          ret = GLEW_ARB_color_buffer_float;
13140
          continue;
13141
        }
13142
#endif
13143
#ifdef GL_ARB_compatibility
13144
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13))
13145
        {
13146
          ret = GLEW_ARB_compatibility;
13147
          continue;
13148
        }
13149
#endif
13150
#ifdef GL_ARB_compressed_texture_pixel_storage
13151
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_texture_pixel_storage", 32))
13152
        {
13153
          ret = GLEW_ARB_compressed_texture_pixel_storage;
13154
          continue;
13155
        }
13156
#endif
13157
#ifdef GL_ARB_compute_shader
13158
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_shader", 14))
13159
        {
13160
          ret = GLEW_ARB_compute_shader;
13161
          continue;
13162
        }
13163
#endif
13164
#ifdef GL_ARB_conservative_depth
13165
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
13166
        {
13167
          ret = GLEW_ARB_conservative_depth;
13168
          continue;
13169
        }
13170
#endif
13171
#ifdef GL_ARB_copy_buffer
13172
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))
13173
        {
13174
          ret = GLEW_ARB_copy_buffer;
13175
          continue;
13176
        }
13177
#endif
13178
#ifdef GL_ARB_copy_image
13179
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
13180
        {
13181
          ret = GLEW_ARB_copy_image;
13182
          continue;
13183
        }
13184
#endif
13185
#ifdef GL_ARB_debug_output
13186
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))
13187
        {
13188
          ret = GLEW_ARB_debug_output;
13189
          continue;
13190
        }
13191
#endif
13192
#ifdef GL_ARB_depth_buffer_float
13193
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
13194
        {
13195
          ret = GLEW_ARB_depth_buffer_float;
13196
          continue;
13197
        }
13198
#endif
13199
#ifdef GL_ARB_depth_clamp
13200
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
13201
        {
13202
          ret = GLEW_ARB_depth_clamp;
13203
          continue;
13204
        }
13205
#endif
13206
#ifdef GL_ARB_depth_texture
13207
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
13208
        {
13209
          ret = GLEW_ARB_depth_texture;
13210
          continue;
13211
        }
13212
#endif
13213
#ifdef GL_ARB_draw_buffers
13214
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))
13215
        {
13216
          ret = GLEW_ARB_draw_buffers;
13217
          continue;
13218
        }
13219
#endif
13220
#ifdef GL_ARB_draw_buffers_blend
13221
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
13222
        {
13223
          ret = GLEW_ARB_draw_buffers_blend;
13224
          continue;
13225
        }
13226
#endif
13227
#ifdef GL_ARB_draw_elements_base_vertex
13228
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25))
13229
        {
13230
          ret = GLEW_ARB_draw_elements_base_vertex;
13231
          continue;
13232
        }
13233
#endif
13234
#ifdef GL_ARB_draw_indirect
13235
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13))
13236
        {
13237
          ret = GLEW_ARB_draw_indirect;
13238
          continue;
13239
        }
13240
#endif
13241
#ifdef GL_ARB_draw_instanced
13242
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
13243
        {
13244
          ret = GLEW_ARB_draw_instanced;
13245
          continue;
13246
        }
13247
#endif
13248
#ifdef GL_ARB_explicit_attrib_location
13249
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24))
13250
        {
13251
          ret = GLEW_ARB_explicit_attrib_location;
13252
          continue;
13253
        }
13254
#endif
13255
#ifdef GL_ARB_explicit_uniform_location
13256
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_uniform_location", 25))
13257
        {
13258
          ret = GLEW_ARB_explicit_uniform_location;
13259
          continue;
13260
        }
13261
#endif
13262
#ifdef GL_ARB_fragment_coord_conventions
13263
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26))
13264
        {
13265
          ret = GLEW_ARB_fragment_coord_conventions;
13266
          continue;
13267
        }
13268
#endif
13269
#ifdef GL_ARB_fragment_layer_viewport
13270
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_layer_viewport", 23))
13271
        {
13272
          ret = GLEW_ARB_fragment_layer_viewport;
13273
          continue;
13274
        }
13275
#endif
13276
#ifdef GL_ARB_fragment_program
13277
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
13278
        {
13279
          ret = GLEW_ARB_fragment_program;
13280
          continue;
13281
        }
13282
#endif
13283
#ifdef GL_ARB_fragment_program_shadow
13284
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))
13285
        {
13286
          ret = GLEW_ARB_fragment_program_shadow;
13287
          continue;
13288
        }
13289
#endif
13290
#ifdef GL_ARB_fragment_shader
13291
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))
13292
        {
13293
          ret = GLEW_ARB_fragment_shader;
13294
          continue;
13295
        }
13296
#endif
13297
#ifdef GL_ARB_framebuffer_no_attachments
13298
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_no_attachments", 26))
13299
        {
13300
          ret = GLEW_ARB_framebuffer_no_attachments;
13301
          continue;
13302
        }
13303
#endif
13304
#ifdef GL_ARB_framebuffer_object
13305
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))
13306
        {
13307
          ret = GLEW_ARB_framebuffer_object;
13308
          continue;
13309
        }
13310
#endif
13311
#ifdef GL_ARB_framebuffer_sRGB
13312
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
13313
        {
13314
          ret = GLEW_ARB_framebuffer_sRGB;
13315
          continue;
13316
        }
13317
#endif
13318
#ifdef GL_ARB_geometry_shader4
13319
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
13320
        {
13321
          ret = GLEW_ARB_geometry_shader4;
13322
          continue;
13323
        }
13324
#endif
13325
#ifdef GL_ARB_get_program_binary
13326
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18))
13327
        {
13328
          ret = GLEW_ARB_get_program_binary;
13329
          continue;
13330
        }
13331
#endif
13332
#ifdef GL_ARB_gpu_shader5
13333
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
13334
        {
13335
          ret = GLEW_ARB_gpu_shader5;
13336
          continue;
13337
        }
13338
#endif
13339
#ifdef GL_ARB_gpu_shader_fp64
13340
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15))
13341
        {
13342
          ret = GLEW_ARB_gpu_shader_fp64;
13343
          continue;
13344
        }
13345
#endif
13346
#ifdef GL_ARB_half_float_pixel
13347
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))
13348
        {
13349
          ret = GLEW_ARB_half_float_pixel;
13350
          continue;
13351
        }
13352
#endif
13353
#ifdef GL_ARB_half_float_vertex
13354
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17))
13355
        {
13356
          ret = GLEW_ARB_half_float_vertex;
13357
          continue;
13358
        }
13359
#endif
13360
#ifdef GL_ARB_imaging
13361
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))
13362
        {
13363
          ret = GLEW_ARB_imaging;
13364
          continue;
13365
        }
13366
#endif
13367
#ifdef GL_ARB_instanced_arrays
13368
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))
13369
        {
13370
          ret = GLEW_ARB_instanced_arrays;
13371
          continue;
13372
        }
13373
#endif
13374
#ifdef GL_ARB_internalformat_query
13375
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query", 20))
13376
        {
13377
          ret = GLEW_ARB_internalformat_query;
13378
          continue;
13379
        }
13380
#endif
13381
#ifdef GL_ARB_internalformat_query2
13382
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query2", 21))
13383
        {
13384
          ret = GLEW_ARB_internalformat_query2;
13385
          continue;
13386
        }
13387
#endif
13388
#ifdef GL_ARB_invalidate_subdata
13389
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"invalidate_subdata", 18))
13390
        {
13391
          ret = GLEW_ARB_invalidate_subdata;
13392
          continue;
13393
        }
13394
#endif
13395
#ifdef GL_ARB_map_buffer_alignment
13396
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_alignment", 20))
13397
        {
13398
          ret = GLEW_ARB_map_buffer_alignment;
13399
          continue;
13400
        }
13401
#endif
13402
#ifdef GL_ARB_map_buffer_range
13403
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16))
13404
        {
13405
          ret = GLEW_ARB_map_buffer_range;
13406
          continue;
13407
        }
13408
#endif
13409
#ifdef GL_ARB_matrix_palette
13410
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))
13411
        {
13412
          ret = GLEW_ARB_matrix_palette;
13413
          continue;
13414
        }
13415
#endif
13416
#ifdef GL_ARB_multi_draw_indirect
13417
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))
13418
        {
13419
          ret = GLEW_ARB_multi_draw_indirect;
13420
          continue;
13421
        }
13422
#endif
13423
#ifdef GL_ARB_multisample
13424
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
13425
        {
13426
          ret = GLEW_ARB_multisample;
13427
          continue;
13428
        }
13429
#endif
13430
#ifdef GL_ARB_multitexture
13431
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))
13432
        {
13433
          ret = GLEW_ARB_multitexture;
13434
          continue;
13435
        }
13436
#endif
13437
#ifdef GL_ARB_occlusion_query
13438
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))
13439
        {
13440
          ret = GLEW_ARB_occlusion_query;
13441
          continue;
13442
        }
13443
#endif
13444
#ifdef GL_ARB_occlusion_query2
13445
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16))
13446
        {
13447
          ret = GLEW_ARB_occlusion_query2;
13448
          continue;
13449
        }
13450
#endif
13451
#ifdef GL_ARB_pixel_buffer_object
13452
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
13453
        {
13454
          ret = GLEW_ARB_pixel_buffer_object;
13455
          continue;
13456
        }
13457
#endif
13458
#ifdef GL_ARB_point_parameters
13459
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))
13460
        {
13461
          ret = GLEW_ARB_point_parameters;
13462
          continue;
13463
        }
13464
#endif
13465
#ifdef GL_ARB_point_sprite
13466
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))
13467
        {
13468
          ret = GLEW_ARB_point_sprite;
13469
          continue;
13470
        }
13471
#endif
13472
#ifdef GL_ARB_program_interface_query
13473
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_interface_query", 23))
13474
        {
13475
          ret = GLEW_ARB_program_interface_query;
13476
          continue;
13477
        }
13478
#endif
13479
#ifdef GL_ARB_provoking_vertex
13480
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
13481
        {
13482
          ret = GLEW_ARB_provoking_vertex;
13483
          continue;
13484
        }
13485
#endif
13486
#ifdef GL_ARB_robust_buffer_access_behavior
13487
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29))
13488
        {
13489
          ret = GLEW_ARB_robust_buffer_access_behavior;
13490
          continue;
13491
        }
13492
#endif
13493
#ifdef GL_ARB_robustness
13494
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10))
13495
        {
13496
          ret = GLEW_ARB_robustness;
13497
          continue;
13498
        }
13499
#endif
13500
#ifdef GL_ARB_robustness_application_isolation
13501
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))
13502
        {
13503
          ret = GLEW_ARB_robustness_application_isolation;
13504
          continue;
13505
        }
13506
#endif
13507
#ifdef GL_ARB_robustness_share_group_isolation
13508
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))
13509
        {
13510
          ret = GLEW_ARB_robustness_share_group_isolation;
13511
          continue;
13512
        }
13513
#endif
13514
#ifdef GL_ARB_sample_shading
13515
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14))
13516
        {
13517
          ret = GLEW_ARB_sample_shading;
13518
          continue;
13519
        }
13520
#endif
13521
#ifdef GL_ARB_sampler_objects
13522
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15))
13523
        {
13524
          ret = GLEW_ARB_sampler_objects;
13525
          continue;
13526
        }
13527
#endif
13528
#ifdef GL_ARB_seamless_cube_map
13529
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17))
13530
        {
13531
          ret = GLEW_ARB_seamless_cube_map;
13532
          continue;
13533
        }
13534
#endif
13535
#ifdef GL_ARB_separate_shader_objects
13536
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
13537
        {
13538
          ret = GLEW_ARB_separate_shader_objects;
13539
          continue;
13540
        }
13541
#endif
13542
#ifdef GL_ARB_shader_atomic_counters
13543
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22))
13544
        {
13545
          ret = GLEW_ARB_shader_atomic_counters;
13546
          continue;
13547
        }
13548
#endif
13549
#ifdef GL_ARB_shader_bit_encoding
13550
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19))
13551
        {
13552
          ret = GLEW_ARB_shader_bit_encoding;
13553
          continue;
13554
        }
13555
#endif
13556
#ifdef GL_ARB_shader_image_load_store
13557
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
13558
        {
13559
          ret = GLEW_ARB_shader_image_load_store;
13560
          continue;
13561
        }
13562
#endif
13563
#ifdef GL_ARB_shader_image_size
13564
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_size", 17))
13565
        {
13566
          ret = GLEW_ARB_shader_image_size;
13567
          continue;
13568
        }
13569
#endif
13570
#ifdef GL_ARB_shader_objects
13571
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))
13572
        {
13573
          ret = GLEW_ARB_shader_objects;
13574
          continue;
13575
        }
13576
#endif
13577
#ifdef GL_ARB_shader_precision
13578
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_precision", 16))
13579
        {
13580
          ret = GLEW_ARB_shader_precision;
13581
          continue;
13582
        }
13583
#endif
13584
#ifdef GL_ARB_shader_stencil_export
13585
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
13586
        {
13587
          ret = GLEW_ARB_shader_stencil_export;
13588
          continue;
13589
        }
13590
#endif
13591
#ifdef GL_ARB_shader_storage_buffer_object
13592
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28))
13593
        {
13594
          ret = GLEW_ARB_shader_storage_buffer_object;
13595
          continue;
13596
        }
13597
#endif
13598
#ifdef GL_ARB_shader_subroutine
13599
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17))
13600
        {
13601
          ret = GLEW_ARB_shader_subroutine;
13602
          continue;
13603
        }
13604
#endif
13605
#ifdef GL_ARB_shader_texture_lod
13606
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
13607
        {
13608
          ret = GLEW_ARB_shader_texture_lod;
13609
          continue;
13610
        }
13611
#endif
13612
#ifdef GL_ARB_shading_language_100
13613
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))
13614
        {
13615
          ret = GLEW_ARB_shading_language_100;
13616
          continue;
13617
        }
13618
#endif
13619
#ifdef GL_ARB_shading_language_420pack
13620
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_420pack", 24))
13621
        {
13622
          ret = GLEW_ARB_shading_language_420pack;
13623
          continue;
13624
        }
13625
#endif
13626
#ifdef GL_ARB_shading_language_include
13627
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24))
13628
        {
13629
          ret = GLEW_ARB_shading_language_include;
13630
          continue;
13631
        }
13632
#endif
13633
#ifdef GL_ARB_shading_language_packing
13634
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_packing", 24))
13635
        {
13636
          ret = GLEW_ARB_shading_language_packing;
13637
          continue;
13638
        }
13639
#endif
13640
#ifdef GL_ARB_shadow
13641
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
13642
        {
13643
          ret = GLEW_ARB_shadow;
13644
          continue;
13645
        }
13646
#endif
13647
#ifdef GL_ARB_shadow_ambient
13648
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))
13649
        {
13650
          ret = GLEW_ARB_shadow_ambient;
13651
          continue;
13652
        }
13653
#endif
13654
#ifdef GL_ARB_stencil_texturing
13655
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_texturing", 17))
13656
        {
13657
          ret = GLEW_ARB_stencil_texturing;
13658
          continue;
13659
        }
13660
#endif
13661
#ifdef GL_ARB_sync
13662
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))
13663
        {
13664
          ret = GLEW_ARB_sync;
13665
          continue;
13666
        }
13667
#endif
13668
#ifdef GL_ARB_tessellation_shader
13669
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19))
13670
        {
13671
          ret = GLEW_ARB_tessellation_shader;
13672
          continue;
13673
        }
13674
#endif
13675
#ifdef GL_ARB_texture_border_clamp
13676
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
13677
        {
13678
          ret = GLEW_ARB_texture_border_clamp;
13679
          continue;
13680
        }
13681
#endif
13682
#ifdef GL_ARB_texture_buffer_object
13683
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))
13684
        {
13685
          ret = GLEW_ARB_texture_buffer_object;
13686
          continue;
13687
        }
13688
#endif
13689
#ifdef GL_ARB_texture_buffer_object_rgb32
13690
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27))
13691
        {
13692
          ret = GLEW_ARB_texture_buffer_object_rgb32;
13693
          continue;
13694
        }
13695
#endif
13696
#ifdef GL_ARB_texture_buffer_range
13697
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_range", 20))
13698
        {
13699
          ret = GLEW_ARB_texture_buffer_range;
13700
          continue;
13701
        }
13702
#endif
13703
#ifdef GL_ARB_texture_compression
13704
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))
13705
        {
13706
          ret = GLEW_ARB_texture_compression;
13707
          continue;
13708
        }
13709
#endif
13710
#ifdef GL_ARB_texture_compression_bptc
13711
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24))
13712
        {
13713
          ret = GLEW_ARB_texture_compression_bptc;
13714
          continue;
13715
        }
13716
#endif
13717
#ifdef GL_ARB_texture_compression_rgtc
13718
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
13719
        {
13720
          ret = GLEW_ARB_texture_compression_rgtc;
13721
          continue;
13722
        }
13723
#endif
13724
#ifdef GL_ARB_texture_cube_map
13725
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))
13726
        {
13727
          ret = GLEW_ARB_texture_cube_map;
13728
          continue;
13729
        }
13730
#endif
13731
#ifdef GL_ARB_texture_cube_map_array
13732
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22))
13733
        {
13734
          ret = GLEW_ARB_texture_cube_map_array;
13735
          continue;
13736
        }
13737
#endif
13738
#ifdef GL_ARB_texture_env_add
13739
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
13740
        {
13741
          ret = GLEW_ARB_texture_env_add;
13742
          continue;
13743
        }
13744
#endif
13745
#ifdef GL_ARB_texture_env_combine
13746
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))
13747
        {
13748
          ret = GLEW_ARB_texture_env_combine;
13749
          continue;
13750
        }
13751
#endif
13752
#ifdef GL_ARB_texture_env_crossbar
13753
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))
13754
        {
13755
          ret = GLEW_ARB_texture_env_crossbar;
13756
          continue;
13757
        }
13758
#endif
13759
#ifdef GL_ARB_texture_env_dot3
13760
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))
13761
        {
13762
          ret = GLEW_ARB_texture_env_dot3;
13763
          continue;
13764
        }
13765
#endif
13766
#ifdef GL_ARB_texture_float
13767
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))
13768
        {
13769
          ret = GLEW_ARB_texture_float;
13770
          continue;
13771
        }
13772
#endif
13773
#ifdef GL_ARB_texture_gather
13774
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14))
13775
        {
13776
          ret = GLEW_ARB_texture_gather;
13777
          continue;
13778
        }
13779
#endif
13780
#ifdef GL_ARB_texture_mirrored_repeat
13781
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
13782
        {
13783
          ret = GLEW_ARB_texture_mirrored_repeat;
13784
          continue;
13785
        }
13786
#endif
13787
#ifdef GL_ARB_texture_multisample
13788
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
13789
        {
13790
          ret = GLEW_ARB_texture_multisample;
13791
          continue;
13792
        }
13793
#endif
13794
#ifdef GL_ARB_texture_non_power_of_two
13795
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))
13796
        {
13797
          ret = GLEW_ARB_texture_non_power_of_two;
13798
          continue;
13799
        }
13800
#endif
13801
#ifdef GL_ARB_texture_query_levels
13802
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_levels", 20))
13803
        {
13804
          ret = GLEW_ARB_texture_query_levels;
13805
          continue;
13806
        }
13807
#endif
13808
#ifdef GL_ARB_texture_query_lod
13809
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17))
13810
        {
13811
          ret = GLEW_ARB_texture_query_lod;
13812
          continue;
13813
        }
13814
#endif
13815
#ifdef GL_ARB_texture_rectangle
13816
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
13817
        {
13818
          ret = GLEW_ARB_texture_rectangle;
13819
          continue;
13820
        }
13821
#endif
13822
#ifdef GL_ARB_texture_rg
13823
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10))
13824
        {
13825
          ret = GLEW_ARB_texture_rg;
13826
          continue;
13827
        }
13828
#endif
13829
#ifdef GL_ARB_texture_rgb10_a2ui
13830
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18))
13831
        {
13832
          ret = GLEW_ARB_texture_rgb10_a2ui;
13833
          continue;
13834
        }
13835
#endif
13836
#ifdef GL_ARB_texture_storage
13837
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15))
13838
        {
13839
          ret = GLEW_ARB_texture_storage;
13840
          continue;
13841
        }
13842
#endif
13843
#ifdef GL_ARB_texture_storage_multisample
13844
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_multisample", 27))
13845
        {
13846
          ret = GLEW_ARB_texture_storage_multisample;
13847
          continue;
13848
        }
13849
#endif
13850
#ifdef GL_ARB_texture_swizzle
13851
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
13852
        {
13853
          ret = GLEW_ARB_texture_swizzle;
13854
          continue;
13855
        }
13856
#endif
13857
#ifdef GL_ARB_texture_view
13858
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12))
13859
        {
13860
          ret = GLEW_ARB_texture_view;
13861
          continue;
13862
        }
13863
#endif
13864
#ifdef GL_ARB_timer_query
13865
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
13866
        {
13867
          ret = GLEW_ARB_timer_query;
13868
          continue;
13869
        }
13870
#endif
13871
#ifdef GL_ARB_transform_feedback2
13872
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
13873
        {
13874
          ret = GLEW_ARB_transform_feedback2;
13875
          continue;
13876
        }
13877
#endif
13878
#ifdef GL_ARB_transform_feedback3
13879
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19))
13880
        {
13881
          ret = GLEW_ARB_transform_feedback3;
13882
          continue;
13883
        }
13884
#endif
13885
#ifdef GL_ARB_transform_feedback_instanced
13886
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_instanced", 28))
13887
        {
13888
          ret = GLEW_ARB_transform_feedback_instanced;
13889
          continue;
13890
        }
13891
#endif
13892
#ifdef GL_ARB_transpose_matrix
13893
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))
13894
        {
13895
          ret = GLEW_ARB_transpose_matrix;
13896
          continue;
13897
        }
13898
#endif
13899
#ifdef GL_ARB_uniform_buffer_object
13900
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21))
13901
        {
13902
          ret = GLEW_ARB_uniform_buffer_object;
13903
          continue;
13904
        }
13905
#endif
13906
#ifdef GL_ARB_vertex_array_bgra
13907
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
13908
        {
13909
          ret = GLEW_ARB_vertex_array_bgra;
13910
          continue;
13911
        }
13912
#endif
13913
#ifdef GL_ARB_vertex_array_object
13914
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
13915
        {
13916
          ret = GLEW_ARB_vertex_array_object;
13917
          continue;
13918
        }
13919
#endif
13920
#ifdef GL_ARB_vertex_attrib_64bit
13921
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
13922
        {
13923
          ret = GLEW_ARB_vertex_attrib_64bit;
13924
          continue;
13925
        }
13926
#endif
13927
#ifdef GL_ARB_vertex_attrib_binding
13928
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_binding", 21))
13929
        {
13930
          ret = GLEW_ARB_vertex_attrib_binding;
13931
          continue;
13932
        }
13933
#endif
13934
#ifdef GL_ARB_vertex_blend
13935
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))
13936
        {
13937
          ret = GLEW_ARB_vertex_blend;
13938
          continue;
13939
        }
13940
#endif
13941
#ifdef GL_ARB_vertex_buffer_object
13942
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
13943
        {
13944
          ret = GLEW_ARB_vertex_buffer_object;
13945
          continue;
13946
        }
13947
#endif
13948
#ifdef GL_ARB_vertex_program
13949
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
13950
        {
13951
          ret = GLEW_ARB_vertex_program;
13952
          continue;
13953
        }
13954
#endif
13955
#ifdef GL_ARB_vertex_shader
13956
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
13957
        {
13958
          ret = GLEW_ARB_vertex_shader;
13959
          continue;
13960
        }
13961
#endif
13962
#ifdef GL_ARB_vertex_type_2_10_10_10_rev
13963
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26))
13964
        {
13965
          ret = GLEW_ARB_vertex_type_2_10_10_10_rev;
13966
          continue;
13967
        }
13968
#endif
13969
#ifdef GL_ARB_viewport_array
13970
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14))
13971
        {
13972
          ret = GLEW_ARB_viewport_array;
13973
          continue;
13974
        }
13975
#endif
13976
#ifdef GL_ARB_window_pos
13977
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
13978
        {
13979
          ret = GLEW_ARB_window_pos;
13980
          continue;
13981
        }
13982
#endif
13983
      }
13984
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))
13985
      {
13986
#ifdef GL_ATIX_point_sprites
13987
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))
13988
        {
13989
          ret = GLEW_ATIX_point_sprites;
13990
          continue;
13991
        }
13992
#endif
13993
#ifdef GL_ATIX_texture_env_combine3
13994
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))
13995
        {
13996
          ret = GLEW_ATIX_texture_env_combine3;
13997
          continue;
13998
        }
13999
#endif
14000
#ifdef GL_ATIX_texture_env_route
14001
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))
14002
        {
14003
          ret = GLEW_ATIX_texture_env_route;
14004
          continue;
14005
        }
14006
#endif
14007
#ifdef GL_ATIX_vertex_shader_output_point_size
14008
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))
14009
        {
14010
          ret = GLEW_ATIX_vertex_shader_output_point_size;
14011
          continue;
14012
        }
14013
#endif
14014
      }
14015
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
14016
      {
14017
#ifdef GL_ATI_draw_buffers
14018
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))
14019
        {
14020
          ret = GLEW_ATI_draw_buffers;
14021
          continue;
14022
        }
14023
#endif
14024
#ifdef GL_ATI_element_array
14025
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))
14026
        {
14027
          ret = GLEW_ATI_element_array;
14028
          continue;
14029
        }
14030
#endif
14031
#ifdef GL_ATI_envmap_bumpmap
14032
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))
14033
        {
14034
          ret = GLEW_ATI_envmap_bumpmap;
14035
          continue;
14036
        }
14037
#endif
14038
#ifdef GL_ATI_fragment_shader
14039
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))
14040
        {
14041
          ret = GLEW_ATI_fragment_shader;
14042
          continue;
14043
        }
14044
#endif
14045
#ifdef GL_ATI_map_object_buffer
14046
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))
14047
        {
14048
          ret = GLEW_ATI_map_object_buffer;
14049
          continue;
14050
        }
14051
#endif
14052
#ifdef GL_ATI_meminfo
14053
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7))
14054
        {
14055
          ret = GLEW_ATI_meminfo;
14056
          continue;
14057
        }
14058
#endif
14059
#ifdef GL_ATI_pn_triangles
14060
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))
14061
        {
14062
          ret = GLEW_ATI_pn_triangles;
14063
          continue;
14064
        }
14065
#endif
14066
#ifdef GL_ATI_separate_stencil
14067
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))
14068
        {
14069
          ret = GLEW_ATI_separate_stencil;
14070
          continue;
14071
        }
14072
#endif
14073
#ifdef GL_ATI_shader_texture_lod
14074
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
14075
        {
14076
          ret = GLEW_ATI_shader_texture_lod;
14077
          continue;
14078
        }
14079
#endif
14080
#ifdef GL_ATI_text_fragment_shader
14081
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))
14082
        {
14083
          ret = GLEW_ATI_text_fragment_shader;
14084
          continue;
14085
        }
14086
#endif
14087
#ifdef GL_ATI_texture_compression_3dc
14088
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))
14089
        {
14090
          ret = GLEW_ATI_texture_compression_3dc;
14091
          continue;
14092
        }
14093
#endif
14094
#ifdef GL_ATI_texture_env_combine3
14095
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))
14096
        {
14097
          ret = GLEW_ATI_texture_env_combine3;
14098
          continue;
14099
        }
14100
#endif
14101
#ifdef GL_ATI_texture_float
14102
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))
14103
        {
14104
          ret = GLEW_ATI_texture_float;
14105
          continue;
14106
        }
14107
#endif
14108
#ifdef GL_ATI_texture_mirror_once
14109
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))
14110
        {
14111
          ret = GLEW_ATI_texture_mirror_once;
14112
          continue;
14113
        }
14114
#endif
14115
#ifdef GL_ATI_vertex_array_object
14116
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
14117
        {
14118
          ret = GLEW_ATI_vertex_array_object;
14119
          continue;
14120
        }
14121
#endif
14122
#ifdef GL_ATI_vertex_attrib_array_object
14123
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))
14124
        {
14125
          ret = GLEW_ATI_vertex_attrib_array_object;
14126
          continue;
14127
        }
14128
#endif
14129
#ifdef GL_ATI_vertex_streams
14130
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))
14131
        {
14132
          ret = GLEW_ATI_vertex_streams;
14133
          continue;
14134
        }
14135
#endif
14136
      }
14137
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
14138
      {
14139
#ifdef GL_EXT_422_pixels
14140
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))
14141
        {
14142
          ret = GLEW_EXT_422_pixels;
14143
          continue;
14144
        }
14145
#endif
14146
#ifdef GL_EXT_Cg_shader
14147
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))
14148
        {
14149
          ret = GLEW_EXT_Cg_shader;
14150
          continue;
14151
        }
14152
#endif
14153
#ifdef GL_EXT_abgr
14154
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))
14155
        {
14156
          ret = GLEW_EXT_abgr;
14157
          continue;
14158
        }
14159
#endif
14160
#ifdef GL_EXT_bgra
14161
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))
14162
        {
14163
          ret = GLEW_EXT_bgra;
14164
          continue;
14165
        }
14166
#endif
14167
#ifdef GL_EXT_bindable_uniform
14168
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16))
14169
        {
14170
          ret = GLEW_EXT_bindable_uniform;
14171
          continue;
14172
        }
14173
#endif
14174
#ifdef GL_EXT_blend_color
14175
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))
14176
        {
14177
          ret = GLEW_EXT_blend_color;
14178
          continue;
14179
        }
14180
#endif
14181
#ifdef GL_EXT_blend_equation_separate
14182
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))
14183
        {
14184
          ret = GLEW_EXT_blend_equation_separate;
14185
          continue;
14186
        }
14187
#endif
14188
#ifdef GL_EXT_blend_func_separate
14189
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))
14190
        {
14191
          ret = GLEW_EXT_blend_func_separate;
14192
          continue;
14193
        }
14194
#endif
14195
#ifdef GL_EXT_blend_logic_op
14196
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))
14197
        {
14198
          ret = GLEW_EXT_blend_logic_op;
14199
          continue;
14200
        }
14201
#endif
14202
#ifdef GL_EXT_blend_minmax
14203
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))
14204
        {
14205
          ret = GLEW_EXT_blend_minmax;
14206
          continue;
14207
        }
14208
#endif
14209
#ifdef GL_EXT_blend_subtract
14210
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))
14211
        {
14212
          ret = GLEW_EXT_blend_subtract;
14213
          continue;
14214
        }
14215
#endif
14216
#ifdef GL_EXT_clip_volume_hint
14217
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))
14218
        {
14219
          ret = GLEW_EXT_clip_volume_hint;
14220
          continue;
14221
        }
14222
#endif
14223
#ifdef GL_EXT_cmyka
14224
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))
14225
        {
14226
          ret = GLEW_EXT_cmyka;
14227
          continue;
14228
        }
14229
#endif
14230
#ifdef GL_EXT_color_subtable
14231
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))
14232
        {
14233
          ret = GLEW_EXT_color_subtable;
14234
          continue;
14235
        }
14236
#endif
14237
#ifdef GL_EXT_compiled_vertex_array
14238
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))
14239
        {
14240
          ret = GLEW_EXT_compiled_vertex_array;
14241
          continue;
14242
        }
14243
#endif
14244
#ifdef GL_EXT_convolution
14245
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))
14246
        {
14247
          ret = GLEW_EXT_convolution;
14248
          continue;
14249
        }
14250
#endif
14251
#ifdef GL_EXT_coordinate_frame
14252
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))
14253
        {
14254
          ret = GLEW_EXT_coordinate_frame;
14255
          continue;
14256
        }
14257
#endif
14258
#ifdef GL_EXT_copy_texture
14259
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))
14260
        {
14261
          ret = GLEW_EXT_copy_texture;
14262
          continue;
14263
        }
14264
#endif
14265
#ifdef GL_EXT_cull_vertex
14266
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))
14267
        {
14268
          ret = GLEW_EXT_cull_vertex;
14269
          continue;
14270
        }
14271
#endif
14272
#ifdef GL_EXT_debug_marker
14273
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_marker", 12))
14274
        {
14275
          ret = GLEW_EXT_debug_marker;
14276
          continue;
14277
        }
14278
#endif
14279
#ifdef GL_EXT_depth_bounds_test
14280
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))
14281
        {
14282
          ret = GLEW_EXT_depth_bounds_test;
14283
          continue;
14284
        }
14285
#endif
14286
#ifdef GL_EXT_direct_state_access
14287
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19))
14288
        {
14289
          ret = GLEW_EXT_direct_state_access;
14290
          continue;
14291
        }
14292
#endif
14293
#ifdef GL_EXT_draw_buffers2
14294
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13))
14295
        {
14296
          ret = GLEW_EXT_draw_buffers2;
14297
          continue;
14298
        }
14299
#endif
14300
#ifdef GL_EXT_draw_instanced
14301
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
14302
        {
14303
          ret = GLEW_EXT_draw_instanced;
14304
          continue;
14305
        }
14306
#endif
14307
#ifdef GL_EXT_draw_range_elements
14308
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))
14309
        {
14310
          ret = GLEW_EXT_draw_range_elements;
14311
          continue;
14312
        }
14313
#endif
14314
#ifdef GL_EXT_fog_coord
14315
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))
14316
        {
14317
          ret = GLEW_EXT_fog_coord;
14318
          continue;
14319
        }
14320
#endif
14321
#ifdef GL_EXT_fragment_lighting
14322
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))
14323
        {
14324
          ret = GLEW_EXT_fragment_lighting;
14325
          continue;
14326
        }
14327
#endif
14328
#ifdef GL_EXT_framebuffer_blit
14329
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))
14330
        {
14331
          ret = GLEW_EXT_framebuffer_blit;
14332
          continue;
14333
        }
14334
#endif
14335
#ifdef GL_EXT_framebuffer_multisample
14336
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))
14337
        {
14338
          ret = GLEW_EXT_framebuffer_multisample;
14339
          continue;
14340
        }
14341
#endif
14342
#ifdef GL_EXT_framebuffer_multisample_blit_scaled
14343
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_blit_scaled", 35))
14344
        {
14345
          ret = GLEW_EXT_framebuffer_multisample_blit_scaled;
14346
          continue;
14347
        }
14348
#endif
14349
#ifdef GL_EXT_framebuffer_object
14350
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))
14351
        {
14352
          ret = GLEW_EXT_framebuffer_object;
14353
          continue;
14354
        }
14355
#endif
14356
#ifdef GL_EXT_framebuffer_sRGB
14357
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
14358
        {
14359
          ret = GLEW_EXT_framebuffer_sRGB;
14360
          continue;
14361
        }
14362
#endif
14363
#ifdef GL_EXT_geometry_shader4
14364
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
14365
        {
14366
          ret = GLEW_EXT_geometry_shader4;
14367
          continue;
14368
        }
14369
#endif
14370
#ifdef GL_EXT_gpu_program_parameters
14371
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22))
14372
        {
14373
          ret = GLEW_EXT_gpu_program_parameters;
14374
          continue;
14375
        }
14376
#endif
14377
#ifdef GL_EXT_gpu_shader4
14378
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11))
14379
        {
14380
          ret = GLEW_EXT_gpu_shader4;
14381
          continue;
14382
        }
14383
#endif
14384
#ifdef GL_EXT_histogram
14385
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))
14386
        {
14387
          ret = GLEW_EXT_histogram;
14388
          continue;
14389
        }
14390
#endif
14391
#ifdef GL_EXT_index_array_formats
14392
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))
14393
        {
14394
          ret = GLEW_EXT_index_array_formats;
14395
          continue;
14396
        }
14397
#endif
14398
#ifdef GL_EXT_index_func
14399
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))
14400
        {
14401
          ret = GLEW_EXT_index_func;
14402
          continue;
14403
        }
14404
#endif
14405
#ifdef GL_EXT_index_material
14406
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))
14407
        {
14408
          ret = GLEW_EXT_index_material;
14409
          continue;
14410
        }
14411
#endif
14412
#ifdef GL_EXT_index_texture
14413
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))
14414
        {
14415
          ret = GLEW_EXT_index_texture;
14416
          continue;
14417
        }
14418
#endif
14419
#ifdef GL_EXT_light_texture
14420
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))
14421
        {
14422
          ret = GLEW_EXT_light_texture;
14423
          continue;
14424
        }
14425
#endif
14426
#ifdef GL_EXT_misc_attribute
14427
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))
14428
        {
14429
          ret = GLEW_EXT_misc_attribute;
14430
          continue;
14431
        }
14432
#endif
14433
#ifdef GL_EXT_multi_draw_arrays
14434
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))
14435
        {
14436
          ret = GLEW_EXT_multi_draw_arrays;
14437
          continue;
14438
        }
14439
#endif
14440
#ifdef GL_EXT_multisample
14441
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
14442
        {
14443
          ret = GLEW_EXT_multisample;
14444
          continue;
14445
        }
14446
#endif
14447
#ifdef GL_EXT_packed_depth_stencil
14448
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))
14449
        {
14450
          ret = GLEW_EXT_packed_depth_stencil;
14451
          continue;
14452
        }
14453
#endif
14454
#ifdef GL_EXT_packed_float
14455
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))
14456
        {
14457
          ret = GLEW_EXT_packed_float;
14458
          continue;
14459
        }
14460
#endif
14461
#ifdef GL_EXT_packed_pixels
14462
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))
14463
        {
14464
          ret = GLEW_EXT_packed_pixels;
14465
          continue;
14466
        }
14467
#endif
14468
#ifdef GL_EXT_paletted_texture
14469
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))
14470
        {
14471
          ret = GLEW_EXT_paletted_texture;
14472
          continue;
14473
        }
14474
#endif
14475
#ifdef GL_EXT_pixel_buffer_object
14476
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
14477
        {
14478
          ret = GLEW_EXT_pixel_buffer_object;
14479
          continue;
14480
        }
14481
#endif
14482
#ifdef GL_EXT_pixel_transform
14483
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))
14484
        {
14485
          ret = GLEW_EXT_pixel_transform;
14486
          continue;
14487
        }
14488
#endif
14489
#ifdef GL_EXT_pixel_transform_color_table
14490
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))
14491
        {
14492
          ret = GLEW_EXT_pixel_transform_color_table;
14493
          continue;
14494
        }
14495
#endif
14496
#ifdef GL_EXT_point_parameters
14497
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))
14498
        {
14499
          ret = GLEW_EXT_point_parameters;
14500
          continue;
14501
        }
14502
#endif
14503
#ifdef GL_EXT_polygon_offset
14504
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))
14505
        {
14506
          ret = GLEW_EXT_polygon_offset;
14507
          continue;
14508
        }
14509
#endif
14510
#ifdef GL_EXT_provoking_vertex
14511
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
14512
        {
14513
          ret = GLEW_EXT_provoking_vertex;
14514
          continue;
14515
        }
14516
#endif
14517
#ifdef GL_EXT_rescale_normal
14518
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))
14519
        {
14520
          ret = GLEW_EXT_rescale_normal;
14521
          continue;
14522
        }
14523
#endif
14524
#ifdef GL_EXT_scene_marker
14525
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))
14526
        {
14527
          ret = GLEW_EXT_scene_marker;
14528
          continue;
14529
        }
14530
#endif
14531
#ifdef GL_EXT_secondary_color
14532
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))
14533
        {
14534
          ret = GLEW_EXT_secondary_color;
14535
          continue;
14536
        }
14537
#endif
14538
#ifdef GL_EXT_separate_shader_objects
14539
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
14540
        {
14541
          ret = GLEW_EXT_separate_shader_objects;
14542
          continue;
14543
        }
14544
#endif
14545
#ifdef GL_EXT_separate_specular_color
14546
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))
14547
        {
14548
          ret = GLEW_EXT_separate_specular_color;
14549
          continue;
14550
        }
14551
#endif
14552
#ifdef GL_EXT_shader_image_load_store
14553
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
14554
        {
14555
          ret = GLEW_EXT_shader_image_load_store;
14556
          continue;
14557
        }
14558
#endif
14559
#ifdef GL_EXT_shadow_funcs
14560
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))
14561
        {
14562
          ret = GLEW_EXT_shadow_funcs;
14563
          continue;
14564
        }
14565
#endif
14566
#ifdef GL_EXT_shared_texture_palette
14567
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))
14568
        {
14569
          ret = GLEW_EXT_shared_texture_palette;
14570
          continue;
14571
        }
14572
#endif
14573
#ifdef GL_EXT_stencil_clear_tag
14574
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17))
14575
        {
14576
          ret = GLEW_EXT_stencil_clear_tag;
14577
          continue;
14578
        }
14579
#endif
14580
#ifdef GL_EXT_stencil_two_side
14581
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))
14582
        {
14583
          ret = GLEW_EXT_stencil_two_side;
14584
          continue;
14585
        }
14586
#endif
14587
#ifdef GL_EXT_stencil_wrap
14588
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))
14589
        {
14590
          ret = GLEW_EXT_stencil_wrap;
14591
          continue;
14592
        }
14593
#endif
14594
#ifdef GL_EXT_subtexture
14595
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))
14596
        {
14597
          ret = GLEW_EXT_subtexture;
14598
          continue;
14599
        }
14600
#endif
14601
#ifdef GL_EXT_texture
14602
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))
14603
        {
14604
          ret = GLEW_EXT_texture;
14605
          continue;
14606
        }
14607
#endif
14608
#ifdef GL_EXT_texture3D
14609
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))
14610
        {
14611
          ret = GLEW_EXT_texture3D;
14612
          continue;
14613
        }
14614
#endif
14615
#ifdef GL_EXT_texture_array
14616
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))
14617
        {
14618
          ret = GLEW_EXT_texture_array;
14619
          continue;
14620
        }
14621
#endif
14622
#ifdef GL_EXT_texture_buffer_object
14623
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))
14624
        {
14625
          ret = GLEW_EXT_texture_buffer_object;
14626
          continue;
14627
        }
14628
#endif
14629
#ifdef GL_EXT_texture_compression_dxt1
14630
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))
14631
        {
14632
          ret = GLEW_EXT_texture_compression_dxt1;
14633
          continue;
14634
        }
14635
#endif
14636
#ifdef GL_EXT_texture_compression_latc
14637
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))
14638
        {
14639
          ret = GLEW_EXT_texture_compression_latc;
14640
          continue;
14641
        }
14642
#endif
14643
#ifdef GL_EXT_texture_compression_rgtc
14644
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
14645
        {
14646
          ret = GLEW_EXT_texture_compression_rgtc;
14647
          continue;
14648
        }
14649
#endif
14650
#ifdef GL_EXT_texture_compression_s3tc
14651
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))
14652
        {
14653
          ret = GLEW_EXT_texture_compression_s3tc;
14654
          continue;
14655
        }
14656
#endif
14657
#ifdef GL_EXT_texture_cube_map
14658
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))
14659
        {
14660
          ret = GLEW_EXT_texture_cube_map;
14661
          continue;
14662
        }
14663
#endif
14664
#ifdef GL_EXT_texture_edge_clamp
14665
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))
14666
        {
14667
          ret = GLEW_EXT_texture_edge_clamp;
14668
          continue;
14669
        }
14670
#endif
14671
#ifdef GL_EXT_texture_env
14672
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))
14673
        {
14674
          ret = GLEW_EXT_texture_env;
14675
          continue;
14676
        }
14677
#endif
14678
#ifdef GL_EXT_texture_env_add
14679
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
14680
        {
14681
          ret = GLEW_EXT_texture_env_add;
14682
          continue;
14683
        }
14684
#endif
14685
#ifdef GL_EXT_texture_env_combine
14686
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))
14687
        {
14688
          ret = GLEW_EXT_texture_env_combine;
14689
          continue;
14690
        }
14691
#endif
14692
#ifdef GL_EXT_texture_env_dot3
14693
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))
14694
        {
14695
          ret = GLEW_EXT_texture_env_dot3;
14696
          continue;
14697
        }
14698
#endif
14699
#ifdef GL_EXT_texture_filter_anisotropic
14700
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))
14701
        {
14702
          ret = GLEW_EXT_texture_filter_anisotropic;
14703
          continue;
14704
        }
14705
#endif
14706
#ifdef GL_EXT_texture_integer
14707
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15))
14708
        {
14709
          ret = GLEW_EXT_texture_integer;
14710
          continue;
14711
        }
14712
#endif
14713
#ifdef GL_EXT_texture_lod_bias
14714
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
14715
        {
14716
          ret = GLEW_EXT_texture_lod_bias;
14717
          continue;
14718
        }
14719
#endif
14720
#ifdef GL_EXT_texture_mirror_clamp
14721
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))
14722
        {
14723
          ret = GLEW_EXT_texture_mirror_clamp;
14724
          continue;
14725
        }
14726
#endif
14727
#ifdef GL_EXT_texture_object
14728
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))
14729
        {
14730
          ret = GLEW_EXT_texture_object;
14731
          continue;
14732
        }
14733
#endif
14734
#ifdef GL_EXT_texture_perturb_normal
14735
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))
14736
        {
14737
          ret = GLEW_EXT_texture_perturb_normal;
14738
          continue;
14739
        }
14740
#endif
14741
#ifdef GL_EXT_texture_rectangle
14742
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
14743
        {
14744
          ret = GLEW_EXT_texture_rectangle;
14745
          continue;
14746
        }
14747
#endif
14748
#ifdef GL_EXT_texture_sRGB
14749
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12))
14750
        {
14751
          ret = GLEW_EXT_texture_sRGB;
14752
          continue;
14753
        }
14754
#endif
14755
#ifdef GL_EXT_texture_sRGB_decode
14756
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19))
14757
        {
14758
          ret = GLEW_EXT_texture_sRGB_decode;
14759
          continue;
14760
        }
14761
#endif
14762
#ifdef GL_EXT_texture_shared_exponent
14763
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23))
14764
        {
14765
          ret = GLEW_EXT_texture_shared_exponent;
14766
          continue;
14767
        }
14768
#endif
14769
#ifdef GL_EXT_texture_snorm
14770
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13))
14771
        {
14772
          ret = GLEW_EXT_texture_snorm;
14773
          continue;
14774
        }
14775
#endif
14776
#ifdef GL_EXT_texture_swizzle
14777
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
14778
        {
14779
          ret = GLEW_EXT_texture_swizzle;
14780
          continue;
14781
        }
14782
#endif
14783
#ifdef GL_EXT_timer_query
14784
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
14785
        {
14786
          ret = GLEW_EXT_timer_query;
14787
          continue;
14788
        }
14789
#endif
14790
#ifdef GL_EXT_transform_feedback
14791
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
14792
        {
14793
          ret = GLEW_EXT_transform_feedback;
14794
          continue;
14795
        }
14796
#endif
14797
#ifdef GL_EXT_vertex_array
14798
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))
14799
        {
14800
          ret = GLEW_EXT_vertex_array;
14801
          continue;
14802
        }
14803
#endif
14804
#ifdef GL_EXT_vertex_array_bgra
14805
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
14806
        {
14807
          ret = GLEW_EXT_vertex_array_bgra;
14808
          continue;
14809
        }
14810
#endif
14811
#ifdef GL_EXT_vertex_attrib_64bit
14812
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
14813
        {
14814
          ret = GLEW_EXT_vertex_attrib_64bit;
14815
          continue;
14816
        }
14817
#endif
14818
#ifdef GL_EXT_vertex_shader
14819
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
14820
        {
14821
          ret = GLEW_EXT_vertex_shader;
14822
          continue;
14823
        }
14824
#endif
14825
#ifdef GL_EXT_vertex_weighting
14826
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))
14827
        {
14828
          ret = GLEW_EXT_vertex_weighting;
14829
          continue;
14830
        }
14831
#endif
14832
#ifdef GL_EXT_x11_sync_object
14833
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"x11_sync_object", 15))
14834
        {
14835
          ret = GLEW_EXT_x11_sync_object;
14836
          continue;
14837
        }
14838
#endif
14839
      }
14840
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8))
14841
      {
14842
#ifdef GL_GREMEDY_frame_terminator
14843
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16))
14844
        {
14845
          ret = GLEW_GREMEDY_frame_terminator;
14846
          continue;
14847
        }
14848
#endif
14849
#ifdef GL_GREMEDY_string_marker
14850
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13))
14851
        {
14852
          ret = GLEW_GREMEDY_string_marker;
14853
          continue;
14854
        }
14855
#endif
14856
      }
14857
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))
14858
      {
14859
#ifdef GL_HP_convolution_border_modes
14860
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))
14861
        {
14862
          ret = GLEW_HP_convolution_border_modes;
14863
          continue;
14864
        }
14865
#endif
14866
#ifdef GL_HP_image_transform
14867
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))
14868
        {
14869
          ret = GLEW_HP_image_transform;
14870
          continue;
14871
        }
14872
#endif
14873
#ifdef GL_HP_occlusion_test
14874
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))
14875
        {
14876
          ret = GLEW_HP_occlusion_test;
14877
          continue;
14878
        }
14879
#endif
14880
#ifdef GL_HP_texture_lighting
14881
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))
14882
        {
14883
          ret = GLEW_HP_texture_lighting;
14884
          continue;
14885
        }
14886
#endif
14887
      }
14888
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))
14889
      {
14890
#ifdef GL_IBM_cull_vertex
14891
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))
14892
        {
14893
          ret = GLEW_IBM_cull_vertex;
14894
          continue;
14895
        }
14896
#endif
14897
#ifdef GL_IBM_multimode_draw_arrays
14898
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))
14899
        {
14900
          ret = GLEW_IBM_multimode_draw_arrays;
14901
          continue;
14902
        }
14903
#endif
14904
#ifdef GL_IBM_rasterpos_clip
14905
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))
14906
        {
14907
          ret = GLEW_IBM_rasterpos_clip;
14908
          continue;
14909
        }
14910
#endif
14911
#ifdef GL_IBM_static_data
14912
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))
14913
        {
14914
          ret = GLEW_IBM_static_data;
14915
          continue;
14916
        }
14917
#endif
14918
#ifdef GL_IBM_texture_mirrored_repeat
14919
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
14920
        {
14921
          ret = GLEW_IBM_texture_mirrored_repeat;
14922
          continue;
14923
        }
14924
#endif
14925
#ifdef GL_IBM_vertex_array_lists
14926
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))
14927
        {
14928
          ret = GLEW_IBM_vertex_array_lists;
14929
          continue;
14930
        }
14931
#endif
14932
      }
14933
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))
14934
      {
14935
#ifdef GL_INGR_color_clamp
14936
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))
14937
        {
14938
          ret = GLEW_INGR_color_clamp;
14939
          continue;
14940
        }
14941
#endif
14942
#ifdef GL_INGR_interlace_read
14943
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))
14944
        {
14945
          ret = GLEW_INGR_interlace_read;
14946
          continue;
14947
        }
14948
#endif
14949
      }
14950
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
14951
      {
14952
#ifdef GL_INTEL_parallel_arrays
14953
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))
14954
        {
14955
          ret = GLEW_INTEL_parallel_arrays;
14956
          continue;
14957
        }
14958
#endif
14959
#ifdef GL_INTEL_texture_scissor
14960
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))
14961
        {
14962
          ret = GLEW_INTEL_texture_scissor;
14963
          continue;
14964
        }
14965
#endif
14966
      }
14967
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"KHR_", 4))
14968
      {
14969
#ifdef GL_KHR_debug
14970
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug", 5))
14971
        {
14972
          ret = GLEW_KHR_debug;
14973
          continue;
14974
        }
14975
#endif
14976
#ifdef GL_KHR_texture_compression_astc_ldr
14977
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_ldr", 28))
14978
        {
14979
          ret = GLEW_KHR_texture_compression_astc_ldr;
14980
          continue;
14981
        }
14982
#endif
14983
      }
14984
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))
14985
      {
14986
#ifdef GL_KTX_buffer_region
14987
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))
14988
        {
14989
          ret = GLEW_KTX_buffer_region;
14990
          continue;
14991
        }
14992
#endif
14993
      }
14994
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6))
14995
      {
14996
#ifdef GL_MESAX_texture_stack
14997
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13))
14998
        {
14999
          ret = GLEW_MESAX_texture_stack;
15000
          continue;
15001
        }
15002
#endif
15003
      }
15004
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
15005
      {
15006
#ifdef GL_MESA_pack_invert
15007
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))
15008
        {
15009
          ret = GLEW_MESA_pack_invert;
15010
          continue;
15011
        }
15012
#endif
15013
#ifdef GL_MESA_resize_buffers
15014
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))
15015
        {
15016
          ret = GLEW_MESA_resize_buffers;
15017
          continue;
15018
        }
15019
#endif
15020
#ifdef GL_MESA_window_pos
15021
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
15022
        {
15023
          ret = GLEW_MESA_window_pos;
15024
          continue;
15025
        }
15026
#endif
15027
#ifdef GL_MESA_ycbcr_texture
15028
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))
15029
        {
15030
          ret = GLEW_MESA_ycbcr_texture;
15031
          continue;
15032
        }
15033
#endif
15034
      }
15035
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NVX_", 4))
15036
      {
15037
#ifdef GL_NVX_gpu_memory_info
15038
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_memory_info", 15))
15039
        {
15040
          ret = GLEW_NVX_gpu_memory_info;
15041
          continue;
15042
        }
15043
#endif
15044
      }
15045
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
15046
      {
15047
#ifdef GL_NV_bindless_texture
15048
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16))
15049
        {
15050
          ret = GLEW_NV_bindless_texture;
15051
          continue;
15052
        }
15053
#endif
15054
#ifdef GL_NV_blend_square
15055
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))
15056
        {
15057
          ret = GLEW_NV_blend_square;
15058
          continue;
15059
        }
15060
#endif
15061
#ifdef GL_NV_conditional_render
15062
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))
15063
        {
15064
          ret = GLEW_NV_conditional_render;
15065
          continue;
15066
        }
15067
#endif
15068
#ifdef GL_NV_copy_depth_to_color
15069
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))
15070
        {
15071
          ret = GLEW_NV_copy_depth_to_color;
15072
          continue;
15073
        }
15074
#endif
15075
#ifdef GL_NV_copy_image
15076
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
15077
        {
15078
          ret = GLEW_NV_copy_image;
15079
          continue;
15080
        }
15081
#endif
15082
#ifdef GL_NV_depth_buffer_float
15083
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
15084
        {
15085
          ret = GLEW_NV_depth_buffer_float;
15086
          continue;
15087
        }
15088
#endif
15089
#ifdef GL_NV_depth_clamp
15090
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
15091
        {
15092
          ret = GLEW_NV_depth_clamp;
15093
          continue;
15094
        }
15095
#endif
15096
#ifdef GL_NV_depth_range_unclamped
15097
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21))
15098
        {
15099
          ret = GLEW_NV_depth_range_unclamped;
15100
          continue;
15101
        }
15102
#endif
15103
#ifdef GL_NV_evaluators
15104
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))
15105
        {
15106
          ret = GLEW_NV_evaluators;
15107
          continue;
15108
        }
15109
#endif
15110
#ifdef GL_NV_explicit_multisample
15111
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20))
15112
        {
15113
          ret = GLEW_NV_explicit_multisample;
15114
          continue;
15115
        }
15116
#endif
15117
#ifdef GL_NV_fence
15118
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))
15119
        {
15120
          ret = GLEW_NV_fence;
15121
          continue;
15122
        }
15123
#endif
15124
#ifdef GL_NV_float_buffer
15125
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
15126
        {
15127
          ret = GLEW_NV_float_buffer;
15128
          continue;
15129
        }
15130
#endif
15131
#ifdef GL_NV_fog_distance
15132
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))
15133
        {
15134
          ret = GLEW_NV_fog_distance;
15135
          continue;
15136
        }
15137
#endif
15138
#ifdef GL_NV_fragment_program
15139
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
15140
        {
15141
          ret = GLEW_NV_fragment_program;
15142
          continue;
15143
        }
15144
#endif
15145
#ifdef GL_NV_fragment_program2
15146
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))
15147
        {
15148
          ret = GLEW_NV_fragment_program2;
15149
          continue;
15150
        }
15151
#endif
15152
#ifdef GL_NV_fragment_program4
15153
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17))
15154
        {
15155
          ret = GLEW_NV_fragment_program4;
15156
          continue;
15157
        }
15158
#endif
15159
#ifdef GL_NV_fragment_program_option
15160
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))
15161
        {
15162
          ret = GLEW_NV_fragment_program_option;
15163
          continue;
15164
        }
15165
#endif
15166
#ifdef GL_NV_framebuffer_multisample_coverage
15167
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32))
15168
        {
15169
          ret = GLEW_NV_framebuffer_multisample_coverage;
15170
          continue;
15171
        }
15172
#endif
15173
#ifdef GL_NV_geometry_program4
15174
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17))
15175
        {
15176
          ret = GLEW_NV_geometry_program4;
15177
          continue;
15178
        }
15179
#endif
15180
#ifdef GL_NV_geometry_shader4
15181
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
15182
        {
15183
          ret = GLEW_NV_geometry_shader4;
15184
          continue;
15185
        }
15186
#endif
15187
#ifdef GL_NV_gpu_program4
15188
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12))
15189
        {
15190
          ret = GLEW_NV_gpu_program4;
15191
          continue;
15192
        }
15193
#endif
15194
#ifdef GL_NV_gpu_program5
15195
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12))
15196
        {
15197
          ret = GLEW_NV_gpu_program5;
15198
          continue;
15199
        }
15200
#endif
15201
#ifdef GL_NV_gpu_program_fp64
15202
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16))
15203
        {
15204
          ret = GLEW_NV_gpu_program_fp64;
15205
          continue;
15206
        }
15207
#endif
15208
#ifdef GL_NV_gpu_shader5
15209
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
15210
        {
15211
          ret = GLEW_NV_gpu_shader5;
15212
          continue;
15213
        }
15214
#endif
15215
#ifdef GL_NV_half_float
15216
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))
15217
        {
15218
          ret = GLEW_NV_half_float;
15219
          continue;
15220
        }
15221
#endif
15222
#ifdef GL_NV_light_max_exponent
15223
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))
15224
        {
15225
          ret = GLEW_NV_light_max_exponent;
15226
          continue;
15227
        }
15228
#endif
15229
#ifdef GL_NV_multisample_coverage
15230
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
15231
        {
15232
          ret = GLEW_NV_multisample_coverage;
15233
          continue;
15234
        }
15235
#endif
15236
#ifdef GL_NV_multisample_filter_hint
15237
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))
15238
        {
15239
          ret = GLEW_NV_multisample_filter_hint;
15240
          continue;
15241
        }
15242
#endif
15243
#ifdef GL_NV_occlusion_query
15244
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))
15245
        {
15246
          ret = GLEW_NV_occlusion_query;
15247
          continue;
15248
        }
15249
#endif
15250
#ifdef GL_NV_packed_depth_stencil
15251
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))
15252
        {
15253
          ret = GLEW_NV_packed_depth_stencil;
15254
          continue;
15255
        }
15256
#endif
15257
#ifdef GL_NV_parameter_buffer_object
15258
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23))
15259
        {
15260
          ret = GLEW_NV_parameter_buffer_object;
15261
          continue;
15262
        }
15263
#endif
15264
#ifdef GL_NV_parameter_buffer_object2
15265
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24))
15266
        {
15267
          ret = GLEW_NV_parameter_buffer_object2;
15268
          continue;
15269
        }
15270
#endif
15271
#ifdef GL_NV_path_rendering
15272
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering", 14))
15273
        {
15274
          ret = GLEW_NV_path_rendering;
15275
          continue;
15276
        }
15277
#endif
15278
#ifdef GL_NV_pixel_data_range
15279
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))
15280
        {
15281
          ret = GLEW_NV_pixel_data_range;
15282
          continue;
15283
        }
15284
#endif
15285
#ifdef GL_NV_point_sprite
15286
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))
15287
        {
15288
          ret = GLEW_NV_point_sprite;
15289
          continue;
15290
        }
15291
#endif
15292
#ifdef GL_NV_present_video
15293
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
15294
        {
15295
          ret = GLEW_NV_present_video;
15296
          continue;
15297
        }
15298
#endif
15299
#ifdef GL_NV_primitive_restart
15300
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))
15301
        {
15302
          ret = GLEW_NV_primitive_restart;
15303
          continue;
15304
        }
15305
#endif
15306
#ifdef GL_NV_register_combiners
15307
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))
15308
        {
15309
          ret = GLEW_NV_register_combiners;
15310
          continue;
15311
        }
15312
#endif
15313
#ifdef GL_NV_register_combiners2
15314
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))
15315
        {
15316
          ret = GLEW_NV_register_combiners2;
15317
          continue;
15318
        }
15319
#endif
15320
#ifdef GL_NV_shader_atomic_float
15321
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_float", 19))
15322
        {
15323
          ret = GLEW_NV_shader_atomic_float;
15324
          continue;
15325
        }
15326
#endif
15327
#ifdef GL_NV_shader_buffer_load
15328
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18))
15329
        {
15330
          ret = GLEW_NV_shader_buffer_load;
15331
          continue;
15332
        }
15333
#endif
15334
#ifdef GL_NV_tessellation_program5
15335
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21))
15336
        {
15337
          ret = GLEW_NV_tessellation_program5;
15338
          continue;
15339
        }
15340
#endif
15341
#ifdef GL_NV_texgen_emboss
15342
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))
15343
        {
15344
          ret = GLEW_NV_texgen_emboss;
15345
          continue;
15346
        }
15347
#endif
15348
#ifdef GL_NV_texgen_reflection
15349
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))
15350
        {
15351
          ret = GLEW_NV_texgen_reflection;
15352
          continue;
15353
        }
15354
#endif
15355
#ifdef GL_NV_texture_barrier
15356
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15))
15357
        {
15358
          ret = GLEW_NV_texture_barrier;
15359
          continue;
15360
        }
15361
#endif
15362
#ifdef GL_NV_texture_compression_vtc
15363
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))
15364
        {
15365
          ret = GLEW_NV_texture_compression_vtc;
15366
          continue;
15367
        }
15368
#endif
15369
#ifdef GL_NV_texture_env_combine4
15370
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))
15371
        {
15372
          ret = GLEW_NV_texture_env_combine4;
15373
          continue;
15374
        }
15375
#endif
15376
#ifdef GL_NV_texture_expand_normal
15377
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))
15378
        {
15379
          ret = GLEW_NV_texture_expand_normal;
15380
          continue;
15381
        }
15382
#endif
15383
#ifdef GL_NV_texture_multisample
15384
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
15385
        {
15386
          ret = GLEW_NV_texture_multisample;
15387
          continue;
15388
        }
15389
#endif
15390
#ifdef GL_NV_texture_rectangle
15391
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
15392
        {
15393
          ret = GLEW_NV_texture_rectangle;
15394
          continue;
15395
        }
15396
#endif
15397
#ifdef GL_NV_texture_shader
15398
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))
15399
        {
15400
          ret = GLEW_NV_texture_shader;
15401
          continue;
15402
        }
15403
#endif
15404
#ifdef GL_NV_texture_shader2
15405
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))
15406
        {
15407
          ret = GLEW_NV_texture_shader2;
15408
          continue;
15409
        }
15410
#endif
15411
#ifdef GL_NV_texture_shader3
15412
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))
15413
        {
15414
          ret = GLEW_NV_texture_shader3;
15415
          continue;
15416
        }
15417
#endif
15418
#ifdef GL_NV_transform_feedback
15419
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
15420
        {
15421
          ret = GLEW_NV_transform_feedback;
15422
          continue;
15423
        }
15424
#endif
15425
#ifdef GL_NV_transform_feedback2
15426
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
15427
        {
15428
          ret = GLEW_NV_transform_feedback2;
15429
          continue;
15430
        }
15431
#endif
15432
#ifdef GL_NV_vdpau_interop
15433
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vdpau_interop", 13))
15434
        {
15435
          ret = GLEW_NV_vdpau_interop;
15436
          continue;
15437
        }
15438
#endif
15439
#ifdef GL_NV_vertex_array_range
15440
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
15441
        {
15442
          ret = GLEW_NV_vertex_array_range;
15443
          continue;
15444
        }
15445
#endif
15446
#ifdef GL_NV_vertex_array_range2
15447
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))
15448
        {
15449
          ret = GLEW_NV_vertex_array_range2;
15450
          continue;
15451
        }
15452
#endif
15453
#ifdef GL_NV_vertex_attrib_integer_64bit
15454
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27))
15455
        {
15456
          ret = GLEW_NV_vertex_attrib_integer_64bit;
15457
          continue;
15458
        }
15459
#endif
15460
#ifdef GL_NV_vertex_buffer_unified_memory
15461
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28))
15462
        {
15463
          ret = GLEW_NV_vertex_buffer_unified_memory;
15464
          continue;
15465
        }
15466
#endif
15467
#ifdef GL_NV_vertex_program
15468
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
15469
        {
15470
          ret = GLEW_NV_vertex_program;
15471
          continue;
15472
        }
15473
#endif
15474
#ifdef GL_NV_vertex_program1_1
15475
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))
15476
        {
15477
          ret = GLEW_NV_vertex_program1_1;
15478
          continue;
15479
        }
15480
#endif
15481
#ifdef GL_NV_vertex_program2
15482
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))
15483
        {
15484
          ret = GLEW_NV_vertex_program2;
15485
          continue;
15486
        }
15487
#endif
15488
#ifdef GL_NV_vertex_program2_option
15489
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))
15490
        {
15491
          ret = GLEW_NV_vertex_program2_option;
15492
          continue;
15493
        }
15494
#endif
15495
#ifdef GL_NV_vertex_program3
15496
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))
15497
        {
15498
          ret = GLEW_NV_vertex_program3;
15499
          continue;
15500
        }
15501
#endif
15502
#ifdef GL_NV_vertex_program4
15503
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15))
15504
        {
15505
          ret = GLEW_NV_vertex_program4;
15506
          continue;
15507
        }
15508
#endif
15509
#ifdef GL_NV_video_capture
15510
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
15511
        {
15512
          ret = GLEW_NV_video_capture;
15513
          continue;
15514
        }
15515
#endif
15516
      }
15517
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4))
15518
      {
15519
#ifdef GL_OES_byte_coordinates
15520
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16))
15521
        {
15522
          ret = GLEW_OES_byte_coordinates;
15523
          continue;
15524
        }
15525
#endif
15526
#ifdef GL_OES_compressed_paletted_texture
15527
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27))
15528
        {
15529
          ret = GLEW_OES_compressed_paletted_texture;
15530
          continue;
15531
        }
15532
#endif
15533
#ifdef GL_OES_read_format
15534
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11))
15535
        {
15536
          ret = GLEW_OES_read_format;
15537
          continue;
15538
        }
15539
#endif
15540
#ifdef GL_OES_single_precision
15541
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16))
15542
        {
15543
          ret = GLEW_OES_single_precision;
15544
          continue;
15545
        }
15546
#endif
15547
      }
15548
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
15549
      {
15550
#ifdef GL_OML_interlace
15551
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))
15552
        {
15553
          ret = GLEW_OML_interlace;
15554
          continue;
15555
        }
15556
#endif
15557
#ifdef GL_OML_resample
15558
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))
15559
        {
15560
          ret = GLEW_OML_resample;
15561
          continue;
15562
        }
15563
#endif
15564
#ifdef GL_OML_subsample
15565
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))
15566
        {
15567
          ret = GLEW_OML_subsample;
15568
          continue;
15569
        }
15570
#endif
15571
      }
15572
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))
15573
      {
15574
#ifdef GL_PGI_misc_hints
15575
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))
15576
        {
15577
          ret = GLEW_PGI_misc_hints;
15578
          continue;
15579
        }
15580
#endif
15581
#ifdef GL_PGI_vertex_hints
15582
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))
15583
        {
15584
          ret = GLEW_PGI_vertex_hints;
15585
          continue;
15586
        }
15587
#endif
15588
      }
15589
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6))
15590
      {
15591
#ifdef GL_REGAL_error_string
15592
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"error_string", 12))
15593
        {
15594
          ret = GLEW_REGAL_error_string;
15595
          continue;
15596
        }
15597
#endif
15598
#ifdef GL_REGAL_extension_query
15599
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"extension_query", 15))
15600
        {
15601
          ret = GLEW_REGAL_extension_query;
15602
          continue;
15603
        }
15604
#endif
15605
#ifdef GL_REGAL_log
15606
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"log", 3))
15607
        {
15608
          ret = GLEW_REGAL_log;
15609
          continue;
15610
        }
15611
#endif
15612
      }
15613
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))
15614
      {
15615
#ifdef GL_REND_screen_coordinates
15616
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))
15617
        {
15618
          ret = GLEW_REND_screen_coordinates;
15619
          continue;
15620
        }
15621
#endif
15622
      }
15623
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))
15624
      {
15625
#ifdef GL_S3_s3tc
15626
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))
15627
        {
15628
          ret = GLEW_S3_s3tc;
15629
          continue;
15630
        }
15631
#endif
15632
      }
15633
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))
15634
      {
15635
#ifdef GL_SGIS_color_range
15636
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))
15637
        {
15638
          ret = GLEW_SGIS_color_range;
15639
          continue;
15640
        }
15641
#endif
15642
#ifdef GL_SGIS_detail_texture
15643
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))
15644
        {
15645
          ret = GLEW_SGIS_detail_texture;
15646
          continue;
15647
        }
15648
#endif
15649
#ifdef GL_SGIS_fog_function
15650
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))
15651
        {
15652
          ret = GLEW_SGIS_fog_function;
15653
          continue;
15654
        }
15655
#endif
15656
#ifdef GL_SGIS_generate_mipmap
15657
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))
15658
        {
15659
          ret = GLEW_SGIS_generate_mipmap;
15660
          continue;
15661
        }
15662
#endif
15663
#ifdef GL_SGIS_multisample
15664
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
15665
        {
15666
          ret = GLEW_SGIS_multisample;
15667
          continue;
15668
        }
15669
#endif
15670
#ifdef GL_SGIS_pixel_texture
15671
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))
15672
        {
15673
          ret = GLEW_SGIS_pixel_texture;
15674
          continue;
15675
        }
15676
#endif
15677
#ifdef GL_SGIS_point_line_texgen
15678
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17))
15679
        {
15680
          ret = GLEW_SGIS_point_line_texgen;
15681
          continue;
15682
        }
15683
#endif
15684
#ifdef GL_SGIS_sharpen_texture
15685
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))
15686
        {
15687
          ret = GLEW_SGIS_sharpen_texture;
15688
          continue;
15689
        }
15690
#endif
15691
#ifdef GL_SGIS_texture4D
15692
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))
15693
        {
15694
          ret = GLEW_SGIS_texture4D;
15695
          continue;
15696
        }
15697
#endif
15698
#ifdef GL_SGIS_texture_border_clamp
15699
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
15700
        {
15701
          ret = GLEW_SGIS_texture_border_clamp;
15702
          continue;
15703
        }
15704
#endif
15705
#ifdef GL_SGIS_texture_edge_clamp
15706
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))
15707
        {
15708
          ret = GLEW_SGIS_texture_edge_clamp;
15709
          continue;
15710
        }
15711
#endif
15712
#ifdef GL_SGIS_texture_filter4
15713
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))
15714
        {
15715
          ret = GLEW_SGIS_texture_filter4;
15716
          continue;
15717
        }
15718
#endif
15719
#ifdef GL_SGIS_texture_lod
15720
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))
15721
        {
15722
          ret = GLEW_SGIS_texture_lod;
15723
          continue;
15724
        }
15725
#endif
15726
#ifdef GL_SGIS_texture_select
15727
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))
15728
        {
15729
          ret = GLEW_SGIS_texture_select;
15730
          continue;
15731
        }
15732
#endif
15733
      }
15734
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))
15735
      {
15736
#ifdef GL_SGIX_async
15737
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))
15738
        {
15739
          ret = GLEW_SGIX_async;
15740
          continue;
15741
        }
15742
#endif
15743
#ifdef GL_SGIX_async_histogram
15744
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))
15745
        {
15746
          ret = GLEW_SGIX_async_histogram;
15747
          continue;
15748
        }
15749
#endif
15750
#ifdef GL_SGIX_async_pixel
15751
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))
15752
        {
15753
          ret = GLEW_SGIX_async_pixel;
15754
          continue;
15755
        }
15756
#endif
15757
#ifdef GL_SGIX_blend_alpha_minmax
15758
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))
15759
        {
15760
          ret = GLEW_SGIX_blend_alpha_minmax;
15761
          continue;
15762
        }
15763
#endif
15764
#ifdef GL_SGIX_clipmap
15765
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))
15766
        {
15767
          ret = GLEW_SGIX_clipmap;
15768
          continue;
15769
        }
15770
#endif
15771
#ifdef GL_SGIX_convolution_accuracy
15772
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20))
15773
        {
15774
          ret = GLEW_SGIX_convolution_accuracy;
15775
          continue;
15776
        }
15777
#endif
15778
#ifdef GL_SGIX_depth_texture
15779
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
15780
        {
15781
          ret = GLEW_SGIX_depth_texture;
15782
          continue;
15783
        }
15784
#endif
15785
#ifdef GL_SGIX_flush_raster
15786
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))
15787
        {
15788
          ret = GLEW_SGIX_flush_raster;
15789
          continue;
15790
        }
15791
#endif
15792
#ifdef GL_SGIX_fog_offset
15793
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))
15794
        {
15795
          ret = GLEW_SGIX_fog_offset;
15796
          continue;
15797
        }
15798
#endif
15799
#ifdef GL_SGIX_fog_texture
15800
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))
15801
        {
15802
          ret = GLEW_SGIX_fog_texture;
15803
          continue;
15804
        }
15805
#endif
15806
#ifdef GL_SGIX_fragment_specular_lighting
15807
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))
15808
        {
15809
          ret = GLEW_SGIX_fragment_specular_lighting;
15810
          continue;
15811
        }
15812
#endif
15813
#ifdef GL_SGIX_framezoom
15814
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))
15815
        {
15816
          ret = GLEW_SGIX_framezoom;
15817
          continue;
15818
        }
15819
#endif
15820
#ifdef GL_SGIX_interlace
15821
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))
15822
        {
15823
          ret = GLEW_SGIX_interlace;
15824
          continue;
15825
        }
15826
#endif
15827
#ifdef GL_SGIX_ir_instrument1
15828
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))
15829
        {
15830
          ret = GLEW_SGIX_ir_instrument1;
15831
          continue;
15832
        }
15833
#endif
15834
#ifdef GL_SGIX_list_priority
15835
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))
15836
        {
15837
          ret = GLEW_SGIX_list_priority;
15838
          continue;
15839
        }
15840
#endif
15841
#ifdef GL_SGIX_pixel_texture
15842
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))
15843
        {
15844
          ret = GLEW_SGIX_pixel_texture;
15845
          continue;
15846
        }
15847
#endif
15848
#ifdef GL_SGIX_pixel_texture_bits
15849
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))
15850
        {
15851
          ret = GLEW_SGIX_pixel_texture_bits;
15852
          continue;
15853
        }
15854
#endif
15855
#ifdef GL_SGIX_reference_plane
15856
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))
15857
        {
15858
          ret = GLEW_SGIX_reference_plane;
15859
          continue;
15860
        }
15861
#endif
15862
#ifdef GL_SGIX_resample
15863
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))
15864
        {
15865
          ret = GLEW_SGIX_resample;
15866
          continue;
15867
        }
15868
#endif
15869
#ifdef GL_SGIX_shadow
15870
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
15871
        {
15872
          ret = GLEW_SGIX_shadow;
15873
          continue;
15874
        }
15875
#endif
15876
#ifdef GL_SGIX_shadow_ambient
15877
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))
15878
        {
15879
          ret = GLEW_SGIX_shadow_ambient;
15880
          continue;
15881
        }
15882
#endif
15883
#ifdef GL_SGIX_sprite
15884
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))
15885
        {
15886
          ret = GLEW_SGIX_sprite;
15887
          continue;
15888
        }
15889
#endif
15890
#ifdef GL_SGIX_tag_sample_buffer
15891
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))
15892
        {
15893
          ret = GLEW_SGIX_tag_sample_buffer;
15894
          continue;
15895
        }
15896
#endif
15897
#ifdef GL_SGIX_texture_add_env
15898
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))
15899
        {
15900
          ret = GLEW_SGIX_texture_add_env;
15901
          continue;
15902
        }
15903
#endif
15904
#ifdef GL_SGIX_texture_coordinate_clamp
15905
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))
15906
        {
15907
          ret = GLEW_SGIX_texture_coordinate_clamp;
15908
          continue;
15909
        }
15910
#endif
15911
#ifdef GL_SGIX_texture_lod_bias
15912
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
15913
        {
15914
          ret = GLEW_SGIX_texture_lod_bias;
15915
          continue;
15916
        }
15917
#endif
15918
#ifdef GL_SGIX_texture_multi_buffer
15919
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))
15920
        {
15921
          ret = GLEW_SGIX_texture_multi_buffer;
15922
          continue;
15923
        }
15924
#endif
15925
#ifdef GL_SGIX_texture_range
15926
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))
15927
        {
15928
          ret = GLEW_SGIX_texture_range;
15929
          continue;
15930
        }
15931
#endif
15932
#ifdef GL_SGIX_texture_scale_bias
15933
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))
15934
        {
15935
          ret = GLEW_SGIX_texture_scale_bias;
15936
          continue;
15937
        }
15938
#endif
15939
#ifdef GL_SGIX_vertex_preclip
15940
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))
15941
        {
15942
          ret = GLEW_SGIX_vertex_preclip;
15943
          continue;
15944
        }
15945
#endif
15946
#ifdef GL_SGIX_vertex_preclip_hint
15947
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))
15948
        {
15949
          ret = GLEW_SGIX_vertex_preclip_hint;
15950
          continue;
15951
        }
15952
#endif
15953
#ifdef GL_SGIX_ycrcb
15954
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))
15955
        {
15956
          ret = GLEW_SGIX_ycrcb;
15957
          continue;
15958
        }
15959
#endif
15960
      }
15961
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))
15962
      {
15963
#ifdef GL_SGI_color_matrix
15964
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))
15965
        {
15966
          ret = GLEW_SGI_color_matrix;
15967
          continue;
15968
        }
15969
#endif
15970
#ifdef GL_SGI_color_table
15971
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))
15972
        {
15973
          ret = GLEW_SGI_color_table;
15974
          continue;
15975
        }
15976
#endif
15977
#ifdef GL_SGI_texture_color_table
15978
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))
15979
        {
15980
          ret = GLEW_SGI_texture_color_table;
15981
          continue;
15982
        }
15983
#endif
15984
      }
15985
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))
15986
      {
15987
#ifdef GL_SUNX_constant_data
15988
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))
15989
        {
15990
          ret = GLEW_SUNX_constant_data;
15991
          continue;
15992
        }
15993
#endif
15994
      }
15995
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))
15996
      {
15997
#ifdef GL_SUN_convolution_border_modes
15998
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))
15999
        {
16000
          ret = GLEW_SUN_convolution_border_modes;
16001
          continue;
16002
        }
16003
#endif
16004
#ifdef GL_SUN_global_alpha
16005
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))
16006
        {
16007
          ret = GLEW_SUN_global_alpha;
16008
          continue;
16009
        }
16010
#endif
16011
#ifdef GL_SUN_mesh_array
16012
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))
16013
        {
16014
          ret = GLEW_SUN_mesh_array;
16015
          continue;
16016
        }
16017
#endif
16018
#ifdef GL_SUN_read_video_pixels
16019
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))
16020
        {
16021
          ret = GLEW_SUN_read_video_pixels;
16022
          continue;
16023
        }
16024
#endif
16025
#ifdef GL_SUN_slice_accum
16026
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))
16027
        {
16028
          ret = GLEW_SUN_slice_accum;
16029
          continue;
16030
        }
16031
#endif
16032
#ifdef GL_SUN_triangle_list
16033
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))
16034
        {
16035
          ret = GLEW_SUN_triangle_list;
16036
          continue;
16037
        }
16038
#endif
16039
#ifdef GL_SUN_vertex
16040
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))
16041
        {
16042
          ret = GLEW_SUN_vertex;
16043
          continue;
16044
        }
16045
#endif
16046
      }
16047
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))
16048
      {
16049
#ifdef GL_WIN_phong_shading
16050
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))
16051
        {
16052
          ret = GLEW_WIN_phong_shading;
16053
          continue;
16054
        }
16055
#endif
16056
#ifdef GL_WIN_specular_fog
16057
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))
16058
        {
16059
          ret = GLEW_WIN_specular_fog;
16060
          continue;
16061
        }
16062
#endif
16063
#ifdef GL_WIN_swap_hint
16064
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))
16065
        {
16066
          ret = GLEW_WIN_swap_hint;
16067
          continue;
16068
        }
16069
#endif
16070
      }
16071
    }
16072
    ret = (len == 0);
16073
  }
16074
  return ret;
16075
}
16076
 
16077
#if defined(_WIN32)
16078
 
16079
#if defined(GLEW_MX)
16080
GLboolean GLEWAPIENTRY wglewContextIsSupported (const WGLEWContext* ctx, const char* name)
16081
#else
16082
GLboolean GLEWAPIENTRY wglewIsSupported (const char* name)
16083
#endif
16084
{
16085
  GLubyte* pos = (GLubyte*)name;
16086
  GLuint len = _glewStrLen(pos);
16087
  GLboolean ret = GL_TRUE;
16088
  while (ret && len > 0)
16089
  {
16090
    if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))
16091
    {
16092
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
16093
      {
16094
#ifdef WGL_3DFX_multisample
16095
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16096
        {
16097
          ret = WGLEW_3DFX_multisample;
16098
          continue;
16099
        }
16100
#endif
16101
      }
16102
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4))
16103
      {
16104
#ifdef WGL_3DL_stereo_control
16105
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14))
16106
        {
16107
          ret = WGLEW_3DL_stereo_control;
16108
          continue;
16109
        }
16110
#endif
16111
      }
16112
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
16113
      {
16114
#ifdef WGL_AMD_gpu_association
16115
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
16116
        {
16117
          ret = WGLEW_AMD_gpu_association;
16118
          continue;
16119
        }
16120
#endif
16121
      }
16122
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
16123
      {
16124
#ifdef WGL_ARB_buffer_region
16125
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))
16126
        {
16127
          ret = WGLEW_ARB_buffer_region;
16128
          continue;
16129
        }
16130
#endif
16131
#ifdef WGL_ARB_create_context
16132
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))
16133
        {
16134
          ret = WGLEW_ARB_create_context;
16135
          continue;
16136
        }
16137
#endif
16138
#ifdef WGL_ARB_create_context_profile
16139
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
16140
        {
16141
          ret = WGLEW_ARB_create_context_profile;
16142
          continue;
16143
        }
16144
#endif
16145
#ifdef WGL_ARB_create_context_robustness
16146
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
16147
        {
16148
          ret = WGLEW_ARB_create_context_robustness;
16149
          continue;
16150
        }
16151
#endif
16152
#ifdef WGL_ARB_extensions_string
16153
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
16154
        {
16155
          ret = WGLEW_ARB_extensions_string;
16156
          continue;
16157
        }
16158
#endif
16159
#ifdef WGL_ARB_framebuffer_sRGB
16160
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
16161
        {
16162
          ret = WGLEW_ARB_framebuffer_sRGB;
16163
          continue;
16164
        }
16165
#endif
16166
#ifdef WGL_ARB_make_current_read
16167
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
16168
        {
16169
          ret = WGLEW_ARB_make_current_read;
16170
          continue;
16171
        }
16172
#endif
16173
#ifdef WGL_ARB_multisample
16174
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16175
        {
16176
          ret = WGLEW_ARB_multisample;
16177
          continue;
16178
        }
16179
#endif
16180
#ifdef WGL_ARB_pbuffer
16181
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
16182
        {
16183
          ret = WGLEW_ARB_pbuffer;
16184
          continue;
16185
        }
16186
#endif
16187
#ifdef WGL_ARB_pixel_format
16188
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))
16189
        {
16190
          ret = WGLEW_ARB_pixel_format;
16191
          continue;
16192
        }
16193
#endif
16194
#ifdef WGL_ARB_pixel_format_float
16195
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
16196
        {
16197
          ret = WGLEW_ARB_pixel_format_float;
16198
          continue;
16199
        }
16200
#endif
16201
#ifdef WGL_ARB_render_texture
16202
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))
16203
        {
16204
          ret = WGLEW_ARB_render_texture;
16205
          continue;
16206
        }
16207
#endif
16208
      }
16209
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
16210
      {
16211
#ifdef WGL_ATI_pixel_format_float
16212
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
16213
        {
16214
          ret = WGLEW_ATI_pixel_format_float;
16215
          continue;
16216
        }
16217
#endif
16218
#ifdef WGL_ATI_render_texture_rectangle
16219
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))
16220
        {
16221
          ret = WGLEW_ATI_render_texture_rectangle;
16222
          continue;
16223
        }
16224
#endif
16225
      }
16226
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
16227
      {
16228
#ifdef WGL_EXT_create_context_es2_profile
16229
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))
16230
        {
16231
          ret = WGLEW_EXT_create_context_es2_profile;
16232
          continue;
16233
        }
16234
#endif
16235
#ifdef WGL_EXT_create_context_es_profile
16236
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25))
16237
        {
16238
          ret = WGLEW_EXT_create_context_es_profile;
16239
          continue;
16240
        }
16241
#endif
16242
#ifdef WGL_EXT_depth_float
16243
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))
16244
        {
16245
          ret = WGLEW_EXT_depth_float;
16246
          continue;
16247
        }
16248
#endif
16249
#ifdef WGL_EXT_display_color_table
16250
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))
16251
        {
16252
          ret = WGLEW_EXT_display_color_table;
16253
          continue;
16254
        }
16255
#endif
16256
#ifdef WGL_EXT_extensions_string
16257
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
16258
        {
16259
          ret = WGLEW_EXT_extensions_string;
16260
          continue;
16261
        }
16262
#endif
16263
#ifdef WGL_EXT_framebuffer_sRGB
16264
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
16265
        {
16266
          ret = WGLEW_EXT_framebuffer_sRGB;
16267
          continue;
16268
        }
16269
#endif
16270
#ifdef WGL_EXT_make_current_read
16271
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
16272
        {
16273
          ret = WGLEW_EXT_make_current_read;
16274
          continue;
16275
        }
16276
#endif
16277
#ifdef WGL_EXT_multisample
16278
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16279
        {
16280
          ret = WGLEW_EXT_multisample;
16281
          continue;
16282
        }
16283
#endif
16284
#ifdef WGL_EXT_pbuffer
16285
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
16286
        {
16287
          ret = WGLEW_EXT_pbuffer;
16288
          continue;
16289
        }
16290
#endif
16291
#ifdef WGL_EXT_pixel_format
16292
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))
16293
        {
16294
          ret = WGLEW_EXT_pixel_format;
16295
          continue;
16296
        }
16297
#endif
16298
#ifdef WGL_EXT_pixel_format_packed_float
16299
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25))
16300
        {
16301
          ret = WGLEW_EXT_pixel_format_packed_float;
16302
          continue;
16303
        }
16304
#endif
16305
#ifdef WGL_EXT_swap_control
16306
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
16307
        {
16308
          ret = WGLEW_EXT_swap_control;
16309
          continue;
16310
        }
16311
#endif
16312
#ifdef WGL_EXT_swap_control_tear
16313
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17))
16314
        {
16315
          ret = WGLEW_EXT_swap_control_tear;
16316
          continue;
16317
        }
16318
#endif
16319
      }
16320
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))
16321
      {
16322
#ifdef WGL_I3D_digital_video_control
16323
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))
16324
        {
16325
          ret = WGLEW_I3D_digital_video_control;
16326
          continue;
16327
        }
16328
#endif
16329
#ifdef WGL_I3D_gamma
16330
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))
16331
        {
16332
          ret = WGLEW_I3D_gamma;
16333
          continue;
16334
        }
16335
#endif
16336
#ifdef WGL_I3D_genlock
16337
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))
16338
        {
16339
          ret = WGLEW_I3D_genlock;
16340
          continue;
16341
        }
16342
#endif
16343
#ifdef WGL_I3D_image_buffer
16344
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))
16345
        {
16346
          ret = WGLEW_I3D_image_buffer;
16347
          continue;
16348
        }
16349
#endif
16350
#ifdef WGL_I3D_swap_frame_lock
16351
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))
16352
        {
16353
          ret = WGLEW_I3D_swap_frame_lock;
16354
          continue;
16355
        }
16356
#endif
16357
#ifdef WGL_I3D_swap_frame_usage
16358
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))
16359
        {
16360
          ret = WGLEW_I3D_swap_frame_usage;
16361
          continue;
16362
        }
16363
#endif
16364
      }
16365
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
16366
      {
16367
#ifdef WGL_NV_DX_interop
16368
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop", 10))
16369
        {
16370
          ret = WGLEW_NV_DX_interop;
16371
          continue;
16372
        }
16373
#endif
16374
#ifdef WGL_NV_DX_interop2
16375
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop2", 11))
16376
        {
16377
          ret = WGLEW_NV_DX_interop2;
16378
          continue;
16379
        }
16380
#endif
16381
#ifdef WGL_NV_copy_image
16382
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
16383
        {
16384
          ret = WGLEW_NV_copy_image;
16385
          continue;
16386
        }
16387
#endif
16388
#ifdef WGL_NV_float_buffer
16389
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
16390
        {
16391
          ret = WGLEW_NV_float_buffer;
16392
          continue;
16393
        }
16394
#endif
16395
#ifdef WGL_NV_gpu_affinity
16396
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12))
16397
        {
16398
          ret = WGLEW_NV_gpu_affinity;
16399
          continue;
16400
        }
16401
#endif
16402
#ifdef WGL_NV_multisample_coverage
16403
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
16404
        {
16405
          ret = WGLEW_NV_multisample_coverage;
16406
          continue;
16407
        }
16408
#endif
16409
#ifdef WGL_NV_present_video
16410
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
16411
        {
16412
          ret = WGLEW_NV_present_video;
16413
          continue;
16414
        }
16415
#endif
16416
#ifdef WGL_NV_render_depth_texture
16417
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))
16418
        {
16419
          ret = WGLEW_NV_render_depth_texture;
16420
          continue;
16421
        }
16422
#endif
16423
#ifdef WGL_NV_render_texture_rectangle
16424
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))
16425
        {
16426
          ret = WGLEW_NV_render_texture_rectangle;
16427
          continue;
16428
        }
16429
#endif
16430
#ifdef WGL_NV_swap_group
16431
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
16432
        {
16433
          ret = WGLEW_NV_swap_group;
16434
          continue;
16435
        }
16436
#endif
16437
#ifdef WGL_NV_vertex_array_range
16438
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
16439
        {
16440
          ret = WGLEW_NV_vertex_array_range;
16441
          continue;
16442
        }
16443
#endif
16444
#ifdef WGL_NV_video_capture
16445
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
16446
        {
16447
          ret = WGLEW_NV_video_capture;
16448
          continue;
16449
        }
16450
#endif
16451
#ifdef WGL_NV_video_output
16452
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))
16453
        {
16454
          ret = WGLEW_NV_video_output;
16455
          continue;
16456
        }
16457
#endif
16458
      }
16459
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
16460
      {
16461
#ifdef WGL_OML_sync_control
16462
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))
16463
        {
16464
          ret = WGLEW_OML_sync_control;
16465
          continue;
16466
        }
16467
#endif
16468
      }
16469
    }
16470
    ret = (len == 0);
16471
  }
16472
  return ret;
16473
}
16474
 
16475
#elif !defined(__ANDROID__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
16476
 
16477
#if defined(GLEW_MX)
16478
GLboolean glxewContextIsSupported (const GLXEWContext* ctx, const char* name)
16479
#else
16480
GLboolean glxewIsSupported (const char* name)
16481
#endif
16482
{
16483
  GLubyte* pos = (GLubyte*)name;
16484
  GLuint len = _glewStrLen(pos);
16485
  GLboolean ret = GL_TRUE;
16486
  while (ret && len > 0)
16487
  {
16488
    if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))
16489
    {
16490
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))
16491
      {
16492
#ifdef GLX_VERSION_1_2
16493
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))
16494
        {
16495
          ret = GLXEW_VERSION_1_2;
16496
          continue;
16497
        }
16498
#endif
16499
#ifdef GLX_VERSION_1_3
16500
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))
16501
        {
16502
          ret = GLXEW_VERSION_1_3;
16503
          continue;
16504
        }
16505
#endif
16506
#ifdef GLX_VERSION_1_4
16507
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))
16508
        {
16509
          ret = GLXEW_VERSION_1_4;
16510
          continue;
16511
        }
16512
#endif
16513
      }
16514
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
16515
      {
16516
#ifdef GLX_3DFX_multisample
16517
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16518
        {
16519
          ret = GLXEW_3DFX_multisample;
16520
          continue;
16521
        }
16522
#endif
16523
      }
16524
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
16525
      {
16526
#ifdef GLX_AMD_gpu_association
16527
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
16528
        {
16529
          ret = GLXEW_AMD_gpu_association;
16530
          continue;
16531
        }
16532
#endif
16533
      }
16534
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
16535
      {
16536
#ifdef GLX_ARB_create_context
16537
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))
16538
        {
16539
          ret = GLXEW_ARB_create_context;
16540
          continue;
16541
        }
16542
#endif
16543
#ifdef GLX_ARB_create_context_profile
16544
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
16545
        {
16546
          ret = GLXEW_ARB_create_context_profile;
16547
          continue;
16548
        }
16549
#endif
16550
#ifdef GLX_ARB_create_context_robustness
16551
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
16552
        {
16553
          ret = GLXEW_ARB_create_context_robustness;
16554
          continue;
16555
        }
16556
#endif
16557
#ifdef GLX_ARB_fbconfig_float
16558
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))
16559
        {
16560
          ret = GLXEW_ARB_fbconfig_float;
16561
          continue;
16562
        }
16563
#endif
16564
#ifdef GLX_ARB_framebuffer_sRGB
16565
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
16566
        {
16567
          ret = GLXEW_ARB_framebuffer_sRGB;
16568
          continue;
16569
        }
16570
#endif
16571
#ifdef GLX_ARB_get_proc_address
16572
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))
16573
        {
16574
          ret = GLXEW_ARB_get_proc_address;
16575
          continue;
16576
        }
16577
#endif
16578
#ifdef GLX_ARB_multisample
16579
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16580
        {
16581
          ret = GLXEW_ARB_multisample;
16582
          continue;
16583
        }
16584
#endif
16585
#ifdef GLX_ARB_robustness_application_isolation
16586
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))
16587
        {
16588
          ret = GLXEW_ARB_robustness_application_isolation;
16589
          continue;
16590
        }
16591
#endif
16592
#ifdef GLX_ARB_robustness_share_group_isolation
16593
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))
16594
        {
16595
          ret = GLXEW_ARB_robustness_share_group_isolation;
16596
          continue;
16597
        }
16598
#endif
16599
#ifdef GLX_ARB_vertex_buffer_object
16600
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
16601
        {
16602
          ret = GLXEW_ARB_vertex_buffer_object;
16603
          continue;
16604
        }
16605
#endif
16606
      }
16607
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
16608
      {
16609
#ifdef GLX_ATI_pixel_format_float
16610
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
16611
        {
16612
          ret = GLXEW_ATI_pixel_format_float;
16613
          continue;
16614
        }
16615
#endif
16616
#ifdef GLX_ATI_render_texture
16617
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))
16618
        {
16619
          ret = GLXEW_ATI_render_texture;
16620
          continue;
16621
        }
16622
#endif
16623
      }
16624
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
16625
      {
16626
#ifdef GLX_EXT_create_context_es2_profile
16627
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))
16628
        {
16629
          ret = GLXEW_EXT_create_context_es2_profile;
16630
          continue;
16631
        }
16632
#endif
16633
#ifdef GLX_EXT_create_context_es_profile
16634
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25))
16635
        {
16636
          ret = GLXEW_EXT_create_context_es_profile;
16637
          continue;
16638
        }
16639
#endif
16640
#ifdef GLX_EXT_fbconfig_packed_float
16641
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21))
16642
        {
16643
          ret = GLXEW_EXT_fbconfig_packed_float;
16644
          continue;
16645
        }
16646
#endif
16647
#ifdef GLX_EXT_framebuffer_sRGB
16648
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
16649
        {
16650
          ret = GLXEW_EXT_framebuffer_sRGB;
16651
          continue;
16652
        }
16653
#endif
16654
#ifdef GLX_EXT_import_context
16655
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))
16656
        {
16657
          ret = GLXEW_EXT_import_context;
16658
          continue;
16659
        }
16660
#endif
16661
#ifdef GLX_EXT_scene_marker
16662
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))
16663
        {
16664
          ret = GLXEW_EXT_scene_marker;
16665
          continue;
16666
        }
16667
#endif
16668
#ifdef GLX_EXT_swap_control
16669
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
16670
        {
16671
          ret = GLXEW_EXT_swap_control;
16672
          continue;
16673
        }
16674
#endif
16675
#ifdef GLX_EXT_swap_control_tear
16676
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17))
16677
        {
16678
          ret = GLXEW_EXT_swap_control_tear;
16679
          continue;
16680
        }
16681
#endif
16682
#ifdef GLX_EXT_texture_from_pixmap
16683
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))
16684
        {
16685
          ret = GLXEW_EXT_texture_from_pixmap;
16686
          continue;
16687
        }
16688
#endif
16689
#ifdef GLX_EXT_visual_info
16690
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))
16691
        {
16692
          ret = GLXEW_EXT_visual_info;
16693
          continue;
16694
        }
16695
#endif
16696
#ifdef GLX_EXT_visual_rating
16697
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))
16698
        {
16699
          ret = GLXEW_EXT_visual_rating;
16700
          continue;
16701
        }
16702
#endif
16703
      }
16704
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
16705
      {
16706
#ifdef GLX_INTEL_swap_event
16707
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10))
16708
        {
16709
          ret = GLXEW_INTEL_swap_event;
16710
          continue;
16711
        }
16712
#endif
16713
      }
16714
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
16715
      {
16716
#ifdef GLX_MESA_agp_offset
16717
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))
16718
        {
16719
          ret = GLXEW_MESA_agp_offset;
16720
          continue;
16721
        }
16722
#endif
16723
#ifdef GLX_MESA_copy_sub_buffer
16724
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))
16725
        {
16726
          ret = GLXEW_MESA_copy_sub_buffer;
16727
          continue;
16728
        }
16729
#endif
16730
#ifdef GLX_MESA_pixmap_colormap
16731
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))
16732
        {
16733
          ret = GLXEW_MESA_pixmap_colormap;
16734
          continue;
16735
        }
16736
#endif
16737
#ifdef GLX_MESA_release_buffers
16738
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))
16739
        {
16740
          ret = GLXEW_MESA_release_buffers;
16741
          continue;
16742
        }
16743
#endif
16744
#ifdef GLX_MESA_set_3dfx_mode
16745
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))
16746
        {
16747
          ret = GLXEW_MESA_set_3dfx_mode;
16748
          continue;
16749
        }
16750
#endif
16751
#ifdef GLX_MESA_swap_control
16752
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
16753
        {
16754
          ret = GLXEW_MESA_swap_control;
16755
          continue;
16756
        }
16757
#endif
16758
      }
16759
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
16760
      {
16761
#ifdef GLX_NV_copy_image
16762
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
16763
        {
16764
          ret = GLXEW_NV_copy_image;
16765
          continue;
16766
        }
16767
#endif
16768
#ifdef GLX_NV_float_buffer
16769
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
16770
        {
16771
          ret = GLXEW_NV_float_buffer;
16772
          continue;
16773
        }
16774
#endif
16775
#ifdef GLX_NV_multisample_coverage
16776
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
16777
        {
16778
          ret = GLXEW_NV_multisample_coverage;
16779
          continue;
16780
        }
16781
#endif
16782
#ifdef GLX_NV_present_video
16783
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
16784
        {
16785
          ret = GLXEW_NV_present_video;
16786
          continue;
16787
        }
16788
#endif
16789
#ifdef GLX_NV_swap_group
16790
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
16791
        {
16792
          ret = GLXEW_NV_swap_group;
16793
          continue;
16794
        }
16795
#endif
16796
#ifdef GLX_NV_vertex_array_range
16797
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
16798
        {
16799
          ret = GLXEW_NV_vertex_array_range;
16800
          continue;
16801
        }
16802
#endif
16803
#ifdef GLX_NV_video_capture
16804
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
16805
        {
16806
          ret = GLXEW_NV_video_capture;
16807
          continue;
16808
        }
16809
#endif
16810
#ifdef GLX_NV_video_out
16811
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_out", 9))
16812
        {
16813
          ret = GLXEW_NV_video_out;
16814
          continue;
16815
        }
16816
#endif
16817
      }
16818
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
16819
      {
16820
#ifdef GLX_OML_swap_method
16821
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))
16822
        {
16823
          ret = GLXEW_OML_swap_method;
16824
          continue;
16825
        }
16826
#endif
16827
#ifdef GLX_OML_sync_control
16828
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))
16829
        {
16830
          ret = GLXEW_OML_sync_control;
16831
          continue;
16832
        }
16833
#endif
16834
      }
16835
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))
16836
      {
16837
#ifdef GLX_SGIS_blended_overlay
16838
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))
16839
        {
16840
          ret = GLXEW_SGIS_blended_overlay;
16841
          continue;
16842
        }
16843
#endif
16844
#ifdef GLX_SGIS_color_range
16845
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))
16846
        {
16847
          ret = GLXEW_SGIS_color_range;
16848
          continue;
16849
        }
16850
#endif
16851
#ifdef GLX_SGIS_multisample
16852
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16853
        {
16854
          ret = GLXEW_SGIS_multisample;
16855
          continue;
16856
        }
16857
#endif
16858
#ifdef GLX_SGIS_shared_multisample
16859
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))
16860
        {
16861
          ret = GLXEW_SGIS_shared_multisample;
16862
          continue;
16863
        }
16864
#endif
16865
      }
16866
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))
16867
      {
16868
#ifdef GLX_SGIX_fbconfig
16869
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))
16870
        {
16871
          ret = GLXEW_SGIX_fbconfig;
16872
          continue;
16873
        }
16874
#endif
16875
#ifdef GLX_SGIX_hyperpipe
16876
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9))
16877
        {
16878
          ret = GLXEW_SGIX_hyperpipe;
16879
          continue;
16880
        }
16881
#endif
16882
#ifdef GLX_SGIX_pbuffer
16883
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
16884
        {
16885
          ret = GLXEW_SGIX_pbuffer;
16886
          continue;
16887
        }
16888
#endif
16889
#ifdef GLX_SGIX_swap_barrier
16890
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))
16891
        {
16892
          ret = GLXEW_SGIX_swap_barrier;
16893
          continue;
16894
        }
16895
#endif
16896
#ifdef GLX_SGIX_swap_group
16897
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
16898
        {
16899
          ret = GLXEW_SGIX_swap_group;
16900
          continue;
16901
        }
16902
#endif
16903
#ifdef GLX_SGIX_video_resize
16904
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))
16905
        {
16906
          ret = GLXEW_SGIX_video_resize;
16907
          continue;
16908
        }
16909
#endif
16910
#ifdef GLX_SGIX_visual_select_group
16911
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))
16912
        {
16913
          ret = GLXEW_SGIX_visual_select_group;
16914
          continue;
16915
        }
16916
#endif
16917
      }
16918
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))
16919
      {
16920
#ifdef GLX_SGI_cushion
16921
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))
16922
        {
16923
          ret = GLXEW_SGI_cushion;
16924
          continue;
16925
        }
16926
#endif
16927
#ifdef GLX_SGI_make_current_read
16928
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
16929
        {
16930
          ret = GLXEW_SGI_make_current_read;
16931
          continue;
16932
        }
16933
#endif
16934
#ifdef GLX_SGI_swap_control
16935
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
16936
        {
16937
          ret = GLXEW_SGI_swap_control;
16938
          continue;
16939
        }
16940
#endif
16941
#ifdef GLX_SGI_video_sync
16942
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))
16943
        {
16944
          ret = GLXEW_SGI_video_sync;
16945
          continue;
16946
        }
16947
#endif
16948
      }
16949
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))
16950
      {
16951
#ifdef GLX_SUN_get_transparent_index
16952
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))
16953
        {
16954
          ret = GLXEW_SUN_get_transparent_index;
16955
          continue;
16956
        }
16957
#endif
16958
#ifdef GLX_SUN_video_resize
16959
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))
16960
        {
16961
          ret = GLXEW_SUN_video_resize;
16962
          continue;
16963
        }
16964
#endif
16965
      }
16966
    }
16967
    ret = (len == 0);
16968
  }
16969
  return ret;
16970
}
16971
 
16972
#endif /* _WIN32 */