Subversion Repositories gelsvn

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
667 khor 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
 
677 janba 32
#include <GL/glew.h>
667 khor 33
 
34
#if defined(_WIN32)
677 janba 35
#  include <GL/wglew.h>
36
#elif !defined(__ANDROID__) && !defined(__native_client__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))
37
#  include <GL/glxew.h>
667 khor 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 */
677 janba 169
#elif defined(__native_client__)
170
#  define glewGetProcAddress(name) NULL /* TODO */
667 khor 171
#else /* __linux */
172
#  define glewGetProcAddress(name) (*glXGetProcAddressARB)(name)
173
#endif
174
 
175
/*
176
 * Define GLboolean const cast.
177
 */
178
#define CONST_CAST(x) (*(GLboolean*)&x)
179
 
180
/*
181
 * GLEW, just like OpenGL or GLU, does not rely on the standard C library.
182
 * These functions implement the functionality required in this file.
183
 */
184
static GLuint _glewStrLen (const GLubyte* s)
185
{
186
  GLuint i=0;
187
  if (s == NULL) return 0;
188
  while (s[i] != '\0') i++;
189
  return i;
190
}
191
 
192
static GLuint _glewStrCLen (const GLubyte* s, GLubyte c)
193
{
194
  GLuint i=0;
195
  if (s == NULL) return 0;
196
  while (s[i] != '\0' && s[i] != c) i++;
197
  return (s[i] == '\0' || s[i] == c) ? i : 0;
198
}
199
 
200
static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n)
201
{
202
  GLuint i=0;
203
  if(a == NULL || b == NULL)
204
    return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE;
205
  while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++;
206
  return i == n ? GL_TRUE : GL_FALSE;
207
}
208
 
209
static GLboolean _glewStrSame1 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
210
{
211
  while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t'))
212
  {
213
    (*a)++;
214
    (*na)--;
215
  }
216
  if(*na >= nb)
217
  {
218
    GLuint i=0;
219
    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
220
    if(i == nb)
221
    {
222
      *a = *a + nb;
223
      *na = *na - nb;
224
      return GL_TRUE;
225
    }
226
  }
227
  return GL_FALSE;
228
}
229
 
230
static GLboolean _glewStrSame2 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
231
{
232
  if(*na >= nb)
233
  {
234
    GLuint i=0;
235
    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
236
    if(i == nb)
237
    {
238
      *a = *a + nb;
239
      *na = *na - nb;
240
      return GL_TRUE;
241
    }
242
  }
243
  return GL_FALSE;
244
}
245
 
246
static GLboolean _glewStrSame3 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
247
{
248
  if(*na >= nb)
249
  {
250
    GLuint i=0;
251
    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
252
    if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t'))
253
    {
254
      *a = *a + nb;
255
      *na = *na - nb;
256
      return GL_TRUE;
257
    }
258
  }
259
  return GL_FALSE;
260
}
261
 
262
/*
263
 * Search for name in the extensions string. Use of strstr()
264
 * is not sufficient because extension names can be prefixes of
265
 * other extension names. Could use strtok() but the constant
266
 * string returned by glGetString might be in read-only memory.
267
 */
268
static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end)
269
{
270
  const GLubyte* p;
271
  GLuint len = _glewStrLen((const GLubyte*)name);
272
  p = start;
273
  while (p < end)
274
  {
275
    GLuint n = _glewStrCLen(p, ' ');
276
    if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE;
277
    p += n+1;
278
  }
279
  return GL_FALSE;
280
}
281
 
282
#if !defined(_WIN32) || !defined(GLEW_MX)
283
 
284
PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;
285
PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;
286
PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;
287
PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;
288
 
289
PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;
290
PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;
291
PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;
292
PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;
293
PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;
294
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;
295
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;
296
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;
297
PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;
298
PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;
299
PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;
300
PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;
301
PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;
302
PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;
303
PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;
304
PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;
305
PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;
306
PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;
307
PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;
308
PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;
309
PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;
310
PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;
311
PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;
312
PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;
313
PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;
314
PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;
315
PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;
316
PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;
317
PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;
318
PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;
319
PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;
320
PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;
321
PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;
322
PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;
323
PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;
324
PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;
325
PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;
326
PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;
327
PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;
328
PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;
329
PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;
330
PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;
331
PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;
332
PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;
333
PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;
334
PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;
335
 
336
PFNGLBLENDCOLORPROC __glewBlendColor = NULL;
337
PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;
338
PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;
339
PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;
340
PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;
341
PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;
342
PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;
343
PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;
344
PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;
345
PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;
346
PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;
347
PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;
348
PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL;
349
PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL;
350
PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;
351
PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;
352
PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;
353
PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;
354
PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;
355
PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;
356
PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;
357
PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;
358
PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;
359
PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;
360
PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;
361
PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;
362
PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;
363
PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;
364
PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;
365
PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;
366
PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;
367
PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;
368
PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;
369
PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;
370
PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;
371
PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;
372
PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;
373
PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;
374
PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;
375
PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;
376
PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;
377
PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;
378
PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;
379
PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;
380
PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;
381
PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;
382
PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;
383
 
384
PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;
385
PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;
386
PFNGLBUFFERDATAPROC __glewBufferData = NULL;
387
PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;
388
PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;
389
PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;
390
PFNGLENDQUERYPROC __glewEndQuery = NULL;
391
PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;
392
PFNGLGENQUERIESPROC __glewGenQueries = NULL;
393
PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;
394
PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;
395
PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;
396
PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;
397
PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;
398
PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;
399
PFNGLISBUFFERPROC __glewIsBuffer = NULL;
400
PFNGLISQUERYPROC __glewIsQuery = NULL;
401
PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;
402
PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;
403
 
404
PFNGLATTACHSHADERPROC __glewAttachShader = NULL;
405
PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;
406
PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;
407
PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;
408
PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;
409
PFNGLCREATESHADERPROC __glewCreateShader = NULL;
410
PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;
411
PFNGLDELETESHADERPROC __glewDeleteShader = NULL;
412
PFNGLDETACHSHADERPROC __glewDetachShader = NULL;
413
PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;
414
PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;
415
PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;
416
PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;
417
PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;
418
PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;
419
PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;
420
PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;
421
PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;
422
PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;
423
PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;
424
PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;
425
PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;
426
PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;
427
PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;
428
PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;
429
PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;
430
PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;
431
PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;
432
PFNGLISPROGRAMPROC __glewIsProgram = NULL;
433
PFNGLISSHADERPROC __glewIsShader = NULL;
434
PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;
435
PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;
436
PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;
437
PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;
438
PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;
439
PFNGLUNIFORM1FPROC __glewUniform1f = NULL;
440
PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;
441
PFNGLUNIFORM1IPROC __glewUniform1i = NULL;
442
PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;
443
PFNGLUNIFORM2FPROC __glewUniform2f = NULL;
444
PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;
445
PFNGLUNIFORM2IPROC __glewUniform2i = NULL;
446
PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;
447
PFNGLUNIFORM3FPROC __glewUniform3f = NULL;
448
PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;
449
PFNGLUNIFORM3IPROC __glewUniform3i = NULL;
450
PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;
451
PFNGLUNIFORM4FPROC __glewUniform4f = NULL;
452
PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;
453
PFNGLUNIFORM4IPROC __glewUniform4i = NULL;
454
PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;
455
PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;
456
PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;
457
PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;
458
PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;
459
PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;
460
PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;
461
PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;
462
PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;
463
PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;
464
PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;
465
PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;
466
PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;
467
PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;
468
PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;
469
PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;
470
PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;
471
PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;
472
PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;
473
PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;
474
PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;
475
PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;
476
PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;
477
PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;
478
PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;
479
PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;
480
PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;
481
PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;
482
PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;
483
PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;
484
PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;
485
PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;
486
PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;
487
PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;
488
PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;
489
PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;
490
PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;
491
PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;
492
PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;
493
PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;
494
PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;
495
PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;
496
PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;
497
 
498
PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;
499
PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;
500
PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;
501
PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;
502
PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;
503
PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;
504
 
505
PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL;
506
PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL;
507
PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL;
508
PFNGLCLAMPCOLORPROC __glewClampColor = NULL;
509
PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL;
510
PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL;
511
PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL;
512
PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL;
513
PFNGLCOLORMASKIPROC __glewColorMaski = NULL;
514
PFNGLDISABLEIPROC __glewDisablei = NULL;
515
PFNGLENABLEIPROC __glewEnablei = NULL;
516
PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL;
517
PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL;
518
PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL;
519
PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL;
520
PFNGLGETSTRINGIPROC __glewGetStringi = NULL;
521
PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL;
522
PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL;
523
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL;
524
PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL;
525
PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL;
526
PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL;
527
PFNGLISENABLEDIPROC __glewIsEnabledi = NULL;
528
PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL;
529
PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL;
530
PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL;
531
PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL;
532
PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL;
533
PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL;
534
PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL;
535
PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL;
536
PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL;
537
PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL;
538
PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL;
539
PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL;
540
PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL;
541
PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL;
542
PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL;
543
PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL;
544
PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL;
545
PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL;
546
PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL;
547
PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL;
548
PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL;
549
PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL;
550
PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL;
551
PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL;
552
PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL;
553
PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL;
554
PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL;
555
PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL;
556
PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL;
557
PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL;
558
PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL;
559
PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL;
560
 
561
PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL;
562
PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL;
563
PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL;
564
PFNGLTEXBUFFERPROC __glewTexBuffer = NULL;
565
 
566
PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL;
567
PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL;
568
PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL;
569
 
570
PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL;
571
 
572
PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL;
573
PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL;
574
PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL;
575
PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL;
576
PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL;
577
 
578
PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;
579
 
580
PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL;
581
PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD = NULL;
582
PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD = NULL;
583
PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD = NULL;
584
 
585
PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL;
586
PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL;
587
PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL;
588
PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL;
589
 
677 janba 590
PFNGLVERTEXATTRIBPARAMETERIAMDPROC __glewVertexAttribParameteriAMD = NULL;
591
 
667 khor 592
PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL;
593
PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD = NULL;
594
 
595
PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD = NULL;
596
PFNGLGENNAMESAMDPROC __glewGenNamesAMD = NULL;
597
PFNGLISNAMEAMDPROC __glewIsNameAMD = NULL;
598
 
599
PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL;
600
PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL;
601
PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL;
602
PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL;
603
PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL;
604
PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL;
605
PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL;
606
PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL;
607
PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL;
608
PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL;
609
PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL;
610
 
611
PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD = NULL;
612
 
677 janba 613
PFNGLTEXSTORAGESPARSEAMDPROC __glewTexStorageSparseAMD = NULL;
614
PFNGLTEXTURESTORAGESPARSEAMDPROC __glewTextureStorageSparseAMD = NULL;
615
 
667 khor 616
PFNGLSTENCILOPVALUEAMDPROC __glewStencilOpValueAMD = NULL;
617
 
618
PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL;
619
PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL;
620
 
677 janba 621
PFNGLBLITFRAMEBUFFERANGLEPROC __glewBlitFramebufferANGLE = NULL;
622
 
623
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC __glewRenderbufferStorageMultisampleANGLE = NULL;
624
 
625
PFNGLDRAWARRAYSINSTANCEDANGLEPROC __glewDrawArraysInstancedANGLE = NULL;
626
PFNGLDRAWELEMENTSINSTANCEDANGLEPROC __glewDrawElementsInstancedANGLE = NULL;
627
PFNGLVERTEXATTRIBDIVISORANGLEPROC __glewVertexAttribDivisorANGLE = NULL;
628
 
629
PFNGLBEGINQUERYANGLEPROC __glewBeginQueryANGLE = NULL;
630
PFNGLDELETEQUERIESANGLEPROC __glewDeleteQueriesANGLE = NULL;
631
PFNGLENDQUERYANGLEPROC __glewEndQueryANGLE = NULL;
632
PFNGLGENQUERIESANGLEPROC __glewGenQueriesANGLE = NULL;
633
PFNGLGETQUERYOBJECTI64VANGLEPROC __glewGetQueryObjecti64vANGLE = NULL;
634
PFNGLGETQUERYOBJECTIVANGLEPROC __glewGetQueryObjectivANGLE = NULL;
635
PFNGLGETQUERYOBJECTUI64VANGLEPROC __glewGetQueryObjectui64vANGLE = NULL;
636
PFNGLGETQUERYOBJECTUIVANGLEPROC __glewGetQueryObjectuivANGLE = NULL;
637
PFNGLGETQUERYIVANGLEPROC __glewGetQueryivANGLE = NULL;
638
PFNGLISQUERYANGLEPROC __glewIsQueryANGLE = NULL;
639
PFNGLQUERYCOUNTERANGLEPROC __glewQueryCounterANGLE = NULL;
640
 
641
PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC __glewGetTranslatedShaderSourceANGLE = NULL;
642
 
667 khor 643
PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;
644
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;
645
PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;
646
PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;
647
PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;
648
 
649
PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;
650
PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;
651
PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;
652
PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;
653
PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;
654
PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;
655
PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;
656
PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;
657
 
658
PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;
659
PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;
660
 
661
PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL;
662
PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL;
663
PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL;
664
 
665
PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;
666
PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;
667
 
668
PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;
669
PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;
670
PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;
671
PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;
672
 
673
PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;
674
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;
675
PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;
676
 
677
PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL;
678
PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL;
679
PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL;
680
PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL;
681
PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL;
682
PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL;
683
PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL;
684
 
685
PFNGLCLEARDEPTHFPROC __glewClearDepthf = NULL;
686
PFNGLDEPTHRANGEFPROC __glewDepthRangef = NULL;
687
PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat = NULL;
688
PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler = NULL;
689
PFNGLSHADERBINARYPROC __glewShaderBinary = NULL;
690
 
691
PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance = NULL;
692
PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance = NULL;
693
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance = NULL;
694
 
677 janba 695
PFNGLGETIMAGEHANDLEARBPROC __glewGetImageHandleARB = NULL;
696
PFNGLGETTEXTUREHANDLEARBPROC __glewGetTextureHandleARB = NULL;
697
PFNGLGETTEXTURESAMPLERHANDLEARBPROC __glewGetTextureSamplerHandleARB = NULL;
698
PFNGLGETVERTEXATTRIBLUI64VARBPROC __glewGetVertexAttribLui64vARB = NULL;
699
PFNGLISIMAGEHANDLERESIDENTARBPROC __glewIsImageHandleResidentARB = NULL;
700
PFNGLISTEXTUREHANDLERESIDENTARBPROC __glewIsTextureHandleResidentARB = NULL;
701
PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC __glewMakeImageHandleNonResidentARB = NULL;
702
PFNGLMAKEIMAGEHANDLERESIDENTARBPROC __glewMakeImageHandleResidentARB = NULL;
703
PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC __glewMakeTextureHandleNonResidentARB = NULL;
704
PFNGLMAKETEXTUREHANDLERESIDENTARBPROC __glewMakeTextureHandleResidentARB = NULL;
705
PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC __glewProgramUniformHandleui64ARB = NULL;
706
PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC __glewProgramUniformHandleui64vARB = NULL;
707
PFNGLUNIFORMHANDLEUI64ARBPROC __glewUniformHandleui64ARB = NULL;
708
PFNGLUNIFORMHANDLEUI64VARBPROC __glewUniformHandleui64vARB = NULL;
709
PFNGLVERTEXATTRIBL1UI64ARBPROC __glewVertexAttribL1ui64ARB = NULL;
710
PFNGLVERTEXATTRIBL1UI64VARBPROC __glewVertexAttribL1ui64vARB = NULL;
711
 
667 khor 712
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL;
713
PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL;
714
 
677 janba 715
PFNGLBUFFERSTORAGEPROC __glewBufferStorage = NULL;
716
PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL;
717
 
667 khor 718
PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL;
719
 
720
PFNGLCLEARBUFFERDATAPROC __glewClearBufferData = NULL;
721
PFNGLCLEARBUFFERSUBDATAPROC __glewClearBufferSubData = NULL;
722
PFNGLCLEARNAMEDBUFFERDATAEXTPROC __glewClearNamedBufferDataEXT = NULL;
723
PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC __glewClearNamedBufferSubDataEXT = NULL;
724
 
677 janba 725
PFNGLCLEARTEXIMAGEPROC __glewClearTexImage = NULL;
726
PFNGLCLEARTEXSUBIMAGEPROC __glewClearTexSubImage = NULL;
727
 
667 khor 728
PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;
729
 
730
PFNGLDISPATCHCOMPUTEPROC __glewDispatchCompute = NULL;
731
PFNGLDISPATCHCOMPUTEINDIRECTPROC __glewDispatchComputeIndirect = NULL;
732
 
677 janba 733
PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC __glewDispatchComputeGroupSizeARB = NULL;
734
 
667 khor 735
PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL;
736
 
737
PFNGLCOPYIMAGESUBDATAPROC __glewCopyImageSubData = NULL;
738
 
739
PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB = NULL;
740
PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB = NULL;
741
PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB = NULL;
742
PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB = NULL;
743
 
744
PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;
745
 
746
PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL;
747
PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL;
748
PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL;
749
PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL;
750
 
751
PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL;
752
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL;
753
PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL;
754
PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL;
755
 
756
PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL;
757
PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL;
758
 
759
PFNGLFRAMEBUFFERPARAMETERIPROC __glewFramebufferParameteri = NULL;
760
PFNGLGETFRAMEBUFFERPARAMETERIVPROC __glewGetFramebufferParameteriv = NULL;
761
PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC __glewGetNamedFramebufferParameterivEXT = NULL;
762
PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC __glewNamedFramebufferParameteriEXT = NULL;
763
 
764
PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL;
765
PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL;
766
PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL;
767
PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL;
768
PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL;
769
PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL;
770
PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL;
771
PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL;
772
PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL;
773
PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL;
774
PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL;
775
PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL;
776
PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL;
777
PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL;
778
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL;
779
PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL;
780
PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL;
781
PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL;
782
PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL;
783
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL;
784
 
785
PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL;
786
PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL;
787
PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL;
788
PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL;
789
 
790
PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary = NULL;
791
PFNGLPROGRAMBINARYPROC __glewProgramBinary = NULL;
792
PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri = NULL;
793
 
794
PFNGLGETUNIFORMDVPROC __glewGetUniformdv = NULL;
795
PFNGLUNIFORM1DPROC __glewUniform1d = NULL;
796
PFNGLUNIFORM1DVPROC __glewUniform1dv = NULL;
797
PFNGLUNIFORM2DPROC __glewUniform2d = NULL;
798
PFNGLUNIFORM2DVPROC __glewUniform2dv = NULL;
799
PFNGLUNIFORM3DPROC __glewUniform3d = NULL;
800
PFNGLUNIFORM3DVPROC __glewUniform3dv = NULL;
801
PFNGLUNIFORM4DPROC __glewUniform4d = NULL;
802
PFNGLUNIFORM4DVPROC __glewUniform4dv = NULL;
803
PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv = NULL;
804
PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv = NULL;
805
PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv = NULL;
806
PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv = NULL;
807
PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv = NULL;
808
PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv = NULL;
809
PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv = NULL;
810
PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv = NULL;
811
PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv = NULL;
812
 
813
PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;
814
PFNGLCOLORTABLEPROC __glewColorTable = NULL;
815
PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;
816
PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;
817
PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;
818
PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;
819
PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;
820
PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;
821
PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;
822
PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;
823
PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;
824
PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;
825
PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;
826
PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;
827
PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;
828
PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;
829
PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;
830
PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;
831
PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;
832
PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;
833
PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;
834
PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;
835
PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;
836
PFNGLGETMINMAXPROC __glewGetMinmax = NULL;
837
PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;
838
PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;
839
PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;
840
PFNGLHISTOGRAMPROC __glewHistogram = NULL;
841
PFNGLMINMAXPROC __glewMinmax = NULL;
842
PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;
843
PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;
844
PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;
845
 
677 janba 846
PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC __glewMultiDrawArraysIndirectCountARB = NULL;
847
PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC __glewMultiDrawElementsIndirectCountARB = NULL;
848
 
667 khor 849
PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL;
850
PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL;
851
PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL;
852
 
853
PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ = NULL;
854
 
855
PFNGLGETINTERNALFORMATI64VPROC __glewGetInternalformati64v = NULL;
856
 
857
PFNGLINVALIDATEBUFFERDATAPROC __glewInvalidateBufferData = NULL;
858
PFNGLINVALIDATEBUFFERSUBDATAPROC __glewInvalidateBufferSubData = NULL;
859
PFNGLINVALIDATEFRAMEBUFFERPROC __glewInvalidateFramebuffer = NULL;
860
PFNGLINVALIDATESUBFRAMEBUFFERPROC __glewInvalidateSubFramebuffer = NULL;
861
PFNGLINVALIDATETEXIMAGEPROC __glewInvalidateTexImage = NULL;
862
PFNGLINVALIDATETEXSUBIMAGEPROC __glewInvalidateTexSubImage = NULL;
863
 
864
PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL;
865
PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL;
866
 
867
PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;
868
PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;
869
PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;
870
PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;
871
PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;
872
 
677 janba 873
PFNGLBINDBUFFERSBASEPROC __glewBindBuffersBase = NULL;
874
PFNGLBINDBUFFERSRANGEPROC __glewBindBuffersRange = NULL;
875
PFNGLBINDIMAGETEXTURESPROC __glewBindImageTextures = NULL;
876
PFNGLBINDSAMPLERSPROC __glewBindSamplers = NULL;
877
PFNGLBINDTEXTURESPROC __glewBindTextures = NULL;
878
PFNGLBINDVERTEXBUFFERSPROC __glewBindVertexBuffers = NULL;
879
 
667 khor 880
PFNGLMULTIDRAWARRAYSINDIRECTPROC __glewMultiDrawArraysIndirect = NULL;
881
PFNGLMULTIDRAWELEMENTSINDIRECTPROC __glewMultiDrawElementsIndirect = NULL;
882
 
883
PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;
884
 
885
PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;
886
PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;
887
PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;
888
PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;
889
PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;
890
PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;
891
PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;
892
PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;
893
PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;
894
PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;
895
PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;
896
PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;
897
PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;
898
PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;
899
PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;
900
PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;
901
PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;
902
PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;
903
PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;
904
PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;
905
PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;
906
PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;
907
PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;
908
PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;
909
PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;
910
PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;
911
PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;
912
PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;
913
PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;
914
PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;
915
PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;
916
PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;
917
PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;
918
PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;
919
 
920
PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;
921
PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;
922
PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;
923
PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;
924
PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;
925
PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;
926
PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;
927
PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;
928
 
929
PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;
930
PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;
931
 
932
PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv = NULL;
933
PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex = NULL;
934
PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation = NULL;
935
PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC __glewGetProgramResourceLocationIndex = NULL;
936
PFNGLGETPROGRAMRESOURCENAMEPROC __glewGetProgramResourceName = NULL;
937
PFNGLGETPROGRAMRESOURCEIVPROC __glewGetProgramResourceiv = NULL;
938
 
939
PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL;
940
 
941
PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB = NULL;
942
PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB = NULL;
943
PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB = NULL;
944
PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB = NULL;
945
PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB = NULL;
946
PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB = NULL;
947
PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB = NULL;
948
PFNGLGETNMAPIVARBPROC __glewGetnMapivARB = NULL;
949
PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB = NULL;
950
PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB = NULL;
951
PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB = NULL;
952
PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB = NULL;
953
PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB = NULL;
954
PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB = NULL;
955
PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB = NULL;
956
PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB = NULL;
957
PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB = NULL;
958
PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL;
959
PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL;
960
PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL;
961
 
962
PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL;
963
 
964
PFNGLBINDSAMPLERPROC __glewBindSampler = NULL;
965
PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL;
966
PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL;
967
PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL;
968
PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL;
969
PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL;
970
PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL;
971
PFNGLISSAMPLERPROC __glewIsSampler = NULL;
972
PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL;
973
PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL;
974
PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL;
975
PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL;
976
PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL;
977
PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL;
978
 
979
PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram = NULL;
980
PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline = NULL;
981
PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv = NULL;
982
PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines = NULL;
983
PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines = NULL;
984
PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog = NULL;
985
PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv = NULL;
986
PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline = NULL;
987
PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d = NULL;
988
PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv = NULL;
989
PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f = NULL;
990
PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv = NULL;
991
PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i = NULL;
992
PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv = NULL;
993
PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui = NULL;
994
PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv = NULL;
995
PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d = NULL;
996
PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv = NULL;
997
PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f = NULL;
998
PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv = NULL;
999
PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i = NULL;
1000
PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv = NULL;
1001
PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui = NULL;
1002
PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv = NULL;
1003
PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d = NULL;
1004
PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv = NULL;
1005
PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f = NULL;
1006
PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv = NULL;
1007
PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i = NULL;
1008
PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv = NULL;
1009
PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui = NULL;
1010
PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv = NULL;
1011
PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d = NULL;
1012
PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv = NULL;
1013
PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f = NULL;
1014
PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv = NULL;
1015
PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i = NULL;
1016
PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv = NULL;
1017
PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui = NULL;
1018
PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv = NULL;
1019
PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv = NULL;
1020
PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv = NULL;
1021
PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv = NULL;
1022
PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv = NULL;
1023
PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv = NULL;
1024
PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv = NULL;
1025
PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv = NULL;
1026
PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv = NULL;
1027
PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv = NULL;
1028
PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv = NULL;
1029
PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv = NULL;
1030
PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv = NULL;
1031
PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv = NULL;
1032
PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv = NULL;
1033
PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv = NULL;
1034
PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv = NULL;
1035
PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv = NULL;
1036
PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv = NULL;
1037
PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages = NULL;
1038
PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline = NULL;
1039
 
1040
PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv = NULL;
1041
 
1042
PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture = NULL;
1043
PFNGLMEMORYBARRIERPROC __glewMemoryBarrier = NULL;
1044
 
1045
PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;
1046
PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;
1047
PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;
1048
PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;
1049
PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;
1050
PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;
1051
PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;
1052
PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;
1053
PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;
1054
PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;
1055
PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;
1056
PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;
1057
PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;
1058
PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;
1059
PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;
1060
PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;
1061
PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;
1062
PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;
1063
PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;
1064
PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;
1065
PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;
1066
PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;
1067
PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;
1068
PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;
1069
PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;
1070
PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;
1071
PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;
1072
PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;
1073
PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;
1074
PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;
1075
PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;
1076
PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;
1077
PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;
1078
PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;
1079
PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;
1080
PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;
1081
PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;
1082
PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;
1083
PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;
1084
 
1085
PFNGLSHADERSTORAGEBLOCKBINDINGPROC __glewShaderStorageBlockBinding = NULL;
1086
 
1087
PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL;
1088
PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL;
1089
PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL;
1090
PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL;
1091
PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL;
1092
PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL;
1093
PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL;
1094
PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL;
1095
 
1096
PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL;
1097
PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL;
1098
PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL;
1099
PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL;
1100
PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL;
1101
PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL;
1102
 
677 janba 1103
PFNGLTEXPAGECOMMITMENTARBPROC __glewTexPageCommitmentARB = NULL;
1104
PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL;
1105
 
667 khor 1106
PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL;
1107
PFNGLDELETESYNCPROC __glewDeleteSync = NULL;
1108
PFNGLFENCESYNCPROC __glewFenceSync = NULL;
1109
PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL;
1110
PFNGLGETSYNCIVPROC __glewGetSynciv = NULL;
1111
PFNGLISSYNCPROC __glewIsSync = NULL;
1112
PFNGLWAITSYNCPROC __glewWaitSync = NULL;
1113
 
1114
PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL;
1115
PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL;
1116
 
1117
PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL;
1118
 
1119
PFNGLTEXBUFFERRANGEPROC __glewTexBufferRange = NULL;
1120
PFNGLTEXTUREBUFFERRANGEEXTPROC __glewTextureBufferRangeEXT = NULL;
1121
 
1122
PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;
1123
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;
1124
PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;
1125
PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;
1126
PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;
1127
PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;
1128
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;
1129
 
1130
PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL;
1131
PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL;
1132
PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL;
1133
PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL;
1134
 
1135
PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL;
1136
PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL;
1137
PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL;
1138
PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL;
1139
PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL;
1140
PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL;
1141
 
1142
PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample = NULL;
1143
PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample = NULL;
1144
PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC __glewTextureStorage2DMultisampleEXT = NULL;
1145
PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC __glewTextureStorage3DMultisampleEXT = NULL;
1146
 
1147
PFNGLTEXTUREVIEWPROC __glewTextureView = NULL;
1148
 
1149
PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL;
1150
PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL;
1151
PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL;
1152
 
1153
PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL;
1154
PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL;
1155
PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL;
1156
PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL;
1157
PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL;
1158
PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL;
1159
PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL;
1160
 
1161
PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL;
1162
PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL;
1163
PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL;
1164
PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL;
1165
 
1166
PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced = NULL;
1167
PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced = NULL;
1168
 
1169
PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;
1170
PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;
1171
PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;
1172
PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;
1173
 
1174
PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;
1175
PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;
1176
PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL;
1177
PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL;
1178
PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL;
1179
PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL;
1180
PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;
1181
PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL;
1182
PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL;
1183
PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL;
1184
 
1185
PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL;
1186
PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL;
1187
PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL;
1188
PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL;
1189
 
1190
PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv = NULL;
1191
PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d = NULL;
1192
PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv = NULL;
1193
PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d = NULL;
1194
PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv = NULL;
1195
PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d = NULL;
1196
PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv = NULL;
1197
PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d = NULL;
1198
PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv = NULL;
1199
PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer = NULL;
1200
 
1201
PFNGLBINDVERTEXBUFFERPROC __glewBindVertexBuffer = NULL;
1202
PFNGLVERTEXATTRIBBINDINGPROC __glewVertexAttribBinding = NULL;
1203
PFNGLVERTEXATTRIBFORMATPROC __glewVertexAttribFormat = NULL;
1204
PFNGLVERTEXATTRIBIFORMATPROC __glewVertexAttribIFormat = NULL;
1205
PFNGLVERTEXATTRIBLFORMATPROC __glewVertexAttribLFormat = NULL;
1206
PFNGLVERTEXBINDINGDIVISORPROC __glewVertexBindingDivisor = NULL;
1207
 
1208
PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;
1209
PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;
1210
PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;
1211
PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;
1212
PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;
1213
PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;
1214
PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;
1215
PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;
1216
PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;
1217
PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;
1218
 
1219
PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;
1220
PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;
1221
PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;
1222
PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;
1223
PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;
1224
PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;
1225
PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;
1226
PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;
1227
PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;
1228
PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;
1229
PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;
1230
 
1231
PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;
1232
PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;
1233
PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;
1234
PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;
1235
PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;
1236
PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;
1237
PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;
1238
PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;
1239
PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;
1240
PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;
1241
PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;
1242
PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;
1243
PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;
1244
PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;
1245
PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;
1246
PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;
1247
PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;
1248
PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;
1249
PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;
1250
PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;
1251
PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;
1252
PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;
1253
PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;
1254
PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;
1255
PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;
1256
PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;
1257
PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;
1258
PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;
1259
PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;
1260
PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;
1261
PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;
1262
PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;
1263
PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;
1264
PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;
1265
PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;
1266
PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;
1267
PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;
1268
PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;
1269
PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;
1270
PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;
1271
PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;
1272
PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;
1273
PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;
1274
PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;
1275
PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;
1276
PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;
1277
PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;
1278
PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;
1279
PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;
1280
PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;
1281
PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;
1282
PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;
1283
PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;
1284
PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;
1285
PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;
1286
PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;
1287
PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;
1288
PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;
1289
PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;
1290
PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;
1291
PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;
1292
PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;
1293
 
1294
PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;
1295
PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;
1296
PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;
1297
 
1298
PFNGLCOLORP3UIPROC __glewColorP3ui = NULL;
1299
PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL;
1300
PFNGLCOLORP4UIPROC __glewColorP4ui = NULL;
1301
PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL;
1302
PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL;
1303
PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL;
1304
PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL;
1305
PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL;
1306
PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL;
1307
PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL;
1308
PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL;
1309
PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL;
1310
PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL;
1311
PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL;
1312
PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL;
1313
PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL;
1314
PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL;
1315
PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL;
1316
PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL;
1317
PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL;
1318
PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL;
1319
PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL;
1320
PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL;
1321
PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL;
1322
PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL;
1323
PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL;
1324
PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL;
1325
PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL;
1326
PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL;
1327
PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL;
1328
PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL;
1329
PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL;
1330
PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL;
1331
PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL;
1332
PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL;
1333
PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL;
1334
PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL;
1335
PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL;
1336
 
1337
PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv = NULL;
1338
PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed = NULL;
1339
PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v = NULL;
1340
PFNGLGETFLOATI_VPROC __glewGetFloati_v = NULL;
1341
PFNGLSCISSORARRAYVPROC __glewScissorArrayv = NULL;
1342
PFNGLSCISSORINDEXEDPROC __glewScissorIndexed = NULL;
1343
PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv = NULL;
1344
PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv = NULL;
1345
PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf = NULL;
1346
PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv = NULL;
1347
 
1348
PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;
1349
PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;
1350
PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;
1351
PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;
1352
PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;
1353
PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;
1354
PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;
1355
PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;
1356
PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;
1357
PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;
1358
PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;
1359
PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;
1360
PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;
1361
PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;
1362
PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;
1363
PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;
1364
 
1365
PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;
1366
 
1367
PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;
1368
PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;
1369
PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;
1370
 
1371
PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;
1372
PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;
1373
PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;
1374
PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;
1375
 
1376
PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;
1377
PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;
1378
PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;
1379
PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;
1380
PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;
1381
PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;
1382
PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;
1383
PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;
1384
PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;
1385
PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;
1386
PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;
1387
PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;
1388
PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;
1389
PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;
1390
 
1391
PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;
1392
PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;
1393
 
1394
PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI = NULL;
1395
PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI = NULL;
1396
 
1397
PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;
1398
PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;
1399
 
1400
PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;
1401
PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;
1402
PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;
1403
PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;
1404
PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;
1405
PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;
1406
PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;
1407
PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;
1408
PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;
1409
PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;
1410
PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;
1411
PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;
1412
 
1413
PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;
1414
PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;
1415
PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;
1416
 
1417
PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;
1418
PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;
1419
PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;
1420
PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;
1421
PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;
1422
PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;
1423
PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;
1424
PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;
1425
PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;
1426
PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;
1427
PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;
1428
PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;
1429
PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;
1430
PFNGLVERTEXSTREAM1DATIPROC __glewVertexStream1dATI = NULL;
1431
PFNGLVERTEXSTREAM1DVATIPROC __glewVertexStream1dvATI = NULL;
1432
PFNGLVERTEXSTREAM1FATIPROC __glewVertexStream1fATI = NULL;
1433
PFNGLVERTEXSTREAM1FVATIPROC __glewVertexStream1fvATI = NULL;
1434
PFNGLVERTEXSTREAM1IATIPROC __glewVertexStream1iATI = NULL;
1435
PFNGLVERTEXSTREAM1IVATIPROC __glewVertexStream1ivATI = NULL;
1436
PFNGLVERTEXSTREAM1SATIPROC __glewVertexStream1sATI = NULL;
1437
PFNGLVERTEXSTREAM1SVATIPROC __glewVertexStream1svATI = NULL;
1438
PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;
1439
PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;
1440
PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;
1441
PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;
1442
PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;
1443
PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;
1444
PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;
1445
PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;
1446
PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;
1447
PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;
1448
PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;
1449
PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;
1450
PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;
1451
PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;
1452
PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;
1453
PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;
1454
PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;
1455
PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;
1456
PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;
1457
PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;
1458
PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;
1459
PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;
1460
PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;
1461
PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;
1462
 
1463
PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL;
1464
PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL;
1465
PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL;
1466
 
1467
PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;
1468
 
1469
PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;
1470
 
1471
PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;
1472
 
1473
PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;
1474
 
1475
PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;
1476
PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;
1477
 
1478
PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;
1479
PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;
1480
 
1481
PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;
1482
PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;
1483
PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;
1484
PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;
1485
PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;
1486
PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;
1487
PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;
1488
PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;
1489
PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;
1490
PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;
1491
PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;
1492
PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;
1493
PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;
1494
 
1495
PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;
1496
PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;
1497
 
1498
PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;
1499
PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;
1500
PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;
1501
PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;
1502
PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;
1503
 
1504
PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;
1505
PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;
1506
 
1507
PFNGLINSERTEVENTMARKEREXTPROC __glewInsertEventMarkerEXT = NULL;
1508
PFNGLPOPGROUPMARKEREXTPROC __glewPopGroupMarkerEXT = NULL;
1509
PFNGLPUSHGROUPMARKEREXTPROC __glewPushGroupMarkerEXT = NULL;
1510
 
1511
PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;
1512
 
1513
PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL;
1514
PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL;
1515
PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL;
1516
PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL;
1517
PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL;
1518
PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL;
1519
PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL;
1520
PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL;
1521
PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL;
1522
PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL;
1523
PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL;
1524
PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL;
1525
PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL;
1526
PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL;
1527
PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL;
1528
PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL;
1529
PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL;
1530
PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL;
1531
PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL;
1532
PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL;
1533
PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL;
1534
PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL;
1535
PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL;
1536
PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL;
1537
PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL;
1538
PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL;
1539
PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL;
1540
PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL;
1541
PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL;
1542
PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL;
1543
PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL;
1544
PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL;
1545
PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL;
1546
PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL;
1547
PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL;
1548
PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL;
1549
PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL;
1550
PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL;
1551
PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL;
1552
PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL;
1553
PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL;
1554
PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL;
1555
PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL;
1556
PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL;
1557
PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL;
1558
PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL;
1559
PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL;
1560
PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL;
1561
PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL;
1562
PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL;
1563
PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL;
1564
PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL;
1565
PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL;
1566
PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL;
1567
PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL;
1568
PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL;
1569
PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL;
1570
PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL;
1571
PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL;
1572
PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL;
1573
PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL;
1574
PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL;
1575
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL;
1576
PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL;
1577
PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL;
1578
PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL;
1579
PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL;
1580
PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL;
1581
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL;
1582
PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL;
1583
PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL;
1584
PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL;
1585
PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL;
1586
PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL;
1587
PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL;
1588
PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL;
1589
PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL;
1590
PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL;
1591
PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL;
1592
PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL;
1593
PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL;
1594
PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL;
1595
PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL;
1596
PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL;
1597
PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL;
1598
PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL;
1599
PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL;
1600
PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL;
1601
PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL;
1602
PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL;
1603
PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL;
1604
PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL;
1605
PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL;
1606
PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL;
1607
PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL;
1608
PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL;
1609
PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL;
1610
PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL;
1611
PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL;
1612
PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL;
1613
PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL;
1614
PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL;
1615
PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL;
1616
PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL;
1617
PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL;
1618
PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL;
1619
PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL;
1620
PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL;
1621
PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL;
1622
PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL;
1623
PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL;
1624
PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL;
1625
PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL;
1626
PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL;
1627
PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL;
1628
PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL;
1629
PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL;
1630
PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL;
1631
PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL;
1632
PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL;
1633
PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL;
1634
PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL;
1635
PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL;
1636
PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL;
1637
PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL;
1638
PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL;
1639
PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;
1640
PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;
1641
PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;
1642
PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;
1643
PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL;
1644
PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;
1645
PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL;
1646
PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL;
1647
PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL;
1648
PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL;
1649
PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL;
1650
PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL;
1651
PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL;
1652
PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL;
1653
PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL;
1654
PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL;
1655
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL;
1656
PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL;
1657
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL;
1658
PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL;
1659
PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL;
1660
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL;
1661
PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL;
1662
PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL;
1663
PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL;
1664
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL;
1665
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL;
1666
PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL;
1667
PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL;
1668
PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL;
1669
PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL;
1670
PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL;
1671
PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL;
1672
PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL;
1673
PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL;
1674
PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL;
1675
PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL;
1676
PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL;
1677
PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL;
1678
PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL;
1679
PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL;
1680
PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL;
1681
PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL;
1682
PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL;
1683
PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL;
1684
PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL;
1685
PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL;
1686
PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL;
1687
PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL;
1688
PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL;
1689
PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL;
1690
PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL;
1691
PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL;
1692
PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL;
1693
PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL;
1694
PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL;
1695
PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL;
1696
PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL;
1697
PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL;
1698
PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL;
1699
PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL;
1700
PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL;
1701
PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL;
1702
PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL;
1703
PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL;
1704
PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL;
1705
PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL;
1706
PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL;
1707
PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL;
1708
PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL;
1709
PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL;
1710
PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL;
1711
PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL;
1712
PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL;
1713
PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL;
1714
PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL;
1715
PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL;
1716
PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL;
1717
PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL;
1718
PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL;
1719
PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL;
1720
PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL;
1721
PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL;
1722
PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL;
1723
PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL;
1724
PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL;
1725
PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL;
1726
 
1727
PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;
1728
PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;
1729
PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL;
1730
PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL;
1731
PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL;
1732
PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL;
1733
 
1734
PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL;
1735
PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL;
1736
 
1737
PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;
1738
 
1739
PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;
1740
PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;
1741
PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;
1742
PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;
1743
PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;
1744
 
1745
PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;
1746
PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;
1747
PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;
1748
PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;
1749
PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;
1750
PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;
1751
PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;
1752
PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;
1753
PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;
1754
PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;
1755
PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;
1756
PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;
1757
PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;
1758
PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;
1759
PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;
1760
PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;
1761
PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;
1762
PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;
1763
 
1764
PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;
1765
 
1766
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;
1767
 
1768
PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;
1769
PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;
1770
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;
1771
PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;
1772
PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;
1773
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;
1774
PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;
1775
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;
1776
PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;
1777
PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;
1778
PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;
1779
PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;
1780
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;
1781
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;
1782
PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;
1783
PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;
1784
PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;
1785
 
1786
PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL;
1787
PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL;
1788
PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL;
1789
 
1790
PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL;
1791
PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL;
1792
 
1793
PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL;
1794
PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL;
1795
PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL;
1796
PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL;
1797
PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL;
1798
PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL;
1799
PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL;
1800
PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL;
1801
PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL;
1802
PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL;
1803
PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL;
1804
PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL;
1805
PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL;
1806
PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL;
1807
PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL;
1808
PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL;
1809
PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL;
1810
PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL;
1811
PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL;
1812
PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL;
1813
PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL;
1814
PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL;
1815
PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL;
1816
PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL;
1817
PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL;
1818
PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL;
1819
PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL;
1820
PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL;
1821
PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL;
1822
PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL;
1823
PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL;
1824
PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL;
1825
PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL;
1826
PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL;
1827
 
1828
PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;
1829
PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;
1830
PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;
1831
PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;
1832
PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;
1833
PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;
1834
PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;
1835
PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;
1836
PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;
1837
PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;
1838
 
1839
PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;
1840
 
1841
PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;
1842
 
1843
PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;
1844
PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;
1845
PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;
1846
 
1847
PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;
1848
PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;
1849
 
1850
PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;
1851
PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;
1852
 
1853
PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;
1854
PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;
1855
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;
1856
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;
1857
 
1858
PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;
1859
PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;
1860
PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;
1861
PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;
1862
PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;
1863
PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;
1864
 
1865
PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;
1866
PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;
1867
 
1868
PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;
1869
 
1870
PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL;
1871
 
1872
PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;
1873
PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;
1874
 
1875
PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;
1876
PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;
1877
PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;
1878
PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;
1879
PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;
1880
PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;
1881
PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;
1882
PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;
1883
PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;
1884
PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;
1885
PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;
1886
PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;
1887
PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;
1888
PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;
1889
PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;
1890
PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;
1891
PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;
1892
 
1893
PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL;
1894
PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL;
1895
PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL;
1896
 
1897
PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL;
1898
PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL;
1899
 
1900
PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
1901
 
1902
PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;
1903
PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;
1904
PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;
1905
 
1906
PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;
1907
 
1908
PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL;
1909
 
1910
PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL;
1911
 
1912
PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL;
1913
PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL;
1914
PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL;
1915
PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL;
1916
PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL;
1917
PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL;
1918
 
1919
PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;
1920
PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;
1921
PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;
1922
PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;
1923
PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;
1924
PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;
1925
 
1926
PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;
1927
 
1928
PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;
1929
PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL;
1930
 
1931
PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL;
1932
PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL;
1933
PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL;
1934
PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL;
1935
PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL;
1936
PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL;
1937
PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL;
1938
 
1939
PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;
1940
PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;
1941
PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;
1942
PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;
1943
PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;
1944
PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;
1945
PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;
1946
PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;
1947
 
1948
PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL;
1949
PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL;
1950
PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL;
1951
PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL;
1952
PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL;
1953
PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL;
1954
PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL;
1955
PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL;
1956
PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL;
1957
PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL;
1958
PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL;
1959
 
1960
PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;
1961
PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;
1962
PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;
1963
PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;
1964
PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;
1965
PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;
1966
PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;
1967
PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;
1968
PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;
1969
PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;
1970
PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;
1971
PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;
1972
PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;
1973
PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;
1974
PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;
1975
PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;
1976
PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;
1977
PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;
1978
PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;
1979
PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;
1980
PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;
1981
PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;
1982
PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;
1983
PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;
1984
PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;
1985
PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;
1986
PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;
1987
PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;
1988
PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;
1989
PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;
1990
PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;
1991
PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;
1992
PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;
1993
PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;
1994
PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;
1995
PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;
1996
PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;
1997
PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;
1998
PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;
1999
PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;
2000
PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;
2001
PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;
2002
 
2003
PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;
2004
PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;
2005
PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;
2006
 
2007
PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL;
2008
 
2009
PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL;
2010
 
2011
PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL;
2012
 
2013
PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;
2014
PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;
2015
PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;
2016
PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;
2017
PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;
2018
PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;
2019
 
2020
PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;
2021
PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;
2022
 
2023
PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;
2024
PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;
2025
PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;
2026
PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;
2027
PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;
2028
PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;
2029
PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;
2030
PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;
2031
 
677 janba 2032
PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL = NULL;
2033
PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL = NULL;
2034
PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL = NULL;
2035
 
667 khor 2036
PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;
2037
PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;
2038
PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;
2039
PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;
2040
 
2041
PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;
2042
PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;
2043
 
2044
PFNGLDEBUGMESSAGECALLBACKPROC __glewDebugMessageCallback = NULL;
2045
PFNGLDEBUGMESSAGECONTROLPROC __glewDebugMessageControl = NULL;
2046
PFNGLDEBUGMESSAGEINSERTPROC __glewDebugMessageInsert = NULL;
2047
PFNGLGETDEBUGMESSAGELOGPROC __glewGetDebugMessageLog = NULL;
2048
PFNGLGETOBJECTLABELPROC __glewGetObjectLabel = NULL;
2049
PFNGLGETOBJECTPTRLABELPROC __glewGetObjectPtrLabel = NULL;
2050
PFNGLOBJECTLABELPROC __glewObjectLabel = NULL;
2051
PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel = NULL;
677 janba 2052
PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup = NULL;
667 khor 2053
PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup = NULL;
2054
 
2055
PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled = NULL;
2056
PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion = NULL;
2057
PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion = NULL;
2058
PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion = NULL;
2059
PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion = NULL;
2060
 
2061
PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;
2062
 
2063
PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;
2064
PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;
2065
PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;
2066
PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;
2067
PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;
2068
PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;
2069
PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;
2070
PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;
2071
PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;
2072
PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;
2073
PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;
2074
PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;
2075
PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;
2076
PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;
2077
PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;
2078
PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;
2079
PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;
2080
PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;
2081
PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;
2082
PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;
2083
PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;
2084
PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;
2085
PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;
2086
PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;
2087
 
677 janba 2088
PFNGLBEGINCONDITIONALRENDERNVXPROC __glewBeginConditionalRenderNVX = NULL;
2089
PFNGLENDCONDITIONALRENDERNVXPROC __glewEndConditionalRenderNVX = NULL;
2090
 
2091
PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC __glewMultiDrawArraysIndirectBindlessNV = NULL;
2092
PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC __glewMultiDrawElementsIndirectBindlessNV = NULL;
2093
 
667 khor 2094
PFNGLGETIMAGEHANDLENVPROC __glewGetImageHandleNV = NULL;
2095
PFNGLGETTEXTUREHANDLENVPROC __glewGetTextureHandleNV = NULL;
2096
PFNGLGETTEXTURESAMPLERHANDLENVPROC __glewGetTextureSamplerHandleNV = NULL;
2097
PFNGLISIMAGEHANDLERESIDENTNVPROC __glewIsImageHandleResidentNV = NULL;
2098
PFNGLISTEXTUREHANDLERESIDENTNVPROC __glewIsTextureHandleResidentNV = NULL;
2099
PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC __glewMakeImageHandleNonResidentNV = NULL;
2100
PFNGLMAKEIMAGEHANDLERESIDENTNVPROC __glewMakeImageHandleResidentNV = NULL;
2101
PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC __glewMakeTextureHandleNonResidentNV = NULL;
2102
PFNGLMAKETEXTUREHANDLERESIDENTNVPROC __glewMakeTextureHandleResidentNV = NULL;
2103
PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC __glewProgramUniformHandleui64NV = NULL;
2104
PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC __glewProgramUniformHandleui64vNV = NULL;
2105
PFNGLUNIFORMHANDLEUI64NVPROC __glewUniformHandleui64NV = NULL;
2106
PFNGLUNIFORMHANDLEUI64VNVPROC __glewUniformHandleui64vNV = NULL;
2107
 
677 janba 2108
PFNGLBLENDBARRIERNVPROC __glewBlendBarrierNV = NULL;
2109
PFNGLBLENDPARAMETERINVPROC __glewBlendParameteriNV = NULL;
2110
 
667 khor 2111
PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL;
2112
PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL;
2113
 
2114
PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL;
2115
 
2116
PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;
2117
PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;
2118
PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;
2119
 
677 janba 2120
PFNGLDRAWTEXTURENVPROC __glewDrawTextureNV = NULL;
2121
 
667 khor 2122
PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;
2123
PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;
2124
PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;
2125
PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;
2126
PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;
2127
PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;
2128
PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;
2129
PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;
2130
PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;
2131
 
2132
PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL;
2133
PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL;
2134
PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL;
2135
 
2136
PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;
2137
PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;
2138
PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;
2139
PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;
2140
PFNGLISFENCENVPROC __glewIsFenceNV = NULL;
2141
PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;
2142
PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;
2143
 
2144
PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;
2145
PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;
2146
PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;
2147
PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;
2148
PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;
2149
PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;
2150
 
2151
PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL;
2152
 
2153
PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL;
2154
 
2155
PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL;
2156
PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL;
2157
PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL;
2158
PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL;
2159
PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL;
2160
PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL;
2161
PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL;
2162
PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL;
2163
PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL;
2164
PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;
2165
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;
2166
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;
2167
 
2168
PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL;
2169
PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL;
2170
PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL;
2171
PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL;
2172
PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL;
2173
PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL;
2174
PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL;
2175
PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL;
2176
PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL;
2177
PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL;
2178
PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL;
2179
PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL;
2180
PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL;
2181
PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL;
2182
PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL;
2183
PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL;
2184
PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL;
2185
PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL;
2186
PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL;
2187
PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL;
2188
PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL;
2189
PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL;
2190
PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL;
2191
PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL;
2192
PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL;
2193
PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL;
2194
PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL;
2195
PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL;
2196
PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL;
2197
PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL;
2198
PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL;
2199
PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL;
2200
PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL;
2201
PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL;
2202
 
2203
PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;
2204
PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;
2205
PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;
2206
PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;
2207
PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;
2208
PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;
2209
PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;
2210
PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;
2211
PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;
2212
PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;
2213
PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;
2214
PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;
2215
PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;
2216
PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;
2217
PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;
2218
PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;
2219
PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;
2220
PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;
2221
PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;
2222
PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;
2223
PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;
2224
PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;
2225
PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;
2226
PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;
2227
PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;
2228
PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;
2229
PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;
2230
PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;
2231
PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;
2232
PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;
2233
PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;
2234
PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;
2235
PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;
2236
PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;
2237
PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;
2238
PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;
2239
PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;
2240
PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;
2241
PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;
2242
PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;
2243
PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;
2244
PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;
2245
PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;
2246
PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;
2247
PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;
2248
PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;
2249
 
2250
PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;
2251
PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;
2252
PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;
2253
PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;
2254
PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;
2255
PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;
2256
PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;
2257
 
2258
PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL;
2259
PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL;
2260
PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL;
2261
 
2262
PFNGLCOPYPATHNVPROC __glewCopyPathNV = NULL;
2263
PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV = NULL;
2264
PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV = NULL;
2265
PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV = NULL;
2266
PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV = NULL;
2267
PFNGLDELETEPATHSNVPROC __glewDeletePathsNV = NULL;
2268
PFNGLGENPATHSNVPROC __glewGenPathsNV = NULL;
2269
PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV = NULL;
2270
PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV = NULL;
2271
PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV = NULL;
2272
PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV = NULL;
2273
PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV = NULL;
2274
PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV = NULL;
2275
PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV = NULL;
2276
PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV = NULL;
2277
PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV = NULL;
2278
PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV = NULL;
2279
PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV = NULL;
2280
PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV = NULL;
2281
PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV = NULL;
2282
PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV = NULL;
2283
PFNGLISPATHNVPROC __glewIsPathNV = NULL;
2284
PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV = NULL;
2285
PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV = NULL;
2286
PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV = NULL;
2287
PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV = NULL;
2288
PFNGLPATHCOORDSNVPROC __glewPathCoordsNV = NULL;
2289
PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV = NULL;
2290
PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV = NULL;
2291
PFNGLPATHFOGGENNVPROC __glewPathFogGenNV = NULL;
2292
PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV = NULL;
2293
PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV = NULL;
2294
PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV = NULL;
2295
PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV = NULL;
2296
PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV = NULL;
2297
PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV = NULL;
2298
PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV = NULL;
2299
PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV = NULL;
2300
PFNGLPATHSTRINGNVPROC __glewPathStringNV = NULL;
2301
PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV = NULL;
2302
PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV = NULL;
2303
PFNGLPATHTEXGENNVPROC __glewPathTexGenNV = NULL;
2304
PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV = NULL;
2305
PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV = NULL;
2306
PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV = NULL;
2307
PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV = NULL;
2308
PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV = NULL;
2309
PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV = NULL;
2310
PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV = NULL;
2311
 
2312
PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;
2313
PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;
2314
 
2315
PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;
2316
PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;
2317
 
2318
PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL;
2319
PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL;
2320
PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL;
2321
PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL;
2322
PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL;
2323
PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL;
2324
 
2325
PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;
2326
PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;
2327
 
2328
PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;
2329
PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;
2330
PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;
2331
PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;
2332
PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;
2333
PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;
2334
PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;
2335
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;
2336
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;
2337
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;
2338
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;
2339
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;
2340
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;
2341
 
2342
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;
2343
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;
2344
 
2345
PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL;
2346
PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL;
2347
PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL;
2348
PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL;
2349
PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL;
2350
PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL;
2351
PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL;
2352
PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL;
2353
PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL;
2354
PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL;
2355
PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL;
2356
PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL;
2357
PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL;
2358
 
2359
PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL;
2360
 
2361
PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL;
2362
PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV = NULL;
2363
PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV = NULL;
2364
PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL;
2365
PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL;
2366
PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL;
2367
 
2368
PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;
2369
PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;
2370
PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;
2371
PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL;
2372
PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL;
2373
PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL;
2374
PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL;
2375
PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL;
2376
PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;
2377
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;
2378
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;
2379
 
2380
PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL;
2381
PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL;
2382
PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL;
2383
PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL;
2384
PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL;
2385
PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL;
2386
PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL;
2387
 
2388
PFNGLVDPAUFININVPROC __glewVDPAUFiniNV = NULL;
2389
PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV = NULL;
2390
PFNGLVDPAUINITNVPROC __glewVDPAUInitNV = NULL;
2391
PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV = NULL;
2392
PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV = NULL;
2393
PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV = NULL;
2394
PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV = NULL;
2395
PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV = NULL;
2396
PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV = NULL;
2397
PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV = NULL;
2398
 
2399
PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;
2400
PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;
2401
 
2402
PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL;
2403
PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL;
2404
PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL;
2405
PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL;
2406
PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL;
2407
PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL;
2408
PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL;
2409
PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL;
2410
PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL;
2411
PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL;
2412
PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL;
2413
PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL;
2414
PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL;
2415
PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL;
2416
PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL;
2417
PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL;
2418
PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL;
2419
PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL;
2420
PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL;
2421
 
2422
PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL;
2423
PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL;
2424
PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL;
2425
PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL;
2426
PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL;
2427
PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL;
2428
PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL;
2429
PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL;
2430
PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL;
2431
PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL;
2432
PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL;
2433
PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL;
2434
 
2435
PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;
2436
PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;
2437
PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;
2438
PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;
2439
PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;
2440
PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;
2441
PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;
2442
PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;
2443
PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;
2444
PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;
2445
PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;
2446
PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;
2447
PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;
2448
PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;
2449
PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;
2450
PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;
2451
PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;
2452
PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;
2453
PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;
2454
PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;
2455
PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;
2456
PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;
2457
PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;
2458
PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;
2459
PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;
2460
PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;
2461
PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;
2462
PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;
2463
PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;
2464
PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;
2465
PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;
2466
PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;
2467
PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;
2468
PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;
2469
PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;
2470
PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;
2471
PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;
2472
PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;
2473
PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;
2474
PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;
2475
PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;
2476
PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;
2477
PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;
2478
PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;
2479
PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;
2480
PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;
2481
PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;
2482
PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;
2483
PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;
2484
PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;
2485
PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;
2486
PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;
2487
PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;
2488
PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;
2489
PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;
2490
PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;
2491
PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;
2492
PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;
2493
PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;
2494
PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;
2495
PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;
2496
PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;
2497
PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;
2498
PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;
2499
 
2500
PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV = NULL;
2501
PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV = NULL;
2502
PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV = NULL;
2503
PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV = NULL;
2504
PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV = NULL;
2505
PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV = NULL;
2506
PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV = NULL;
2507
PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV = NULL;
2508
PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV = NULL;
2509
PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = NULL;
2510
PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL;
2511
PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL;
2512
 
2513
PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL;
2514
PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL;
2515
PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL;
2516
PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL;
2517
PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL;
2518
PFNGLORTHOFOESPROC __glewOrthofOES = NULL;
2519
 
677 janba 2520
PFNGLALPHAFUNCXPROC __glewAlphaFuncx = NULL;
2521
PFNGLCLEARCOLORXPROC __glewClearColorx = NULL;
2522
PFNGLCLEARDEPTHXPROC __glewClearDepthx = NULL;
2523
PFNGLCOLOR4XPROC __glewColor4x = NULL;
2524
PFNGLDEPTHRANGEXPROC __glewDepthRangex = NULL;
2525
PFNGLFOGXPROC __glewFogx = NULL;
2526
PFNGLFOGXVPROC __glewFogxv = NULL;
2527
PFNGLFRUSTUMFPROC __glewFrustumf = NULL;
2528
PFNGLFRUSTUMXPROC __glewFrustumx = NULL;
2529
PFNGLLIGHTMODELXPROC __glewLightModelx = NULL;
2530
PFNGLLIGHTMODELXVPROC __glewLightModelxv = NULL;
2531
PFNGLLIGHTXPROC __glewLightx = NULL;
2532
PFNGLLIGHTXVPROC __glewLightxv = NULL;
2533
PFNGLLINEWIDTHXPROC __glewLineWidthx = NULL;
2534
PFNGLLOADMATRIXXPROC __glewLoadMatrixx = NULL;
2535
PFNGLMATERIALXPROC __glewMaterialx = NULL;
2536
PFNGLMATERIALXVPROC __glewMaterialxv = NULL;
2537
PFNGLMULTMATRIXXPROC __glewMultMatrixx = NULL;
2538
PFNGLMULTITEXCOORD4XPROC __glewMultiTexCoord4x = NULL;
2539
PFNGLNORMAL3XPROC __glewNormal3x = NULL;
2540
PFNGLORTHOFPROC __glewOrthof = NULL;
2541
PFNGLORTHOXPROC __glewOrthox = NULL;
2542
PFNGLPOINTSIZEXPROC __glewPointSizex = NULL;
2543
PFNGLPOLYGONOFFSETXPROC __glewPolygonOffsetx = NULL;
2544
PFNGLROTATEXPROC __glewRotatex = NULL;
2545
PFNGLSAMPLECOVERAGEXPROC __glewSampleCoveragex = NULL;
2546
PFNGLSCALEXPROC __glewScalex = NULL;
2547
PFNGLTEXENVXPROC __glewTexEnvx = NULL;
2548
PFNGLTEXENVXVPROC __glewTexEnvxv = NULL;
2549
PFNGLTEXPARAMETERXPROC __glewTexParameterx = NULL;
2550
PFNGLTRANSLATEXPROC __glewTranslatex = NULL;
2551
 
2552
PFNGLCLIPPLANEFPROC __glewClipPlanef = NULL;
2553
PFNGLCLIPPLANEXPROC __glewClipPlanex = NULL;
2554
PFNGLGETCLIPPLANEFPROC __glewGetClipPlanef = NULL;
2555
PFNGLGETCLIPPLANEXPROC __glewGetClipPlanex = NULL;
2556
PFNGLGETFIXEDVPROC __glewGetFixedv = NULL;
2557
PFNGLGETLIGHTXVPROC __glewGetLightxv = NULL;
2558
PFNGLGETMATERIALXVPROC __glewGetMaterialxv = NULL;
2559
PFNGLGETTEXENVXVPROC __glewGetTexEnvxv = NULL;
2560
PFNGLGETTEXPARAMETERXVPROC __glewGetTexParameterxv = NULL;
2561
PFNGLPOINTPARAMETERXPROC __glewPointParameterx = NULL;
2562
PFNGLPOINTPARAMETERXVPROC __glewPointParameterxv = NULL;
2563
PFNGLPOINTSIZEPOINTEROESPROC __glewPointSizePointerOES = NULL;
2564
PFNGLTEXPARAMETERXVPROC __glewTexParameterxv = NULL;
2565
 
667 khor 2566
PFNGLERRORSTRINGREGALPROC __glewErrorStringREGAL = NULL;
2567
 
2568
PFNGLGETEXTENSIONREGALPROC __glewGetExtensionREGAL = NULL;
2569
PFNGLISSUPPORTEDREGALPROC __glewIsSupportedREGAL = NULL;
2570
 
677 janba 2571
PFNGLLOGMESSAGECALLBACKREGALPROC __glewLogMessageCallbackREGAL = NULL;
2572
 
667 khor 2573
PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;
2574
PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;
2575
 
2576
PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;
2577
PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;
2578
 
2579
PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;
2580
PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;
2581
 
2582
PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;
2583
PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;
2584
 
2585
PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;
2586
PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;
2587
 
2588
PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;
2589
PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;
2590
 
2591
PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;
2592
PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;
2593
PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;
2594
PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;
2595
PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;
2596
PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;
2597
 
2598
PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;
2599
 
2600
PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;
2601
 
2602
PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;
2603
PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;
2604
PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;
2605
PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;
2606
PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;
2607
PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;
2608
PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;
2609
PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;
2610
PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;
2611
PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;
2612
PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;
2613
PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;
2614
PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;
2615
PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;
2616
PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;
2617
PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;
2618
PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;
2619
 
2620
PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;
2621
 
2622
PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;
2623
 
2624
PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;
2625
 
2626
PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;
2627
PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;
2628
PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;
2629
PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;
2630
 
2631
PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;
2632
 
2633
PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;
2634
PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;
2635
PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;
2636
PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;
2637
PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;
2638
PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;
2639
PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;
2640
 
2641
PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;
2642
 
2643
PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;
2644
PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;
2645
PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;
2646
PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;
2647
PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;
2648
PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;
2649
PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;
2650
PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;
2651
 
2652
PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;
2653
 
2654
PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;
2655
PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;
2656
PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;
2657
PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;
2658
PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;
2659
PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;
2660
PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;
2661
 
2662
PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;
2663
PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;
2664
PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;
2665
PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;
2666
PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;
2667
PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;
2668
PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;
2669
PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;
2670
PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;
2671
PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;
2672
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;
2673
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;
2674
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;
2675
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;
2676
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;
2677
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;
2678
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;
2679
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;
2680
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;
2681
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;
2682
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;
2683
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;
2684
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;
2685
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;
2686
PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;
2687
PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;
2688
PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;
2689
PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;
2690
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;
2691
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;
2692
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;
2693
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;
2694
PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;
2695
PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;
2696
PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;
2697
PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;
2698
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;
2699
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;
2700
PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;
2701
PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;
2702
 
2703
PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;
2704
 
2705
#endif /* !WIN32 || !GLEW_MX */
2706
 
2707
#if !defined(GLEW_MX)
2708
 
2709
GLboolean __GLEW_VERSION_1_1 = GL_FALSE;
2710
GLboolean __GLEW_VERSION_1_2 = GL_FALSE;
2711
GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE;
2712
GLboolean __GLEW_VERSION_1_3 = GL_FALSE;
2713
GLboolean __GLEW_VERSION_1_4 = GL_FALSE;
2714
GLboolean __GLEW_VERSION_1_5 = GL_FALSE;
2715
GLboolean __GLEW_VERSION_2_0 = GL_FALSE;
2716
GLboolean __GLEW_VERSION_2_1 = GL_FALSE;
2717
GLboolean __GLEW_VERSION_3_0 = GL_FALSE;
2718
GLboolean __GLEW_VERSION_3_1 = GL_FALSE;
2719
GLboolean __GLEW_VERSION_3_2 = GL_FALSE;
2720
GLboolean __GLEW_VERSION_3_3 = GL_FALSE;
2721
GLboolean __GLEW_VERSION_4_0 = GL_FALSE;
2722
GLboolean __GLEW_VERSION_4_1 = GL_FALSE;
2723
GLboolean __GLEW_VERSION_4_2 = GL_FALSE;
2724
GLboolean __GLEW_VERSION_4_3 = GL_FALSE;
677 janba 2725
GLboolean __GLEW_VERSION_4_4 = GL_FALSE;
667 khor 2726
GLboolean __GLEW_3DFX_multisample = GL_FALSE;
2727
GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;
2728
GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;
2729
GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE;
2730
GLboolean __GLEW_AMD_conservative_depth = GL_FALSE;
2731
GLboolean __GLEW_AMD_debug_output = GL_FALSE;
2732
GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE;
2733
GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE;
677 janba 2734
GLboolean __GLEW_AMD_interleaved_elements = GL_FALSE;
667 khor 2735
GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE;
2736
GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE;
2737
GLboolean __GLEW_AMD_performance_monitor = GL_FALSE;
2738
GLboolean __GLEW_AMD_pinned_memory = GL_FALSE;
2739
GLboolean __GLEW_AMD_query_buffer_object = GL_FALSE;
2740
GLboolean __GLEW_AMD_sample_positions = GL_FALSE;
2741
GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE;
2742
GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE;
677 janba 2743
GLboolean __GLEW_AMD_shader_trinary_minmax = GL_FALSE;
2744
GLboolean __GLEW_AMD_sparse_texture = GL_FALSE;
667 khor 2745
GLboolean __GLEW_AMD_stencil_operation_extended = GL_FALSE;
2746
GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE;
2747
GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE;
2748
GLboolean __GLEW_AMD_vertex_shader_layer = GL_FALSE;
2749
GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE;
2750
GLboolean __GLEW_AMD_vertex_shader_viewport_index = GL_FALSE;
677 janba 2751
GLboolean __GLEW_ANGLE_depth_texture = GL_FALSE;
2752
GLboolean __GLEW_ANGLE_framebuffer_blit = GL_FALSE;
2753
GLboolean __GLEW_ANGLE_framebuffer_multisample = GL_FALSE;
2754
GLboolean __GLEW_ANGLE_instanced_arrays = GL_FALSE;
2755
GLboolean __GLEW_ANGLE_pack_reverse_row_order = GL_FALSE;
2756
GLboolean __GLEW_ANGLE_program_binary = GL_FALSE;
2757
GLboolean __GLEW_ANGLE_texture_compression_dxt1 = GL_FALSE;
2758
GLboolean __GLEW_ANGLE_texture_compression_dxt3 = GL_FALSE;
2759
GLboolean __GLEW_ANGLE_texture_compression_dxt5 = GL_FALSE;
2760
GLboolean __GLEW_ANGLE_texture_usage = GL_FALSE;
2761
GLboolean __GLEW_ANGLE_timer_query = GL_FALSE;
2762
GLboolean __GLEW_ANGLE_translated_shader_source = GL_FALSE;
667 khor 2763
GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE;
2764
GLboolean __GLEW_APPLE_client_storage = GL_FALSE;
2765
GLboolean __GLEW_APPLE_element_array = GL_FALSE;
2766
GLboolean __GLEW_APPLE_fence = GL_FALSE;
2767
GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;
2768
GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;
2769
GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE;
2770
GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;
2771
GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE;
2772
GLboolean __GLEW_APPLE_row_bytes = GL_FALSE;
2773
GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;
2774
GLboolean __GLEW_APPLE_texture_range = GL_FALSE;
2775
GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;
2776
GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;
2777
GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;
2778
GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE;
2779
GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;
2780
GLboolean __GLEW_ARB_ES2_compatibility = GL_FALSE;
2781
GLboolean __GLEW_ARB_ES3_compatibility = GL_FALSE;
2782
GLboolean __GLEW_ARB_arrays_of_arrays = GL_FALSE;
2783
GLboolean __GLEW_ARB_base_instance = GL_FALSE;
677 janba 2784
GLboolean __GLEW_ARB_bindless_texture = GL_FALSE;
667 khor 2785
GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE;
677 janba 2786
GLboolean __GLEW_ARB_buffer_storage = GL_FALSE;
667 khor 2787
GLboolean __GLEW_ARB_cl_event = GL_FALSE;
2788
GLboolean __GLEW_ARB_clear_buffer_object = GL_FALSE;
677 janba 2789
GLboolean __GLEW_ARB_clear_texture = GL_FALSE;
667 khor 2790
GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;
2791
GLboolean __GLEW_ARB_compatibility = GL_FALSE;
2792
GLboolean __GLEW_ARB_compressed_texture_pixel_storage = GL_FALSE;
2793
GLboolean __GLEW_ARB_compute_shader = GL_FALSE;
677 janba 2794
GLboolean __GLEW_ARB_compute_variable_group_size = GL_FALSE;
667 khor 2795
GLboolean __GLEW_ARB_conservative_depth = GL_FALSE;
2796
GLboolean __GLEW_ARB_copy_buffer = GL_FALSE;
2797
GLboolean __GLEW_ARB_copy_image = GL_FALSE;
2798
GLboolean __GLEW_ARB_debug_output = GL_FALSE;
2799
GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE;
2800
GLboolean __GLEW_ARB_depth_clamp = GL_FALSE;
2801
GLboolean __GLEW_ARB_depth_texture = GL_FALSE;
2802
GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;
2803
GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE;
2804
GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE;
2805
GLboolean __GLEW_ARB_draw_indirect = GL_FALSE;
2806
GLboolean __GLEW_ARB_draw_instanced = GL_FALSE;
677 janba 2807
GLboolean __GLEW_ARB_enhanced_layouts = GL_FALSE;
667 khor 2808
GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE;
2809
GLboolean __GLEW_ARB_explicit_uniform_location = GL_FALSE;
2810
GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE;
2811
GLboolean __GLEW_ARB_fragment_layer_viewport = GL_FALSE;
2812
GLboolean __GLEW_ARB_fragment_program = GL_FALSE;
2813
GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;
2814
GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;
2815
GLboolean __GLEW_ARB_framebuffer_no_attachments = GL_FALSE;
2816
GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE;
2817
GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE;
2818
GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE;
2819
GLboolean __GLEW_ARB_get_program_binary = GL_FALSE;
2820
GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE;
2821
GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE;
2822
GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;
2823
GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE;
2824
GLboolean __GLEW_ARB_imaging = GL_FALSE;
677 janba 2825
GLboolean __GLEW_ARB_indirect_parameters = GL_FALSE;
667 khor 2826
GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE;
2827
GLboolean __GLEW_ARB_internalformat_query = GL_FALSE;
2828
GLboolean __GLEW_ARB_internalformat_query2 = GL_FALSE;
2829
GLboolean __GLEW_ARB_invalidate_subdata = GL_FALSE;
2830
GLboolean __GLEW_ARB_map_buffer_alignment = GL_FALSE;
2831
GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE;
2832
GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;
677 janba 2833
GLboolean __GLEW_ARB_multi_bind = GL_FALSE;
667 khor 2834
GLboolean __GLEW_ARB_multi_draw_indirect = GL_FALSE;
2835
GLboolean __GLEW_ARB_multisample = GL_FALSE;
2836
GLboolean __GLEW_ARB_multitexture = GL_FALSE;
2837
GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;
2838
GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE;
2839
GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;
2840
GLboolean __GLEW_ARB_point_parameters = GL_FALSE;
2841
GLboolean __GLEW_ARB_point_sprite = GL_FALSE;
2842
GLboolean __GLEW_ARB_program_interface_query = GL_FALSE;
2843
GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE;
677 janba 2844
GLboolean __GLEW_ARB_query_buffer_object = GL_FALSE;
667 khor 2845
GLboolean __GLEW_ARB_robust_buffer_access_behavior = GL_FALSE;
2846
GLboolean __GLEW_ARB_robustness = GL_FALSE;
2847
GLboolean __GLEW_ARB_robustness_application_isolation = GL_FALSE;
2848
GLboolean __GLEW_ARB_robustness_share_group_isolation = GL_FALSE;
2849
GLboolean __GLEW_ARB_sample_shading = GL_FALSE;
2850
GLboolean __GLEW_ARB_sampler_objects = GL_FALSE;
2851
GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE;
677 janba 2852
GLboolean __GLEW_ARB_seamless_cubemap_per_texture = GL_FALSE;
667 khor 2853
GLboolean __GLEW_ARB_separate_shader_objects = GL_FALSE;
2854
GLboolean __GLEW_ARB_shader_atomic_counters = GL_FALSE;
2855
GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE;
677 janba 2856
GLboolean __GLEW_ARB_shader_draw_parameters = GL_FALSE;
2857
GLboolean __GLEW_ARB_shader_group_vote = GL_FALSE;
667 khor 2858
GLboolean __GLEW_ARB_shader_image_load_store = GL_FALSE;
2859
GLboolean __GLEW_ARB_shader_image_size = GL_FALSE;
2860
GLboolean __GLEW_ARB_shader_objects = GL_FALSE;
2861
GLboolean __GLEW_ARB_shader_precision = GL_FALSE;
2862
GLboolean __GLEW_ARB_shader_stencil_export = GL_FALSE;
2863
GLboolean __GLEW_ARB_shader_storage_buffer_object = GL_FALSE;
2864
GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE;
2865
GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE;
2866
GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;
2867
GLboolean __GLEW_ARB_shading_language_420pack = GL_FALSE;
2868
GLboolean __GLEW_ARB_shading_language_include = GL_FALSE;
2869
GLboolean __GLEW_ARB_shading_language_packing = GL_FALSE;
2870
GLboolean __GLEW_ARB_shadow = GL_FALSE;
2871
GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;
677 janba 2872
GLboolean __GLEW_ARB_sparse_texture = GL_FALSE;
667 khor 2873
GLboolean __GLEW_ARB_stencil_texturing = GL_FALSE;
2874
GLboolean __GLEW_ARB_sync = GL_FALSE;
2875
GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE;
2876
GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;
2877
GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE;
2878
GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE;
2879
GLboolean __GLEW_ARB_texture_buffer_range = GL_FALSE;
2880
GLboolean __GLEW_ARB_texture_compression = GL_FALSE;
2881
GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE;
2882
GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE;
2883
GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;
2884
GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE;
2885
GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;
2886
GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;
2887
GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;
2888
GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;
2889
GLboolean __GLEW_ARB_texture_float = GL_FALSE;
2890
GLboolean __GLEW_ARB_texture_gather = GL_FALSE;
677 janba 2891
GLboolean __GLEW_ARB_texture_mirror_clamp_to_edge = GL_FALSE;
667 khor 2892
GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;
2893
GLboolean __GLEW_ARB_texture_multisample = GL_FALSE;
2894
GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;
2895
GLboolean __GLEW_ARB_texture_query_levels = GL_FALSE;
2896
GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE;
2897
GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;
2898
GLboolean __GLEW_ARB_texture_rg = GL_FALSE;
2899
GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE;
677 janba 2900
GLboolean __GLEW_ARB_texture_stencil8 = GL_FALSE;
667 khor 2901
GLboolean __GLEW_ARB_texture_storage = GL_FALSE;
2902
GLboolean __GLEW_ARB_texture_storage_multisample = GL_FALSE;
2903
GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE;
2904
GLboolean __GLEW_ARB_texture_view = GL_FALSE;
2905
GLboolean __GLEW_ARB_timer_query = GL_FALSE;
2906
GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE;
2907
GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE;
2908
GLboolean __GLEW_ARB_transform_feedback_instanced = GL_FALSE;
2909
GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;
2910
GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE;
2911
GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE;
2912
GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE;
2913
GLboolean __GLEW_ARB_vertex_attrib_64bit = GL_FALSE;
2914
GLboolean __GLEW_ARB_vertex_attrib_binding = GL_FALSE;
2915
GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;
2916
GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;
2917
GLboolean __GLEW_ARB_vertex_program = GL_FALSE;
2918
GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;
677 janba 2919
GLboolean __GLEW_ARB_vertex_type_10f_11f_11f_rev = GL_FALSE;
667 khor 2920
GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE;
2921
GLboolean __GLEW_ARB_viewport_array = GL_FALSE;
2922
GLboolean __GLEW_ARB_window_pos = GL_FALSE;
2923
GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;
2924
GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;
2925
GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;
2926
GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;
2927
GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;
2928
GLboolean __GLEW_ATI_element_array = GL_FALSE;
2929
GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;
2930
GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;
2931
GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;
2932
GLboolean __GLEW_ATI_meminfo = GL_FALSE;
2933
GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;
2934
GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;
2935
GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;
2936
GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;
2937
GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;
2938
GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;
2939
GLboolean __GLEW_ATI_texture_float = GL_FALSE;
2940
GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;
2941
GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;
2942
GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;
2943
GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;
2944
GLboolean __GLEW_EXT_422_pixels = GL_FALSE;
2945
GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;
2946
GLboolean __GLEW_EXT_abgr = GL_FALSE;
2947
GLboolean __GLEW_EXT_bgra = GL_FALSE;
2948
GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE;
2949
GLboolean __GLEW_EXT_blend_color = GL_FALSE;
2950
GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;
2951
GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;
2952
GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;
2953
GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;
2954
GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;
2955
GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;
2956
GLboolean __GLEW_EXT_cmyka = GL_FALSE;
2957
GLboolean __GLEW_EXT_color_subtable = GL_FALSE;
2958
GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;
2959
GLboolean __GLEW_EXT_convolution = GL_FALSE;
2960
GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;
2961
GLboolean __GLEW_EXT_copy_texture = GL_FALSE;
2962
GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;
2963
GLboolean __GLEW_EXT_debug_marker = GL_FALSE;
2964
GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;
2965
GLboolean __GLEW_EXT_direct_state_access = GL_FALSE;
2966
GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE;
2967
GLboolean __GLEW_EXT_draw_instanced = GL_FALSE;
2968
GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;
2969
GLboolean __GLEW_EXT_fog_coord = GL_FALSE;
2970
GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;
2971
GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;
2972
GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;
2973
GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE;
2974
GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;
2975
GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE;
2976
GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE;
2977
GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE;
2978
GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE;
2979
GLboolean __GLEW_EXT_histogram = GL_FALSE;
2980
GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;
2981
GLboolean __GLEW_EXT_index_func = GL_FALSE;
2982
GLboolean __GLEW_EXT_index_material = GL_FALSE;
2983
GLboolean __GLEW_EXT_index_texture = GL_FALSE;
2984
GLboolean __GLEW_EXT_light_texture = GL_FALSE;
2985
GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;
2986
GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;
2987
GLboolean __GLEW_EXT_multisample = GL_FALSE;
2988
GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE;
2989
GLboolean __GLEW_EXT_packed_float = GL_FALSE;
2990
GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;
2991
GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;
2992
GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;
2993
GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;
2994
GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;
2995
GLboolean __GLEW_EXT_point_parameters = GL_FALSE;
2996
GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;
2997
GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE;
2998
GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;
2999
GLboolean __GLEW_EXT_scene_marker = GL_FALSE;
3000
GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
3001
GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE;
3002
GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;
3003
GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE;
3004
GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;
3005
GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;
3006
GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;
3007
GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;
3008
GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;
3009
GLboolean __GLEW_EXT_subtexture = GL_FALSE;
3010
GLboolean __GLEW_EXT_texture = GL_FALSE;
3011
GLboolean __GLEW_EXT_texture3D = GL_FALSE;
3012
GLboolean __GLEW_EXT_texture_array = GL_FALSE;
3013
GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE;
3014
GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;
3015
GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE;
3016
GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE;
3017
GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;
3018
GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;
3019
GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;
3020
GLboolean __GLEW_EXT_texture_env = GL_FALSE;
3021
GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;
3022
GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;
3023
GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;
3024
GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;
3025
GLboolean __GLEW_EXT_texture_integer = GL_FALSE;
3026
GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;
3027
GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;
3028
GLboolean __GLEW_EXT_texture_object = GL_FALSE;
3029
GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;
3030
GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;
3031
GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;
3032
GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE;
3033
GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;
3034
GLboolean __GLEW_EXT_texture_snorm = GL_FALSE;
3035
GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;
3036
GLboolean __GLEW_EXT_timer_query = GL_FALSE;
3037
GLboolean __GLEW_EXT_transform_feedback = GL_FALSE;
3038
GLboolean __GLEW_EXT_vertex_array = GL_FALSE;
3039
GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE;
3040
GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE;
3041
GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;
3042
GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;
3043
GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE;
3044
GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;
3045
GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE;
3046
GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;
3047
GLboolean __GLEW_HP_image_transform = GL_FALSE;
3048
GLboolean __GLEW_HP_occlusion_test = GL_FALSE;
3049
GLboolean __GLEW_HP_texture_lighting = GL_FALSE;
3050
GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;
3051
GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;
3052
GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;
3053
GLboolean __GLEW_IBM_static_data = GL_FALSE;
3054
GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;
3055
GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;
3056
GLboolean __GLEW_INGR_color_clamp = GL_FALSE;
3057
GLboolean __GLEW_INGR_interlace_read = GL_FALSE;
677 janba 3058
GLboolean __GLEW_INTEL_map_texture = GL_FALSE;
667 khor 3059
GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;
3060
GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;
3061
GLboolean __GLEW_KHR_debug = GL_FALSE;
3062
GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE;
3063
GLboolean __GLEW_KTX_buffer_region = GL_FALSE;
3064
GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;
3065
GLboolean __GLEW_MESA_pack_invert = GL_FALSE;
3066
GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;
3067
GLboolean __GLEW_MESA_window_pos = GL_FALSE;
3068
GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;
677 janba 3069
GLboolean __GLEW_NVX_conditional_render = GL_FALSE;
667 khor 3070
GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE;
677 janba 3071
GLboolean __GLEW_NV_bindless_multi_draw_indirect = GL_FALSE;
667 khor 3072
GLboolean __GLEW_NV_bindless_texture = GL_FALSE;
677 janba 3073
GLboolean __GLEW_NV_blend_equation_advanced = GL_FALSE;
3074
GLboolean __GLEW_NV_blend_equation_advanced_coherent = GL_FALSE;
667 khor 3075
GLboolean __GLEW_NV_blend_square = GL_FALSE;
677 janba 3076
GLboolean __GLEW_NV_compute_program5 = GL_FALSE;
667 khor 3077
GLboolean __GLEW_NV_conditional_render = GL_FALSE;
3078
GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;
3079
GLboolean __GLEW_NV_copy_image = GL_FALSE;
677 janba 3080
GLboolean __GLEW_NV_deep_texture3D = GL_FALSE;
667 khor 3081
GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;
3082
GLboolean __GLEW_NV_depth_clamp = GL_FALSE;
3083
GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;
677 janba 3084
GLboolean __GLEW_NV_draw_texture = GL_FALSE;
667 khor 3085
GLboolean __GLEW_NV_evaluators = GL_FALSE;
3086
GLboolean __GLEW_NV_explicit_multisample = GL_FALSE;
3087
GLboolean __GLEW_NV_fence = GL_FALSE;
3088
GLboolean __GLEW_NV_float_buffer = GL_FALSE;
3089
GLboolean __GLEW_NV_fog_distance = GL_FALSE;
3090
GLboolean __GLEW_NV_fragment_program = GL_FALSE;
3091
GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;
3092
GLboolean __GLEW_NV_fragment_program4 = GL_FALSE;
3093
GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;
3094
GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;
3095
GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;
3096
GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;
3097
GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;
3098
GLboolean __GLEW_NV_gpu_program5 = GL_FALSE;
677 janba 3099
GLboolean __GLEW_NV_gpu_program5_mem_extended = GL_FALSE;
667 khor 3100
GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE;
3101
GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE;
3102
GLboolean __GLEW_NV_half_float = GL_FALSE;
3103
GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;
3104
GLboolean __GLEW_NV_multisample_coverage = GL_FALSE;
3105
GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;
3106
GLboolean __GLEW_NV_occlusion_query = GL_FALSE;
3107
GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;
3108
GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;
3109
GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE;
3110
GLboolean __GLEW_NV_path_rendering = GL_FALSE;
3111
GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;
3112
GLboolean __GLEW_NV_point_sprite = GL_FALSE;
3113
GLboolean __GLEW_NV_present_video = GL_FALSE;
3114
GLboolean __GLEW_NV_primitive_restart = GL_FALSE;
3115
GLboolean __GLEW_NV_register_combiners = GL_FALSE;
3116
GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;
677 janba 3117
GLboolean __GLEW_NV_shader_atomic_counters = GL_FALSE;
667 khor 3118
GLboolean __GLEW_NV_shader_atomic_float = GL_FALSE;
3119
GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE;
677 janba 3120
GLboolean __GLEW_NV_shader_storage_buffer_object = GL_FALSE;
667 khor 3121
GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE;
3122
GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;
3123
GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;
3124
GLboolean __GLEW_NV_texture_barrier = GL_FALSE;
3125
GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;
3126
GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;
3127
GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;
3128
GLboolean __GLEW_NV_texture_multisample = GL_FALSE;
3129
GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;
3130
GLboolean __GLEW_NV_texture_shader = GL_FALSE;
3131
GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;
3132
GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;
3133
GLboolean __GLEW_NV_transform_feedback = GL_FALSE;
3134
GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE;
3135
GLboolean __GLEW_NV_vdpau_interop = GL_FALSE;
3136
GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;
3137
GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;
3138
GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE;
3139
GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE;
3140
GLboolean __GLEW_NV_vertex_program = GL_FALSE;
3141
GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;
3142
GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;
3143
GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;
3144
GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;
3145
GLboolean __GLEW_NV_vertex_program4 = GL_FALSE;
3146
GLboolean __GLEW_NV_video_capture = GL_FALSE;
3147
GLboolean __GLEW_OES_byte_coordinates = GL_FALSE;
3148
GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE;
3149
GLboolean __GLEW_OES_read_format = GL_FALSE;
3150
GLboolean __GLEW_OES_single_precision = GL_FALSE;
3151
GLboolean __GLEW_OML_interlace = GL_FALSE;
3152
GLboolean __GLEW_OML_resample = GL_FALSE;
3153
GLboolean __GLEW_OML_subsample = GL_FALSE;
3154
GLboolean __GLEW_PGI_misc_hints = GL_FALSE;
3155
GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;
677 janba 3156
GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE;
3157
GLboolean __GLEW_REGAL_ES1_1_compatibility = GL_FALSE;
3158
GLboolean __GLEW_REGAL_enable = GL_FALSE;
667 khor 3159
GLboolean __GLEW_REGAL_error_string = GL_FALSE;
3160
GLboolean __GLEW_REGAL_extension_query = GL_FALSE;
3161
GLboolean __GLEW_REGAL_log = GL_FALSE;
3162
GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;
3163
GLboolean __GLEW_S3_s3tc = GL_FALSE;
3164
GLboolean __GLEW_SGIS_color_range = GL_FALSE;
3165
GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;
3166
GLboolean __GLEW_SGIS_fog_function = GL_FALSE;
3167
GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;
3168
GLboolean __GLEW_SGIS_multisample = GL_FALSE;
3169
GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;
3170
GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE;
3171
GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;
3172
GLboolean __GLEW_SGIS_texture4D = GL_FALSE;
3173
GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;
3174
GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;
3175
GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;
3176
GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;
3177
GLboolean __GLEW_SGIS_texture_select = GL_FALSE;
3178
GLboolean __GLEW_SGIX_async = GL_FALSE;
3179
GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;
3180
GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;
3181
GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;
3182
GLboolean __GLEW_SGIX_clipmap = GL_FALSE;
3183
GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE;
3184
GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;
3185
GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;
3186
GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;
3187
GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;
3188
GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;
3189
GLboolean __GLEW_SGIX_framezoom = GL_FALSE;
3190
GLboolean __GLEW_SGIX_interlace = GL_FALSE;
3191
GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;
3192
GLboolean __GLEW_SGIX_list_priority = GL_FALSE;
3193
GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;
3194
GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;
3195
GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;
3196
GLboolean __GLEW_SGIX_resample = GL_FALSE;
3197
GLboolean __GLEW_SGIX_shadow = GL_FALSE;
3198
GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;
3199
GLboolean __GLEW_SGIX_sprite = GL_FALSE;
3200
GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;
3201
GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;
3202
GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;
3203
GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;
3204
GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;
3205
GLboolean __GLEW_SGIX_texture_range = GL_FALSE;
3206
GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;
3207
GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;
3208
GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;
3209
GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;
3210
GLboolean __GLEW_SGI_color_matrix = GL_FALSE;
3211
GLboolean __GLEW_SGI_color_table = GL_FALSE;
3212
GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;
3213
GLboolean __GLEW_SUNX_constant_data = GL_FALSE;
3214
GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;
3215
GLboolean __GLEW_SUN_global_alpha = GL_FALSE;
3216
GLboolean __GLEW_SUN_mesh_array = GL_FALSE;
3217
GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;
3218
GLboolean __GLEW_SUN_slice_accum = GL_FALSE;
3219
GLboolean __GLEW_SUN_triangle_list = GL_FALSE;
3220
GLboolean __GLEW_SUN_vertex = GL_FALSE;
3221
GLboolean __GLEW_WIN_phong_shading = GL_FALSE;
3222
GLboolean __GLEW_WIN_specular_fog = GL_FALSE;
3223
GLboolean __GLEW_WIN_swap_hint = GL_FALSE;
3224
 
3225
#endif /* !GLEW_MX */
3226
 
3227
#ifdef GL_VERSION_1_2
3228
 
3229
static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)
3230
{
3231
  GLboolean r = GL_FALSE;
3232
 
3233
  r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r;
3234
  r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r;
3235
  r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r;
3236
  r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r;
3237
 
3238
  return r;
3239
}
3240
 
3241
#endif /* GL_VERSION_1_2 */
3242
 
3243
#ifdef GL_VERSION_1_2_1
3244
 
3245
#endif /* GL_VERSION_1_2_1 */
3246
 
3247
#ifdef GL_VERSION_1_3
3248
 
3249
static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)
3250
{
3251
  GLboolean r = GL_FALSE;
3252
 
3253
  r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r;
3254
  r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r;
3255
  r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r;
3256
  r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r;
3257
  r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r;
3258
  r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r;
3259
  r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r;
3260
  r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r;
3261
  r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r;
3262
  r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r;
3263
  r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r;
3264
  r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r;
3265
  r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r;
3266
  r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r;
3267
  r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r;
3268
  r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r;
3269
  r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r;
3270
  r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r;
3271
  r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r;
3272
  r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r;
3273
  r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r;
3274
  r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r;
3275
  r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r;
3276
  r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r;
3277
  r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r;
3278
  r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r;
3279
  r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r;
3280
  r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r;
3281
  r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r;
3282
  r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r;
3283
  r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r;
3284
  r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r;
3285
  r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r;
3286
  r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r;
3287
  r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r;
3288
  r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r;
3289
  r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r;
3290
  r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r;
3291
  r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r;
3292
  r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r;
3293
  r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r;
3294
  r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r;
3295
  r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r;
3296
  r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r;
3297
  r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r;
3298
  r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r;
3299
 
3300
  return r;
3301
}
3302
 
3303
#endif /* GL_VERSION_1_3 */
3304
 
3305
#ifdef GL_VERSION_1_4
3306
 
3307
static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)
3308
{
3309
  GLboolean r = GL_FALSE;
3310
 
3311
  r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r;
3312
  r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
3313
  r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r;
3314
  r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r;
3315
  r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r;
3316
  r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r;
3317
  r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r;
3318
  r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r;
3319
  r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r;
3320
  r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r;
3321
  r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r;
3322
  r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r;
3323
  r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r;
3324
  r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r;
3325
  r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r;
3326
  r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r;
3327
  r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r;
3328
  r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r;
3329
  r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r;
3330
  r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r;
3331
  r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r;
3332
  r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r;
3333
  r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r;
3334
  r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r;
3335
  r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r;
3336
  r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r;
3337
  r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r;
3338
  r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r;
3339
  r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r;
3340
  r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r;
3341
  r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r;
3342
  r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r;
3343
  r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r;
3344
  r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r;
3345
  r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r;
3346
  r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r;
3347
  r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r;
3348
  r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r;
3349
  r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r;
3350
  r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r;
3351
  r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r;
3352
  r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r;
3353
  r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r;
3354
  r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r;
3355
  r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r;
3356
  r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r;
3357
  r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r;
3358
 
3359
  return r;
3360
}
3361
 
3362
#endif /* GL_VERSION_1_4 */
3363
 
3364
#ifdef GL_VERSION_1_5
3365
 
3366
static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)
3367
{
3368
  GLboolean r = GL_FALSE;
3369
 
3370
  r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r;
3371
  r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r;
3372
  r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r;
3373
  r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r;
3374
  r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r;
3375
  r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r;
3376
  r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r;
3377
  r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r;
3378
  r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r;
3379
  r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r;
3380
  r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r;
3381
  r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r;
3382
  r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r;
3383
  r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r;
3384
  r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r;
3385
  r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r;
3386
  r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r;
3387
  r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r;
3388
  r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r;
3389
 
3390
  return r;
3391
}
3392
 
3393
#endif /* GL_VERSION_1_5 */
3394
 
3395
#ifdef GL_VERSION_2_0
3396
 
3397
static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)
3398
{
3399
  GLboolean r = GL_FALSE;
3400
 
3401
  r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r;
3402
  r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r;
3403
  r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r;
3404
  r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r;
3405
  r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r;
3406
  r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r;
3407
  r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r;
3408
  r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r;
3409
  r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r;
3410
  r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r;
3411
  r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r;
3412
  r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r;
3413
  r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r;
3414
  r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r;
3415
  r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r;
3416
  r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r;
3417
  r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r;
3418
  r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r;
3419
  r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r;
3420
  r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r;
3421
  r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r;
3422
  r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r;
3423
  r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r;
3424
  r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r;
3425
  r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r;
3426
  r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r;
3427
  r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r;
3428
  r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r;
3429
  r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r;
3430
  r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r;
3431
  r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r;
3432
  r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r;
3433
  r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r;
3434
  r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r;
3435
  r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r;
3436
  r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r;
3437
  r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r;
3438
  r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r;
3439
  r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r;
3440
  r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r;
3441
  r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r;
3442
  r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r;
3443
  r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r;
3444
  r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r;
3445
  r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r;
3446
  r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r;
3447
  r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r;
3448
  r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r;
3449
  r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r;
3450
  r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r;
3451
  r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r;
3452
  r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r;
3453
  r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r;
3454
  r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r;
3455
  r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r;
3456
  r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r;
3457
  r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r;
3458
  r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r;
3459
  r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r;
3460
  r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r;
3461
  r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r;
3462
  r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r;
3463
  r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r;
3464
  r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r;
3465
  r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r;
3466
  r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r;
3467
  r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r;
3468
  r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r;
3469
  r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r;
3470
  r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r;
3471
  r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r;
3472
  r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r;
3473
  r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r;
3474
  r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r;
3475
  r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r;
3476
  r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r;
3477
  r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r;
3478
  r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r;
3479
  r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r;
3480
  r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r;
3481
  r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r;
3482
  r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r;
3483
  r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r;
3484
  r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r;
3485
  r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r;
3486
  r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r;
3487
  r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r;
3488
  r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r;
3489
  r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r;
3490
  r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r;
3491
  r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r;
3492
  r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r;
3493
  r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r;
3494
 
3495
  return r;
3496
}
3497
 
3498
#endif /* GL_VERSION_2_0 */
3499
 
3500
#ifdef GL_VERSION_2_1
3501
 
3502
static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT)
3503
{
3504
  GLboolean r = GL_FALSE;
3505
 
3506
  r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r;
3507
  r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r;
3508
  r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r;
3509
  r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r;
3510
  r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r;
3511
  r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r;
3512
 
3513
  return r;
3514
}
3515
 
3516
#endif /* GL_VERSION_2_1 */
3517
 
3518
#ifdef GL_VERSION_3_0
3519
 
3520
static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)
3521
{
3522
  GLboolean r = GL_FALSE;
3523
 
3524
  r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r;
3525
  r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r;
3526
  r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r;
3527
  r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r;
3528
  r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r;
3529
  r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r;
3530
  r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r;
3531
  r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r;
3532
  r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r;
3533
  r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r;
3534
  r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r;
3535
  r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r;
3536
  r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r;
3537
  r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r;
3538
  r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r;
3539
  r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r;
3540
  r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r;
3541
  r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r;
3542
  r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r;
3543
  r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r;
3544
  r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r;
3545
  r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r;
3546
  r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r;
3547
  r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r;
3548
  r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r;
3549
  r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r;
3550
  r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r;
3551
  r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r;
3552
  r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r;
3553
  r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r;
3554
  r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r;
3555
  r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r;
3556
  r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r;
3557
  r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r;
3558
  r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r;
3559
  r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r;
3560
  r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r;
3561
  r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r;
3562
  r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r;
3563
  r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r;
3564
  r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r;
3565
  r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r;
3566
  r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r;
3567
  r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r;
3568
  r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r;
3569
  r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r;
3570
  r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r;
3571
  r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r;
3572
  r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r;
3573
  r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r;
3574
  r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r;
3575
  r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r;
3576
  r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r;
3577
  r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r;
3578
  r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r;
3579
 
3580
  return r;
3581
}
3582
 
3583
#endif /* GL_VERSION_3_0 */
3584
 
3585
#ifdef GL_VERSION_3_1
3586
 
3587
static GLboolean _glewInit_GL_VERSION_3_1 (GLEW_CONTEXT_ARG_DEF_INIT)
3588
{
3589
  GLboolean r = GL_FALSE;
3590
 
3591
  r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r;
3592
  r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r;
3593
  r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r;
3594
  r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r;
3595
 
3596
  return r;
3597
}
3598
 
3599
#endif /* GL_VERSION_3_1 */
3600
 
3601
#ifdef GL_VERSION_3_2
3602
 
3603
static GLboolean _glewInit_GL_VERSION_3_2 (GLEW_CONTEXT_ARG_DEF_INIT)
3604
{
3605
  GLboolean r = GL_FALSE;
3606
 
3607
  r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r;
3608
  r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r;
3609
  r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r;
3610
 
3611
  return r;
3612
}
3613
 
3614
#endif /* GL_VERSION_3_2 */
3615
 
3616
#ifdef GL_VERSION_3_3
3617
 
3618
static GLboolean _glewInit_GL_VERSION_3_3 (GLEW_CONTEXT_ARG_DEF_INIT)
3619
{
3620
  GLboolean r = GL_FALSE;
3621
 
3622
  r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r;
3623
 
3624
  return r;
3625
}
3626
 
3627
#endif /* GL_VERSION_3_3 */
3628
 
3629
#ifdef GL_VERSION_4_0
3630
 
3631
static GLboolean _glewInit_GL_VERSION_4_0 (GLEW_CONTEXT_ARG_DEF_INIT)
3632
{
3633
  GLboolean r = GL_FALSE;
3634
 
3635
  r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r;
3636
  r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r;
3637
  r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r;
3638
  r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r;
3639
  r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r;
3640
 
3641
  return r;
3642
}
3643
 
3644
#endif /* GL_VERSION_4_0 */
3645
 
3646
#ifdef GL_VERSION_4_1
3647
 
3648
#endif /* GL_VERSION_4_1 */
3649
 
3650
#ifdef GL_VERSION_4_2
3651
 
3652
#endif /* GL_VERSION_4_2 */
3653
 
3654
#ifdef GL_VERSION_4_3
3655
 
3656
#endif /* GL_VERSION_4_3 */
3657
 
677 janba 3658
#ifdef GL_VERSION_4_4
3659
 
3660
#endif /* GL_VERSION_4_4 */
3661
 
667 khor 3662
#ifdef GL_3DFX_multisample
3663
 
3664
#endif /* GL_3DFX_multisample */
3665
 
3666
#ifdef GL_3DFX_tbuffer
3667
 
3668
static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)
3669
{
3670
  GLboolean r = GL_FALSE;
3671
 
3672
  r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r;
3673
 
3674
  return r;
3675
}
3676
 
3677
#endif /* GL_3DFX_tbuffer */
3678
 
3679
#ifdef GL_3DFX_texture_compression_FXT1
3680
 
3681
#endif /* GL_3DFX_texture_compression_FXT1 */
3682
 
3683
#ifdef GL_AMD_blend_minmax_factor
3684
 
3685
#endif /* GL_AMD_blend_minmax_factor */
3686
 
3687
#ifdef GL_AMD_conservative_depth
3688
 
3689
#endif /* GL_AMD_conservative_depth */
3690
 
3691
#ifdef GL_AMD_debug_output
3692
 
3693
static GLboolean _glewInit_GL_AMD_debug_output (GLEW_CONTEXT_ARG_DEF_INIT)
3694
{
3695
  GLboolean r = GL_FALSE;
3696
 
3697
  r = ((glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackAMD")) == NULL) || r;
3698
  r = ((glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageEnableAMD")) == NULL) || r;
3699
  r = ((glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertAMD")) == NULL) || r;
3700
  r = ((glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogAMD")) == NULL) || r;
3701
 
3702
  return r;
3703
}
3704
 
3705
#endif /* GL_AMD_debug_output */
3706
 
3707
#ifdef GL_AMD_depth_clamp_separate
3708
 
3709
#endif /* GL_AMD_depth_clamp_separate */
3710
 
3711
#ifdef GL_AMD_draw_buffers_blend
3712
 
3713
static GLboolean _glewInit_GL_AMD_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
3714
{
3715
  GLboolean r = GL_FALSE;
3716
 
3717
  r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r;
3718
  r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r;
3719
  r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r;
3720
  r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r;
3721
 
3722
  return r;
3723
}
3724
 
3725
#endif /* GL_AMD_draw_buffers_blend */
3726
 
677 janba 3727
#ifdef GL_AMD_interleaved_elements
3728
 
3729
static GLboolean _glewInit_GL_AMD_interleaved_elements (GLEW_CONTEXT_ARG_DEF_INIT)
3730
{
3731
  GLboolean r = GL_FALSE;
3732
 
3733
  r = ((glVertexAttribParameteriAMD = (PFNGLVERTEXATTRIBPARAMETERIAMDPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribParameteriAMD")) == NULL) || r;
3734
 
3735
  return r;
3736
}
3737
 
3738
#endif /* GL_AMD_interleaved_elements */
3739
 
667 khor 3740
#ifdef GL_AMD_multi_draw_indirect
3741
 
3742
static GLboolean _glewInit_GL_AMD_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
3743
{
3744
  GLboolean r = GL_FALSE;
3745
 
3746
  r = ((glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectAMD")) == NULL) || r;
3747
  r = ((glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectAMD")) == NULL) || r;
3748
 
3749
  return r;
3750
}
3751
 
3752
#endif /* GL_AMD_multi_draw_indirect */
3753
 
3754
#ifdef GL_AMD_name_gen_delete
3755
 
3756
static GLboolean _glewInit_GL_AMD_name_gen_delete (GLEW_CONTEXT_ARG_DEF_INIT)
3757
{
3758
  GLboolean r = GL_FALSE;
3759
 
3760
  r = ((glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamesAMD")) == NULL) || r;
3761
  r = ((glGenNamesAMD = (PFNGLGENNAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glGenNamesAMD")) == NULL) || r;
3762
  r = ((glIsNameAMD = (PFNGLISNAMEAMDPROC)glewGetProcAddress((const GLubyte*)"glIsNameAMD")) == NULL) || r;
3763
 
3764
  return r;
3765
}
3766
 
3767
#endif /* GL_AMD_name_gen_delete */
3768
 
3769
#ifdef GL_AMD_performance_monitor
3770
 
3771
static GLboolean _glewInit_GL_AMD_performance_monitor (GLEW_CONTEXT_ARG_DEF_INIT)
3772
{
3773
  GLboolean r = GL_FALSE;
3774
 
3775
  r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r;
3776
  r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r;
3777
  r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r;
3778
  r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r;
3779
  r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r;
3780
  r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r;
3781
  r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r;
3782
  r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r;
3783
  r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r;
3784
  r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r;
3785
  r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r;
3786
 
3787
  return r;
3788
}
3789
 
3790
#endif /* GL_AMD_performance_monitor */
3791
 
3792
#ifdef GL_AMD_pinned_memory
3793
 
3794
#endif /* GL_AMD_pinned_memory */
3795
 
3796
#ifdef GL_AMD_query_buffer_object
3797
 
3798
#endif /* GL_AMD_query_buffer_object */
3799
 
3800
#ifdef GL_AMD_sample_positions
3801
 
3802
static GLboolean _glewInit_GL_AMD_sample_positions (GLEW_CONTEXT_ARG_DEF_INIT)
3803
{
3804
  GLboolean r = GL_FALSE;
3805
 
3806
  r = ((glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC)glewGetProcAddress((const GLubyte*)"glSetMultisamplefvAMD")) == NULL) || r;
3807
 
3808
  return r;
3809
}
3810
 
3811
#endif /* GL_AMD_sample_positions */
3812
 
3813
#ifdef GL_AMD_seamless_cubemap_per_texture
3814
 
3815
#endif /* GL_AMD_seamless_cubemap_per_texture */
3816
 
3817
#ifdef GL_AMD_shader_stencil_export
3818
 
3819
#endif /* GL_AMD_shader_stencil_export */
3820
 
677 janba 3821
#ifdef GL_AMD_shader_trinary_minmax
3822
 
3823
#endif /* GL_AMD_shader_trinary_minmax */
3824
 
3825
#ifdef GL_AMD_sparse_texture
3826
 
3827
static GLboolean _glewInit_GL_AMD_sparse_texture (GLEW_CONTEXT_ARG_DEF_INIT)
3828
{
3829
  GLboolean r = GL_FALSE;
3830
 
3831
  r = ((glTexStorageSparseAMD = (PFNGLTEXSTORAGESPARSEAMDPROC)glewGetProcAddress((const GLubyte*)"glTexStorageSparseAMD")) == NULL) || r;
3832
  r = ((glTextureStorageSparseAMD = (PFNGLTEXTURESTORAGESPARSEAMDPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageSparseAMD")) == NULL) || r;
3833
 
3834
  return r;
3835
}
3836
 
3837
#endif /* GL_AMD_sparse_texture */
3838
 
667 khor 3839
#ifdef GL_AMD_stencil_operation_extended
3840
 
3841
static GLboolean _glewInit_GL_AMD_stencil_operation_extended (GLEW_CONTEXT_ARG_DEF_INIT)
3842
{
3843
  GLboolean r = GL_FALSE;
3844
 
3845
  r = ((glStencilOpValueAMD = (PFNGLSTENCILOPVALUEAMDPROC)glewGetProcAddress((const GLubyte*)"glStencilOpValueAMD")) == NULL) || r;
3846
 
3847
  return r;
3848
}
3849
 
3850
#endif /* GL_AMD_stencil_operation_extended */
3851
 
3852
#ifdef GL_AMD_texture_texture4
3853
 
3854
#endif /* GL_AMD_texture_texture4 */
3855
 
3856
#ifdef GL_AMD_transform_feedback3_lines_triangles
3857
 
3858
#endif /* GL_AMD_transform_feedback3_lines_triangles */
3859
 
3860
#ifdef GL_AMD_vertex_shader_layer
3861
 
3862
#endif /* GL_AMD_vertex_shader_layer */
3863
 
3864
#ifdef GL_AMD_vertex_shader_tessellator
3865
 
3866
static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (GLEW_CONTEXT_ARG_DEF_INIT)
3867
{
3868
  GLboolean r = GL_FALSE;
3869
 
3870
  r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r;
3871
  r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r;
3872
 
3873
  return r;
3874
}
3875
 
3876
#endif /* GL_AMD_vertex_shader_tessellator */
3877
 
3878
#ifdef GL_AMD_vertex_shader_viewport_index
3879
 
3880
#endif /* GL_AMD_vertex_shader_viewport_index */
3881
 
677 janba 3882
#ifdef GL_ANGLE_depth_texture
3883
 
3884
#endif /* GL_ANGLE_depth_texture */
3885
 
3886
#ifdef GL_ANGLE_framebuffer_blit
3887
 
3888
static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT)
3889
{
3890
  GLboolean r = GL_FALSE;
3891
 
3892
  r = ((glBlitFramebufferANGLE = (PFNGLBLITFRAMEBUFFERANGLEPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferANGLE")) == NULL) || r;
3893
 
3894
  return r;
3895
}
3896
 
3897
#endif /* GL_ANGLE_framebuffer_blit */
3898
 
3899
#ifdef GL_ANGLE_framebuffer_multisample
3900
 
3901
static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
3902
{
3903
  GLboolean r = GL_FALSE;
3904
 
3905
  r = ((glRenderbufferStorageMultisampleANGLE = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleANGLE")) == NULL) || r;
3906
 
3907
  return r;
3908
}
3909
 
3910
#endif /* GL_ANGLE_framebuffer_multisample */
3911
 
3912
#ifdef GL_ANGLE_instanced_arrays
3913
 
3914
static GLboolean _glewInit_GL_ANGLE_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
3915
{
3916
  GLboolean r = GL_FALSE;
3917
 
3918
  r = ((glDrawArraysInstancedANGLE = (PFNGLDRAWARRAYSINSTANCEDANGLEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedANGLE")) == NULL) || r;
3919
  r = ((glDrawElementsInstancedANGLE = (PFNGLDRAWELEMENTSINSTANCEDANGLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedANGLE")) == NULL) || r;
3920
  r = ((glVertexAttribDivisorANGLE = (PFNGLVERTEXATTRIBDIVISORANGLEPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorANGLE")) == NULL) || r;
3921
 
3922
  return r;
3923
}
3924
 
3925
#endif /* GL_ANGLE_instanced_arrays */
3926
 
3927
#ifdef GL_ANGLE_pack_reverse_row_order
3928
 
3929
#endif /* GL_ANGLE_pack_reverse_row_order */
3930
 
3931
#ifdef GL_ANGLE_program_binary
3932
 
3933
#endif /* GL_ANGLE_program_binary */
3934
 
3935
#ifdef GL_ANGLE_texture_compression_dxt1
3936
 
3937
#endif /* GL_ANGLE_texture_compression_dxt1 */
3938
 
3939
#ifdef GL_ANGLE_texture_compression_dxt3
3940
 
3941
#endif /* GL_ANGLE_texture_compression_dxt3 */
3942
 
3943
#ifdef GL_ANGLE_texture_compression_dxt5
3944
 
3945
#endif /* GL_ANGLE_texture_compression_dxt5 */
3946
 
3947
#ifdef GL_ANGLE_texture_usage
3948
 
3949
#endif /* GL_ANGLE_texture_usage */
3950
 
3951
#ifdef GL_ANGLE_timer_query
3952
 
3953
static GLboolean _glewInit_GL_ANGLE_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
3954
{
3955
  GLboolean r = GL_FALSE;
3956
 
3957
  r = ((glBeginQueryANGLE = (PFNGLBEGINQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryANGLE")) == NULL) || r;
3958
  r = ((glDeleteQueriesANGLE = (PFNGLDELETEQUERIESANGLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesANGLE")) == NULL) || r;
3959
  r = ((glEndQueryANGLE = (PFNGLENDQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glEndQueryANGLE")) == NULL) || r;
3960
  r = ((glGenQueriesANGLE = (PFNGLGENQUERIESANGLEPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesANGLE")) == NULL) || r;
3961
  r = ((glGetQueryObjecti64vANGLE = (PFNGLGETQUERYOBJECTI64VANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vANGLE")) == NULL) || r;
3962
  r = ((glGetQueryObjectivANGLE = (PFNGLGETQUERYOBJECTIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivANGLE")) == NULL) || r;
3963
  r = ((glGetQueryObjectui64vANGLE = (PFNGLGETQUERYOBJECTUI64VANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vANGLE")) == NULL) || r;
3964
  r = ((glGetQueryObjectuivANGLE = (PFNGLGETQUERYOBJECTUIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivANGLE")) == NULL) || r;
3965
  r = ((glGetQueryivANGLE = (PFNGLGETQUERYIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivANGLE")) == NULL) || r;
3966
  r = ((glIsQueryANGLE = (PFNGLISQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glIsQueryANGLE")) == NULL) || r;
3967
  r = ((glQueryCounterANGLE = (PFNGLQUERYCOUNTERANGLEPROC)glewGetProcAddress((const GLubyte*)"glQueryCounterANGLE")) == NULL) || r;
3968
 
3969
  return r;
3970
}
3971
 
3972
#endif /* GL_ANGLE_timer_query */
3973
 
3974
#ifdef GL_ANGLE_translated_shader_source
3975
 
3976
static GLboolean _glewInit_GL_ANGLE_translated_shader_source (GLEW_CONTEXT_ARG_DEF_INIT)
3977
{
3978
  GLboolean r = GL_FALSE;
3979
 
3980
  r = ((glGetTranslatedShaderSourceANGLE = (PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetTranslatedShaderSourceANGLE")) == NULL) || r;
3981
 
3982
  return r;
3983
}
3984
 
3985
#endif /* GL_ANGLE_translated_shader_source */
3986
 
667 khor 3987
#ifdef GL_APPLE_aux_depth_stencil
3988
 
3989
#endif /* GL_APPLE_aux_depth_stencil */
3990
 
3991
#ifdef GL_APPLE_client_storage
3992
 
3993
#endif /* GL_APPLE_client_storage */
3994
 
3995
#ifdef GL_APPLE_element_array
3996
 
3997
static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT)
3998
{
3999
  GLboolean r = GL_FALSE;
4000
 
4001
  r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r;
4002
  r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r;
4003
  r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r;
4004
  r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r;
4005
  r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r;
4006
 
4007
  return r;
4008
}
4009
 
4010
#endif /* GL_APPLE_element_array */
4011
 
4012
#ifdef GL_APPLE_fence
4013
 
4014
static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT)
4015
{
4016
  GLboolean r = GL_FALSE;
4017
 
4018
  r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r;
4019
  r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r;
4020
  r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r;
4021
  r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r;
4022
  r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r;
4023
  r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r;
4024
  r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r;
4025
  r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r;
4026
 
4027
  return r;
4028
}
4029
 
4030
#endif /* GL_APPLE_fence */
4031
 
4032
#ifdef GL_APPLE_float_pixels
4033
 
4034
#endif /* GL_APPLE_float_pixels */
4035
 
4036
#ifdef GL_APPLE_flush_buffer_range
4037
 
4038
static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
4039
{
4040
  GLboolean r = GL_FALSE;
4041
 
4042
  r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r;
4043
  r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r;
4044
 
4045
  return r;
4046
}
4047
 
4048
#endif /* GL_APPLE_flush_buffer_range */
4049
 
4050
#ifdef GL_APPLE_object_purgeable
4051
 
4052
static GLboolean _glewInit_GL_APPLE_object_purgeable (GLEW_CONTEXT_ARG_DEF_INIT)
4053
{
4054
  GLboolean r = GL_FALSE;
4055
 
4056
  r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r;
4057
  r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r;
4058
  r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r;
4059
 
4060
  return r;
4061
}
4062
 
4063
#endif /* GL_APPLE_object_purgeable */
4064
 
4065
#ifdef GL_APPLE_pixel_buffer
4066
 
4067
#endif /* GL_APPLE_pixel_buffer */
4068
 
4069
#ifdef GL_APPLE_rgb_422
4070
 
4071
#endif /* GL_APPLE_rgb_422 */
4072
 
4073
#ifdef GL_APPLE_row_bytes
4074
 
4075
#endif /* GL_APPLE_row_bytes */
4076
 
4077
#ifdef GL_APPLE_specular_vector
4078
 
4079
#endif /* GL_APPLE_specular_vector */
4080
 
4081
#ifdef GL_APPLE_texture_range
4082
 
4083
static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT)
4084
{
4085
  GLboolean r = GL_FALSE;
4086
 
4087
  r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r;
4088
  r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r;
4089
 
4090
  return r;
4091
}
4092
 
4093
#endif /* GL_APPLE_texture_range */
4094
 
4095
#ifdef GL_APPLE_transform_hint
4096
 
4097
#endif /* GL_APPLE_transform_hint */
4098
 
4099
#ifdef GL_APPLE_vertex_array_object
4100
 
4101
static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
4102
{
4103
  GLboolean r = GL_FALSE;
4104
 
4105
  r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r;
4106
  r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r;
4107
  r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r;
4108
  r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r;
4109
 
4110
  return r;
4111
}
4112
 
4113
#endif /* GL_APPLE_vertex_array_object */
4114
 
4115
#ifdef GL_APPLE_vertex_array_range
4116
 
4117
static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
4118
{
4119
  GLboolean r = GL_FALSE;
4120
 
4121
  r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r;
4122
  r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r;
4123
  r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r;
4124
 
4125
  return r;
4126
}
4127
 
4128
#endif /* GL_APPLE_vertex_array_range */
4129
 
4130
#ifdef GL_APPLE_vertex_program_evaluators
4131
 
4132
static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
4133
{
4134
  GLboolean r = GL_FALSE;
4135
 
4136
  r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r;
4137
  r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r;
4138
  r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r;
4139
  r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r;
4140
  r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r;
4141
  r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r;
4142
  r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r;
4143
 
4144
  return r;
4145
}
4146
 
4147
#endif /* GL_APPLE_vertex_program_evaluators */
4148
 
4149
#ifdef GL_APPLE_ycbcr_422
4150
 
4151
#endif /* GL_APPLE_ycbcr_422 */
4152
 
4153
#ifdef GL_ARB_ES2_compatibility
4154
 
4155
static GLboolean _glewInit_GL_ARB_ES2_compatibility (GLEW_CONTEXT_ARG_DEF_INIT)
4156
{
4157
  GLboolean r = GL_FALSE;
4158
 
4159
  r = ((glClearDepthf = (PFNGLCLEARDEPTHFPROC)glewGetProcAddress((const GLubyte*)"glClearDepthf")) == NULL) || r;
4160
  r = ((glDepthRangef = (PFNGLDEPTHRANGEFPROC)glewGetProcAddress((const GLubyte*)"glDepthRangef")) == NULL) || r;
4161
  r = ((glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glewGetProcAddress((const GLubyte*)"glGetShaderPrecisionFormat")) == NULL) || r;
4162
  r = ((glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glewGetProcAddress((const GLubyte*)"glReleaseShaderCompiler")) == NULL) || r;
4163
  r = ((glShaderBinary = (PFNGLSHADERBINARYPROC)glewGetProcAddress((const GLubyte*)"glShaderBinary")) == NULL) || r;
4164
 
4165
  return r;
4166
}
4167
 
4168
#endif /* GL_ARB_ES2_compatibility */
4169
 
4170
#ifdef GL_ARB_ES3_compatibility
4171
 
4172
#endif /* GL_ARB_ES3_compatibility */
4173
 
4174
#ifdef GL_ARB_arrays_of_arrays
4175
 
4176
#endif /* GL_ARB_arrays_of_arrays */
4177
 
4178
#ifdef GL_ARB_base_instance
4179
 
4180
static GLboolean _glewInit_GL_ARB_base_instance (GLEW_CONTEXT_ARG_DEF_INIT)
4181
{
4182
  GLboolean r = GL_FALSE;
4183
 
4184
  r = ((glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstance")) == NULL) || r;
4185
  r = ((glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstance")) == NULL) || r;
4186
  r = ((glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstance")) == NULL) || r;
4187
 
4188
  return r;
4189
}
4190
 
4191
#endif /* GL_ARB_base_instance */
4192
 
677 janba 4193
#ifdef GL_ARB_bindless_texture
4194
 
4195
static GLboolean _glewInit_GL_ARB_bindless_texture (GLEW_CONTEXT_ARG_DEF_INIT)
4196
{
4197
  GLboolean r = GL_FALSE;
4198
 
4199
  r = ((glGetImageHandleARB = (PFNGLGETIMAGEHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleARB")) == NULL) || r;
4200
  r = ((glGetTextureHandleARB = (PFNGLGETTEXTUREHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleARB")) == NULL) || r;
4201
  r = ((glGetTextureSamplerHandleARB = (PFNGLGETTEXTURESAMPLERHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleARB")) == NULL) || r;
4202
  r = ((glGetVertexAttribLui64vARB = (PFNGLGETVERTEXATTRIBLUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vARB")) == NULL) || r;
4203
  r = ((glIsImageHandleResidentARB = (PFNGLISIMAGEHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentARB")) == NULL) || r;
4204
  r = ((glIsTextureHandleResidentARB = (PFNGLISTEXTUREHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentARB")) == NULL) || r;
4205
  r = ((glMakeImageHandleNonResidentARB = (PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentARB")) == NULL) || r;
4206
  r = ((glMakeImageHandleResidentARB = (PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentARB")) == NULL) || r;
4207
  r = ((glMakeTextureHandleNonResidentARB = (PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentARB")) == NULL) || r;
4208
  r = ((glMakeTextureHandleResidentARB = (PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentARB")) == NULL) || r;
4209
  r = ((glProgramUniformHandleui64ARB = (PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64ARB")) == NULL) || r;
4210
  r = ((glProgramUniformHandleui64vARB = (PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vARB")) == NULL) || r;
4211
  r = ((glUniformHandleui64ARB = (PFNGLUNIFORMHANDLEUI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64ARB")) == NULL) || r;
4212
  r = ((glUniformHandleui64vARB = (PFNGLUNIFORMHANDLEUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vARB")) == NULL) || r;
4213
  r = ((glVertexAttribL1ui64ARB = (PFNGLVERTEXATTRIBL1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64ARB")) == NULL) || r;
4214
  r = ((glVertexAttribL1ui64vARB = (PFNGLVERTEXATTRIBL1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vARB")) == NULL) || r;
4215
 
4216
  return r;
4217
}
4218
 
4219
#endif /* GL_ARB_bindless_texture */
4220
 
667 khor 4221
#ifdef GL_ARB_blend_func_extended
4222
 
4223
static GLboolean _glewInit_GL_ARB_blend_func_extended (GLEW_CONTEXT_ARG_DEF_INIT)
4224
{
4225
  GLboolean r = GL_FALSE;
4226
 
4227
  r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r;
4228
  r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r;
4229
 
4230
  return r;
4231
}
4232
 
4233
#endif /* GL_ARB_blend_func_extended */
4234
 
677 janba 4235
#ifdef GL_ARB_buffer_storage
4236
 
4237
static GLboolean _glewInit_GL_ARB_buffer_storage (GLEW_CONTEXT_ARG_DEF_INIT)
4238
{
4239
  GLboolean r = GL_FALSE;
4240
 
4241
  r = ((glBufferStorage = (PFNGLBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glBufferStorage")) == NULL) || r;
4242
  r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r;
4243
 
4244
  return r;
4245
}
4246
 
4247
#endif /* GL_ARB_buffer_storage */
4248
 
667 khor 4249
#ifdef GL_ARB_cl_event
4250
 
4251
static GLboolean _glewInit_GL_ARB_cl_event (GLEW_CONTEXT_ARG_DEF_INIT)
4252
{
4253
  GLboolean r = GL_FALSE;
4254
 
4255
  r = ((glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateSyncFromCLeventARB")) == NULL) || r;
4256
 
4257
  return r;
4258
}
4259
 
4260
#endif /* GL_ARB_cl_event */
4261
 
4262
#ifdef GL_ARB_clear_buffer_object
4263
 
4264
static GLboolean _glewInit_GL_ARB_clear_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
4265
{
4266
  GLboolean r = GL_FALSE;
4267
 
4268
  r = ((glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferData")) == NULL) || r;
4269
  r = ((glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferSubData")) == NULL) || r;
4270
  r = ((glClearNamedBufferDataEXT = (PFNGLCLEARNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferDataEXT")) == NULL) || r;
4271
  r = ((glClearNamedBufferSubDataEXT = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferSubDataEXT")) == NULL) || r;
4272
 
4273
  return r;
4274
}
4275
 
4276
#endif /* GL_ARB_clear_buffer_object */
4277
 
677 janba 4278
#ifdef GL_ARB_clear_texture
4279
 
4280
static GLboolean _glewInit_GL_ARB_clear_texture (GLEW_CONTEXT_ARG_DEF_INIT)
4281
{
4282
  GLboolean r = GL_FALSE;
4283
 
4284
  r = ((glClearTexImage = (PFNGLCLEARTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glClearTexImage")) == NULL) || r;
4285
  r = ((glClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glClearTexSubImage")) == NULL) || r;
4286
 
4287
  return r;
4288
}
4289
 
4290
#endif /* GL_ARB_clear_texture */
4291
 
667 khor 4292
#ifdef GL_ARB_color_buffer_float
4293
 
4294
static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
4295
{
4296
  GLboolean r = GL_FALSE;
4297
 
4298
  r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r;
4299
 
4300
  return r;
4301
}
4302
 
4303
#endif /* GL_ARB_color_buffer_float */
4304
 
4305
#ifdef GL_ARB_compatibility
4306
 
4307
#endif /* GL_ARB_compatibility */
4308
 
4309
#ifdef GL_ARB_compressed_texture_pixel_storage
4310
 
4311
#endif /* GL_ARB_compressed_texture_pixel_storage */
4312
 
4313
#ifdef GL_ARB_compute_shader
4314
 
4315
static GLboolean _glewInit_GL_ARB_compute_shader (GLEW_CONTEXT_ARG_DEF_INIT)
4316
{
4317
  GLboolean r = GL_FALSE;
4318
 
4319
  r = ((glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)glewGetProcAddress((const GLubyte*)"glDispatchCompute")) == NULL) || r;
4320
  r = ((glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeIndirect")) == NULL) || r;
4321
 
4322
  return r;
4323
}
4324
 
4325
#endif /* GL_ARB_compute_shader */
4326
 
677 janba 4327
#ifdef GL_ARB_compute_variable_group_size
4328
 
4329
static GLboolean _glewInit_GL_ARB_compute_variable_group_size (GLEW_CONTEXT_ARG_DEF_INIT)
4330
{
4331
  GLboolean r = GL_FALSE;
4332
 
4333
  r = ((glDispatchComputeGroupSizeARB = (PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeGroupSizeARB")) == NULL) || r;
4334
 
4335
  return r;
4336
}
4337
 
4338
#endif /* GL_ARB_compute_variable_group_size */
4339
 
667 khor 4340
#ifdef GL_ARB_conservative_depth
4341
 
4342
#endif /* GL_ARB_conservative_depth */
4343
 
4344
#ifdef GL_ARB_copy_buffer
4345
 
4346
static GLboolean _glewInit_GL_ARB_copy_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
4347
{
4348
  GLboolean r = GL_FALSE;
4349
 
4350
  r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r;
4351
 
4352
  return r;
4353
}
4354
 
4355
#endif /* GL_ARB_copy_buffer */
4356
 
4357
#ifdef GL_ARB_copy_image
4358
 
4359
static GLboolean _glewInit_GL_ARB_copy_image (GLEW_CONTEXT_ARG_DEF_INIT)
4360
{
4361
  GLboolean r = GL_FALSE;
4362
 
4363
  r = ((glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubData")) == NULL) || r;
4364
 
4365
  return r;
4366
}
4367
 
4368
#endif /* GL_ARB_copy_image */
4369
 
4370
#ifdef GL_ARB_debug_output
4371
 
4372
static GLboolean _glewInit_GL_ARB_debug_output (GLEW_CONTEXT_ARG_DEF_INIT)
4373
{
4374
  GLboolean r = GL_FALSE;
4375
 
4376
  r = ((glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackARB")) == NULL) || r;
4377
  r = ((glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControlARB")) == NULL) || r;
4378
  r = ((glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertARB")) == NULL) || r;
4379
  r = ((glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogARB")) == NULL) || r;
4380
 
4381
  return r;
4382
}
4383
 
4384
#endif /* GL_ARB_debug_output */
4385
 
4386
#ifdef GL_ARB_depth_buffer_float
4387
 
4388
#endif /* GL_ARB_depth_buffer_float */
4389
 
4390
#ifdef GL_ARB_depth_clamp
4391
 
4392
#endif /* GL_ARB_depth_clamp */
4393
 
4394
#ifdef GL_ARB_depth_texture
4395
 
4396
#endif /* GL_ARB_depth_texture */
4397
 
4398
#ifdef GL_ARB_draw_buffers
4399
 
4400
static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
4401
{
4402
  GLboolean r = GL_FALSE;
4403
 
4404
  r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r;
4405
 
4406
  return r;
4407
}
4408
 
4409
#endif /* GL_ARB_draw_buffers */
4410
 
4411
#ifdef GL_ARB_draw_buffers_blend
4412
 
4413
static GLboolean _glewInit_GL_ARB_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
4414
{
4415
  GLboolean r = GL_FALSE;
4416
 
4417
  r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r;
4418
  r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r;
4419
  r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r;
4420
  r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r;
4421
 
4422
  return r;
4423
}
4424
 
4425
#endif /* GL_ARB_draw_buffers_blend */
4426
 
4427
#ifdef GL_ARB_draw_elements_base_vertex
4428
 
4429
static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
4430
{
4431
  GLboolean r = GL_FALSE;
4432
 
4433
  r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r;
4434
  r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r;
4435
  r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r;
4436
  r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r;
4437
 
4438
  return r;
4439
}
4440
 
4441
#endif /* GL_ARB_draw_elements_base_vertex */
4442
 
4443
#ifdef GL_ARB_draw_indirect
4444
 
4445
static GLboolean _glewInit_GL_ARB_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
4446
{
4447
  GLboolean r = GL_FALSE;
4448
 
4449
  r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r;
4450
  r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r;
4451
 
4452
  return r;
4453
}
4454
 
4455
#endif /* GL_ARB_draw_indirect */
4456
 
4457
#ifdef GL_ARB_draw_instanced
4458
 
4459
#endif /* GL_ARB_draw_instanced */
4460
 
677 janba 4461
#ifdef GL_ARB_enhanced_layouts
4462
 
4463
#endif /* GL_ARB_enhanced_layouts */
4464
 
667 khor 4465
#ifdef GL_ARB_explicit_attrib_location
4466
 
4467
#endif /* GL_ARB_explicit_attrib_location */
4468
 
4469
#ifdef GL_ARB_explicit_uniform_location
4470
 
4471
#endif /* GL_ARB_explicit_uniform_location */
4472
 
4473
#ifdef GL_ARB_fragment_coord_conventions
4474
 
4475
#endif /* GL_ARB_fragment_coord_conventions */
4476
 
4477
#ifdef GL_ARB_fragment_layer_viewport
4478
 
4479
#endif /* GL_ARB_fragment_layer_viewport */
4480
 
4481
#ifdef GL_ARB_fragment_program
4482
 
4483
#endif /* GL_ARB_fragment_program */
4484
 
4485
#ifdef GL_ARB_fragment_program_shadow
4486
 
4487
#endif /* GL_ARB_fragment_program_shadow */
4488
 
4489
#ifdef GL_ARB_fragment_shader
4490
 
4491
#endif /* GL_ARB_fragment_shader */
4492
 
4493
#ifdef GL_ARB_framebuffer_no_attachments
4494
 
4495
static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (GLEW_CONTEXT_ARG_DEF_INIT)
4496
{
4497
  GLboolean r = GL_FALSE;
4498
 
4499
  r = ((glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glFramebufferParameteri")) == NULL) || r;
4500
  r = ((glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameteriv")) == NULL) || r;
4501
  r = ((glGetNamedFramebufferParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameterivEXT")) == NULL) || r;
4502
  r = ((glNamedFramebufferParameteriEXT = (PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferParameteriEXT")) == NULL) || r;
4503
 
4504
  return r;
4505
}
4506
 
4507
#endif /* GL_ARB_framebuffer_no_attachments */
4508
 
4509
#ifdef GL_ARB_framebuffer_object
4510
 
4511
static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
4512
{
4513
  GLboolean r = GL_FALSE;
4514
 
4515
  r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r;
4516
  r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r;
4517
  r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r;
4518
  r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r;
4519
  r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r;
4520
  r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r;
4521
  r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r;
4522
  r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r;
4523
  r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r;
4524
  r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r;
4525
  r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r;
4526
  r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r;
4527
  r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r;
4528
  r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r;
4529
  r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r;
4530
  r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r;
4531
  r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r;
4532
  r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r;
4533
  r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r;
4534
  r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r;
4535
 
4536
  return r;
4537
}
4538
 
4539
#endif /* GL_ARB_framebuffer_object */
4540
 
4541
#ifdef GL_ARB_framebuffer_sRGB
4542
 
4543
#endif /* GL_ARB_framebuffer_sRGB */
4544
 
4545
#ifdef GL_ARB_geometry_shader4
4546
 
4547
static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
4548
{
4549
  GLboolean r = GL_FALSE;
4550
 
4551
  r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r;
4552
  r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r;
4553
  r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r;
4554
  r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r;
4555
 
4556
  return r;
4557
}
4558
 
4559
#endif /* GL_ARB_geometry_shader4 */
4560
 
4561
#ifdef GL_ARB_get_program_binary
4562
 
4563
static GLboolean _glewInit_GL_ARB_get_program_binary (GLEW_CONTEXT_ARG_DEF_INIT)
4564
{
4565
  GLboolean r = GL_FALSE;
4566
 
4567
  r = ((glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinary")) == NULL) || r;
4568
  r = ((glProgramBinary = (PFNGLPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glProgramBinary")) == NULL) || r;
4569
  r = ((glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteri")) == NULL) || r;
4570
 
4571
  return r;
4572
}
4573
 
4574
#endif /* GL_ARB_get_program_binary */
4575
 
4576
#ifdef GL_ARB_gpu_shader5
4577
 
4578
#endif /* GL_ARB_gpu_shader5 */
4579
 
4580
#ifdef GL_ARB_gpu_shader_fp64
4581
 
4582
static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (GLEW_CONTEXT_ARG_DEF_INIT)
4583
{
4584
  GLboolean r = GL_FALSE;
4585
 
4586
  r = ((glGetUniformdv = (PFNGLGETUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformdv")) == NULL) || r;
4587
  r = ((glUniform1d = (PFNGLUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glUniform1d")) == NULL) || r;
4588
  r = ((glUniform1dv = (PFNGLUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glUniform1dv")) == NULL) || r;
4589
  r = ((glUniform2d = (PFNGLUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glUniform2d")) == NULL) || r;
4590
  r = ((glUniform2dv = (PFNGLUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glUniform2dv")) == NULL) || r;
4591
  r = ((glUniform3d = (PFNGLUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glUniform3d")) == NULL) || r;
4592
  r = ((glUniform3dv = (PFNGLUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glUniform3dv")) == NULL) || r;
4593
  r = ((glUniform4d = (PFNGLUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glUniform4d")) == NULL) || r;
4594
  r = ((glUniform4dv = (PFNGLUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glUniform4dv")) == NULL) || r;
4595
  r = ((glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2dv")) == NULL) || r;
4596
  r = ((glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3dv")) == NULL) || r;
4597
  r = ((glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4dv")) == NULL) || r;
4598
  r = ((glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3dv")) == NULL) || r;
4599
  r = ((glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2dv")) == NULL) || r;
4600
  r = ((glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4dv")) == NULL) || r;
4601
  r = ((glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4dv")) == NULL) || r;
4602
  r = ((glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2dv")) == NULL) || r;
4603
  r = ((glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3dv")) == NULL) || r;
4604
 
4605
  return r;
4606
}
4607
 
4608
#endif /* GL_ARB_gpu_shader_fp64 */
4609
 
4610
#ifdef GL_ARB_half_float_pixel
4611
 
4612
#endif /* GL_ARB_half_float_pixel */
4613
 
4614
#ifdef GL_ARB_half_float_vertex
4615
 
4616
#endif /* GL_ARB_half_float_vertex */
4617
 
4618
#ifdef GL_ARB_imaging
4619
 
4620
static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT)
4621
{
4622
  GLboolean r = GL_FALSE;
4623
 
4624
  r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
4625
  r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r;
4626
  r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r;
4627
  r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r;
4628
  r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r;
4629
  r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r;
4630
  r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r;
4631
  r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r;
4632
  r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r;
4633
  r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r;
4634
  r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r;
4635
  r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r;
4636
  r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r;
4637
  r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r;
4638
  r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r;
4639
  r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r;
4640
  r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r;
4641
  r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r;
4642
  r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r;
4643
  r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r;
4644
  r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r;
4645
  r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r;
4646
  r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r;
4647
  r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r;
4648
  r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r;
4649
  r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r;
4650
  r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r;
4651
  r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r;
4652
  r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r;
4653
  r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r;
4654
  r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r;
4655
  r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r;
4656
  r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r;
4657
 
4658
  return r;
4659
}
4660
 
4661
#endif /* GL_ARB_imaging */
4662
 
677 janba 4663
#ifdef GL_ARB_indirect_parameters
4664
 
4665
static GLboolean _glewInit_GL_ARB_indirect_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
4666
{
4667
  GLboolean r = GL_FALSE;
4668
 
4669
  r = ((glMultiDrawArraysIndirectCountARB = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectCountARB")) == NULL) || r;
4670
  r = ((glMultiDrawElementsIndirectCountARB = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectCountARB")) == NULL) || r;
4671
 
4672
  return r;
4673
}
4674
 
4675
#endif /* GL_ARB_indirect_parameters */
4676
 
667 khor 4677
#ifdef GL_ARB_instanced_arrays
4678
 
4679
static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
4680
{
4681
  GLboolean r = GL_FALSE;
4682
 
4683
  r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r;
4684
  r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r;
4685
  r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r;
4686
 
4687
  return r;
4688
}
4689
 
4690
#endif /* GL_ARB_instanced_arrays */
4691
 
4692
#ifdef GL_ARB_internalformat_query
4693
 
4694
static GLboolean _glewInit_GL_ARB_internalformat_query (GLEW_CONTEXT_ARG_DEF_INIT)
4695
{
4696
  GLboolean r = GL_FALSE;
4697
 
4698
  r = ((glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformativ")) == NULL) || r;
4699
 
4700
  return r;
4701
}
4702
 
4703
#endif /* GL_ARB_internalformat_query */
4704
 
4705
#ifdef GL_ARB_internalformat_query2
4706
 
4707
static GLboolean _glewInit_GL_ARB_internalformat_query2 (GLEW_CONTEXT_ARG_DEF_INIT)
4708
{
4709
  GLboolean r = GL_FALSE;
4710
 
4711
  r = ((glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformati64v")) == NULL) || r;
4712
 
4713
  return r;
4714
}
4715
 
4716
#endif /* GL_ARB_internalformat_query2 */
4717
 
4718
#ifdef GL_ARB_invalidate_subdata
4719
 
4720
static GLboolean _glewInit_GL_ARB_invalidate_subdata (GLEW_CONTEXT_ARG_DEF_INIT)
4721
{
4722
  GLboolean r = GL_FALSE;
4723
 
4724
  r = ((glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferData")) == NULL) || r;
4725
  r = ((glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferSubData")) == NULL) || r;
4726
  r = ((glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateFramebuffer")) == NULL) || r;
4727
  r = ((glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateSubFramebuffer")) == NULL) || r;
4728
  r = ((glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexImage")) == NULL) || r;
4729
  r = ((glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexSubImage")) == NULL) || r;
4730
 
4731
  return r;
4732
}
4733
 
4734
#endif /* GL_ARB_invalidate_subdata */
4735
 
4736
#ifdef GL_ARB_map_buffer_alignment
4737
 
4738
#endif /* GL_ARB_map_buffer_alignment */
4739
 
4740
#ifdef GL_ARB_map_buffer_range
4741
 
4742
static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
4743
{
4744
  GLboolean r = GL_FALSE;
4745
 
4746
  r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r;
4747
  r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r;
4748
 
4749
  return r;
4750
}
4751
 
4752
#endif /* GL_ARB_map_buffer_range */
4753
 
4754
#ifdef GL_ARB_matrix_palette
4755
 
4756
static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT)
4757
{
4758
  GLboolean r = GL_FALSE;
4759
 
4760
  r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r;
4761
  r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r;
4762
  r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r;
4763
  r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r;
4764
  r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r;
4765
 
4766
  return r;
4767
}
4768
 
4769
#endif /* GL_ARB_matrix_palette */
4770
 
677 janba 4771
#ifdef GL_ARB_multi_bind
4772
 
4773
static GLboolean _glewInit_GL_ARB_multi_bind (GLEW_CONTEXT_ARG_DEF_INIT)
4774
{
4775
  GLboolean r = GL_FALSE;
4776
 
4777
  r = ((glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBuffersBase")) == NULL) || r;
4778
  r = ((glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBuffersRange")) == NULL) || r;
4779
  r = ((glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextures")) == NULL) || r;
4780
  r = ((glBindSamplers = (PFNGLBINDSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glBindSamplers")) == NULL) || r;
4781
  r = ((glBindTextures = (PFNGLBINDTEXTURESPROC)glewGetProcAddress((const GLubyte*)"glBindTextures")) == NULL) || r;
4782
  r = ((glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffers")) == NULL) || r;
4783
 
4784
  return r;
4785
}
4786
 
4787
#endif /* GL_ARB_multi_bind */
4788
 
667 khor 4789
#ifdef GL_ARB_multi_draw_indirect
4790
 
4791
static GLboolean _glewInit_GL_ARB_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
4792
{
4793
  GLboolean r = GL_FALSE;
4794
 
4795
  r = ((glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirect")) == NULL) || r;
4796
  r = ((glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirect")) == NULL) || r;
4797
 
4798
  return r;
4799
}
4800
 
4801
#endif /* GL_ARB_multi_draw_indirect */
4802
 
4803
#ifdef GL_ARB_multisample
4804
 
4805
static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
4806
{
4807
  GLboolean r = GL_FALSE;
4808
 
4809
  r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r;
4810
 
4811
  return r;
4812
}
4813
 
4814
#endif /* GL_ARB_multisample */
4815
 
4816
#ifdef GL_ARB_multitexture
4817
 
4818
static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)
4819
{
4820
  GLboolean r = GL_FALSE;
4821
 
4822
  r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r;
4823
  r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r;
4824
  r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r;
4825
  r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r;
4826
  r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r;
4827
  r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r;
4828
  r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r;
4829
  r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r;
4830
  r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r;
4831
  r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r;
4832
  r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r;
4833
  r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r;
4834
  r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r;
4835
  r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r;
4836
  r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r;
4837
  r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r;
4838
  r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r;
4839
  r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r;
4840
  r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r;
4841
  r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r;
4842
  r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r;
4843
  r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r;
4844
  r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r;
4845
  r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;
4846
  r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;
4847
  r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;
4848
  r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;
4849
  r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;
4850
  r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;
4851
  r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;
4852
  r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;
4853
  r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;
4854
  r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;
4855
  r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;
4856
 
4857
  return r;
4858
}
4859
 
4860
#endif /* GL_ARB_multitexture */
4861
 
4862
#ifdef GL_ARB_occlusion_query
4863
 
4864
static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
4865
{
4866
  GLboolean r = GL_FALSE;
4867
 
4868
  r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;
4869
  r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;
4870
  r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;
4871
  r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;
4872
  r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;
4873
  r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;
4874
  r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;
4875
  r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;
4876
 
4877
  return r;
4878
}
4879
 
4880
#endif /* GL_ARB_occlusion_query */
4881
 
4882
#ifdef GL_ARB_occlusion_query2
4883
 
4884
#endif /* GL_ARB_occlusion_query2 */
4885
 
4886
#ifdef GL_ARB_pixel_buffer_object
4887
 
4888
#endif /* GL_ARB_pixel_buffer_object */
4889
 
4890
#ifdef GL_ARB_point_parameters
4891
 
4892
static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
4893
{
4894
  GLboolean r = GL_FALSE;
4895
 
4896
  r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;
4897
  r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;
4898
 
4899
  return r;
4900
}
4901
 
4902
#endif /* GL_ARB_point_parameters */
4903
 
4904
#ifdef GL_ARB_point_sprite
4905
 
4906
#endif /* GL_ARB_point_sprite */
4907
 
4908
#ifdef GL_ARB_program_interface_query
4909
 
4910
static GLboolean _glewInit_GL_ARB_program_interface_query (GLEW_CONTEXT_ARG_DEF_INIT)
4911
{
4912
  GLboolean r = GL_FALSE;
4913
 
4914
  r = ((glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInterfaceiv")) == NULL) || r;
4915
  r = ((glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceIndex")) == NULL) || r;
4916
  r = ((glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocation")) == NULL) || r;
4917
  r = ((glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocationIndex")) == NULL) || r;
4918
  r = ((glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceName")) == NULL) || r;
4919
  r = ((glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceiv")) == NULL) || r;
4920
 
4921
  return r;
4922
}
4923
 
4924
#endif /* GL_ARB_program_interface_query */
4925
 
4926
#ifdef GL_ARB_provoking_vertex
4927
 
4928
static GLboolean _glewInit_GL_ARB_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
4929
{
4930
  GLboolean r = GL_FALSE;
4931
 
4932
  r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r;
4933
 
4934
  return r;
4935
}
4936
 
4937
#endif /* GL_ARB_provoking_vertex */
4938
 
677 janba 4939
#ifdef GL_ARB_query_buffer_object
4940
 
4941
#endif /* GL_ARB_query_buffer_object */
4942
 
667 khor 4943
#ifdef GL_ARB_robust_buffer_access_behavior
4944
 
4945
#endif /* GL_ARB_robust_buffer_access_behavior */
4946
 
4947
#ifdef GL_ARB_robustness
4948
 
4949
static GLboolean _glewInit_GL_ARB_robustness (GLEW_CONTEXT_ARG_DEF_INIT)
4950
{
4951
  GLboolean r = GL_FALSE;
4952
 
4953
  r = ((glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusARB")) == NULL) || r;
4954
  r = ((glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnColorTableARB")) == NULL) || r;
4955
  r = ((glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImageARB")) == NULL) || r;
4956
  r = ((glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnConvolutionFilterARB")) == NULL) || r;
4957
  r = ((glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glGetnHistogramARB")) == NULL) || r;
4958
  r = ((glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapdvARB")) == NULL) || r;
4959
  r = ((glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapfvARB")) == NULL) || r;
4960
  r = ((glGetnMapivARB = (PFNGLGETNMAPIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapivARB")) == NULL) || r;
4961
  r = ((glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMinmaxARB")) == NULL) || r;
4962
  r = ((glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapfvARB")) == NULL) || r;
4963
  r = ((glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapuivARB")) == NULL) || r;
4964
  r = ((glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapusvARB")) == NULL) || r;
4965
  r = ((glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPolygonStippleARB")) == NULL) || r;
4966
  r = ((glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnSeparableFilterARB")) == NULL) || r;
4967
  r = ((glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImageARB")) == NULL) || r;
4968
  r = ((glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdvARB")) == NULL) || r;
4969
  r = ((glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvARB")) == NULL) || r;
4970
  r = ((glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivARB")) == NULL) || r;
4971
  r = ((glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuivARB")) == NULL) || r;
4972
  r = ((glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsARB")) == NULL) || r;
4973
 
4974
  return r;
4975
}
4976
 
4977
#endif /* GL_ARB_robustness */
4978
 
4979
#ifdef GL_ARB_robustness_application_isolation
4980
 
4981
#endif /* GL_ARB_robustness_application_isolation */
4982
 
4983
#ifdef GL_ARB_robustness_share_group_isolation
4984
 
4985
#endif /* GL_ARB_robustness_share_group_isolation */
4986
 
4987
#ifdef GL_ARB_sample_shading
4988
 
4989
static GLboolean _glewInit_GL_ARB_sample_shading (GLEW_CONTEXT_ARG_DEF_INIT)
4990
{
4991
  GLboolean r = GL_FALSE;
4992
 
4993
  r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r;
4994
 
4995
  return r;
4996
}
4997
 
4998
#endif /* GL_ARB_sample_shading */
4999
 
5000
#ifdef GL_ARB_sampler_objects
5001
 
5002
static GLboolean _glewInit_GL_ARB_sampler_objects (GLEW_CONTEXT_ARG_DEF_INIT)
5003
{
5004
  GLboolean r = GL_FALSE;
5005
 
5006
  r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r;
5007
  r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r;
5008
  r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r;
5009
  r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r;
5010
  r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r;
5011
  r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r;
5012
  r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r;
5013
  r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r;
5014
  r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r;
5015
  r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r;
5016
  r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r;
5017
  r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r;
5018
  r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r;
5019
  r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r;
5020
 
5021
  return r;
5022
}
5023
 
5024
#endif /* GL_ARB_sampler_objects */
5025
 
5026
#ifdef GL_ARB_seamless_cube_map
5027
 
5028
#endif /* GL_ARB_seamless_cube_map */
5029
 
677 janba 5030
#ifdef GL_ARB_seamless_cubemap_per_texture
5031
 
5032
#endif /* GL_ARB_seamless_cubemap_per_texture */
5033
 
667 khor 5034
#ifdef GL_ARB_separate_shader_objects
5035
 
5036
static GLboolean _glewInit_GL_ARB_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
5037
{
5038
  GLboolean r = GL_FALSE;
5039
 
5040
  r = ((glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glActiveShaderProgram")) == NULL) || r;
5041
  r = ((glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glBindProgramPipeline")) == NULL) || r;
5042
  r = ((glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramv")) == NULL) || r;
5043
  r = ((glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramPipelines")) == NULL) || r;
5044
  r = ((glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glGenProgramPipelines")) == NULL) || r;
5045
  r = ((glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineInfoLog")) == NULL) || r;
5046
  r = ((glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineiv")) == NULL) || r;
5047
  r = ((glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glIsProgramPipeline")) == NULL) || r;
5048
  r = ((glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1d")) == NULL) || r;
5049
  r = ((glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dv")) == NULL) || r;
5050
  r = ((glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1f")) == NULL) || r;
5051
  r = ((glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fv")) == NULL) || r;
5052
  r = ((glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i")) == NULL) || r;
5053
  r = ((glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iv")) == NULL) || r;
5054
  r = ((glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui")) == NULL) || r;
5055
  r = ((glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiv")) == NULL) || r;
5056
  r = ((glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2d")) == NULL) || r;
5057
  r = ((glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dv")) == NULL) || r;
5058
  r = ((glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2f")) == NULL) || r;
5059
  r = ((glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fv")) == NULL) || r;
5060
  r = ((glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i")) == NULL) || r;
5061
  r = ((glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iv")) == NULL) || r;
5062
  r = ((glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui")) == NULL) || r;
5063
  r = ((glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiv")) == NULL) || r;
5064
  r = ((glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3d")) == NULL) || r;
5065
  r = ((glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dv")) == NULL) || r;
5066
  r = ((glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3f")) == NULL) || r;
5067
  r = ((glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fv")) == NULL) || r;
5068
  r = ((glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i")) == NULL) || r;
5069
  r = ((glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iv")) == NULL) || r;
5070
  r = ((glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui")) == NULL) || r;
5071
  r = ((glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiv")) == NULL) || r;
5072
  r = ((glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4d")) == NULL) || r;
5073
  r = ((glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dv")) == NULL) || r;
5074
  r = ((glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4f")) == NULL) || r;
5075
  r = ((glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fv")) == NULL) || r;
5076
  r = ((glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i")) == NULL) || r;
5077
  r = ((glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iv")) == NULL) || r;
5078
  r = ((glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui")) == NULL) || r;
5079
  r = ((glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiv")) == NULL) || r;
5080
  r = ((glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dv")) == NULL) || r;
5081
  r = ((glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fv")) == NULL) || r;
5082
  r = ((glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dv")) == NULL) || r;
5083
  r = ((glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fv")) == NULL) || r;
5084
  r = ((glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dv")) == NULL) || r;
5085
  r = ((glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fv")) == NULL) || r;
5086
  r = ((glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dv")) == NULL) || r;
5087
  r = ((glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fv")) == NULL) || r;
5088
  r = ((glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dv")) == NULL) || r;
5089
  r = ((glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fv")) == NULL) || r;
5090
  r = ((glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dv")) == NULL) || r;
5091
  r = ((glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fv")) == NULL) || r;
5092
  r = ((glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dv")) == NULL) || r;
5093
  r = ((glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fv")) == NULL) || r;
5094
  r = ((glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dv")) == NULL) || r;
5095
  r = ((glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fv")) == NULL) || r;
5096
  r = ((glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dv")) == NULL) || r;
5097
  r = ((glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fv")) == NULL) || r;
5098
  r = ((glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glewGetProcAddress((const GLubyte*)"glUseProgramStages")) == NULL) || r;
5099
  r = ((glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramPipeline")) == NULL) || r;
5100
 
5101
  return r;
5102
}
5103
 
5104
#endif /* GL_ARB_separate_shader_objects */
5105
 
5106
#ifdef GL_ARB_shader_atomic_counters
5107
 
5108
static GLboolean _glewInit_GL_ARB_shader_atomic_counters (GLEW_CONTEXT_ARG_DEF_INIT)
5109
{
5110
  GLboolean r = GL_FALSE;
5111
 
5112
  r = ((glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAtomicCounterBufferiv")) == NULL) || r;
5113
 
5114
  return r;
5115
}
5116
 
5117
#endif /* GL_ARB_shader_atomic_counters */
5118
 
5119
#ifdef GL_ARB_shader_bit_encoding
5120
 
5121
#endif /* GL_ARB_shader_bit_encoding */
5122
 
677 janba 5123
#ifdef GL_ARB_shader_draw_parameters
5124
 
5125
#endif /* GL_ARB_shader_draw_parameters */
5126
 
5127
#ifdef GL_ARB_shader_group_vote
5128
 
5129
#endif /* GL_ARB_shader_group_vote */
5130
 
667 khor 5131
#ifdef GL_ARB_shader_image_load_store
5132
 
5133
static GLboolean _glewInit_GL_ARB_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
5134
{
5135
  GLboolean r = GL_FALSE;
5136
 
5137
  r = ((glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glBindImageTexture")) == NULL) || r;
5138
  r = ((glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrier")) == NULL) || r;
5139
 
5140
  return r;
5141
}
5142
 
5143
#endif /* GL_ARB_shader_image_load_store */
5144
 
5145
#ifdef GL_ARB_shader_image_size
5146
 
5147
#endif /* GL_ARB_shader_image_size */
5148
 
5149
#ifdef GL_ARB_shader_objects
5150
 
5151
static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
5152
{
5153
  GLboolean r = GL_FALSE;
5154
 
5155
  r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;
5156
  r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;
5157
  r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;
5158
  r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;
5159
  r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;
5160
  r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;
5161
  r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;
5162
  r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;
5163
  r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;
5164
  r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;
5165
  r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;
5166
  r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;
5167
  r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;
5168
  r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;
5169
  r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;
5170
  r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;
5171
  r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;
5172
  r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;
5173
  r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;
5174
  r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;
5175
  r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;
5176
  r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;
5177
  r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;
5178
  r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;
5179
  r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;
5180
  r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;
5181
  r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;
5182
  r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;
5183
  r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;
5184
  r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;
5185
  r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;
5186
  r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;
5187
  r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;
5188
  r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;
5189
  r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;
5190
  r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;
5191
  r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;
5192
  r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;
5193
  r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;
5194
 
5195
  return r;
5196
}
5197
 
5198
#endif /* GL_ARB_shader_objects */
5199
 
5200
#ifdef GL_ARB_shader_precision
5201
 
5202
#endif /* GL_ARB_shader_precision */
5203
 
5204
#ifdef GL_ARB_shader_stencil_export
5205
 
5206
#endif /* GL_ARB_shader_stencil_export */
5207
 
5208
#ifdef GL_ARB_shader_storage_buffer_object
5209
 
5210
static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
5211
{
5212
  GLboolean r = GL_FALSE;
5213
 
5214
  r = ((glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glShaderStorageBlockBinding")) == NULL) || r;
5215
 
5216
  return r;
5217
}
5218
 
5219
#endif /* GL_ARB_shader_storage_buffer_object */
5220
 
5221
#ifdef GL_ARB_shader_subroutine
5222
 
5223
static GLboolean _glewInit_GL_ARB_shader_subroutine (GLEW_CONTEXT_ARG_DEF_INIT)
5224
{
5225
  GLboolean r = GL_FALSE;
5226
 
5227
  r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r;
5228
  r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r;
5229
  r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r;
5230
  r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r;
5231
  r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r;
5232
  r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r;
5233
  r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r;
5234
  r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r;
5235
 
5236
  return r;
5237
}
5238
 
5239
#endif /* GL_ARB_shader_subroutine */
5240
 
5241
#ifdef GL_ARB_shader_texture_lod
5242
 
5243
#endif /* GL_ARB_shader_texture_lod */
5244
 
5245
#ifdef GL_ARB_shading_language_100
5246
 
5247
#endif /* GL_ARB_shading_language_100 */
5248
 
5249
#ifdef GL_ARB_shading_language_420pack
5250
 
5251
#endif /* GL_ARB_shading_language_420pack */
5252
 
5253
#ifdef GL_ARB_shading_language_include
5254
 
5255
static GLboolean _glewInit_GL_ARB_shading_language_include (GLEW_CONTEXT_ARG_DEF_INIT)
5256
{
5257
  GLboolean r = GL_FALSE;
5258
 
5259
  r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r;
5260
  r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r;
5261
  r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r;
5262
  r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r;
5263
  r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r;
5264
  r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r;
5265
 
5266
  return r;
5267
}
5268
 
5269
#endif /* GL_ARB_shading_language_include */
5270
 
5271
#ifdef GL_ARB_shading_language_packing
5272
 
5273
#endif /* GL_ARB_shading_language_packing */
5274
 
5275
#ifdef GL_ARB_shadow
5276
 
5277
#endif /* GL_ARB_shadow */
5278
 
5279
#ifdef GL_ARB_shadow_ambient
5280
 
5281
#endif /* GL_ARB_shadow_ambient */
5282
 
677 janba 5283
#ifdef GL_ARB_sparse_texture
5284
 
5285
static GLboolean _glewInit_GL_ARB_sparse_texture (GLEW_CONTEXT_ARG_DEF_INIT)
5286
{
5287
  GLboolean r = GL_FALSE;
5288
 
5289
  r = ((glTexPageCommitmentARB = (PFNGLTEXPAGECOMMITMENTARBPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentARB")) == NULL) || r;
5290
  r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r;
5291
 
5292
  return r;
5293
}
5294
 
5295
#endif /* GL_ARB_sparse_texture */
5296
 
667 khor 5297
#ifdef GL_ARB_stencil_texturing
5298
 
5299
#endif /* GL_ARB_stencil_texturing */
5300
 
5301
#ifdef GL_ARB_sync
5302
 
5303
static GLboolean _glewInit_GL_ARB_sync (GLEW_CONTEXT_ARG_DEF_INIT)
5304
{
5305
  GLboolean r = GL_FALSE;
5306
 
5307
  r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r;
5308
  r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r;
5309
  r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r;
5310
  r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r;
5311
  r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r;
5312
  r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r;
5313
  r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r;
5314
 
5315
  return r;
5316
}
5317
 
5318
#endif /* GL_ARB_sync */
5319
 
5320
#ifdef GL_ARB_tessellation_shader
5321
 
5322
static GLboolean _glewInit_GL_ARB_tessellation_shader (GLEW_CONTEXT_ARG_DEF_INIT)
5323
{
5324
  GLboolean r = GL_FALSE;
5325
 
5326
  r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r;
5327
  r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r;
5328
 
5329
  return r;
5330
}
5331
 
5332
#endif /* GL_ARB_tessellation_shader */
5333
 
5334
#ifdef GL_ARB_texture_border_clamp
5335
 
5336
#endif /* GL_ARB_texture_border_clamp */
5337
 
5338
#ifdef GL_ARB_texture_buffer_object
5339
 
5340
static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
5341
{
5342
  GLboolean r = GL_FALSE;
5343
 
5344
  r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;
5345
 
5346
  return r;
5347
}
5348
 
5349
#endif /* GL_ARB_texture_buffer_object */
5350
 
5351
#ifdef GL_ARB_texture_buffer_object_rgb32
5352
 
5353
#endif /* GL_ARB_texture_buffer_object_rgb32 */
5354
 
5355
#ifdef GL_ARB_texture_buffer_range
5356
 
5357
static GLboolean _glewInit_GL_ARB_texture_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
5358
{
5359
  GLboolean r = GL_FALSE;
5360
 
5361
  r = ((glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTexBufferRange")) == NULL) || r;
5362
  r = ((glTextureBufferRangeEXT = (PFNGLTEXTUREBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferRangeEXT")) == NULL) || r;
5363
 
5364
  return r;
5365
}
5366
 
5367
#endif /* GL_ARB_texture_buffer_range */
5368
 
5369
#ifdef GL_ARB_texture_compression
5370
 
5371
static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)
5372
{
5373
  GLboolean r = GL_FALSE;
5374
 
5375
  r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;
5376
  r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;
5377
  r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;
5378
  r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;
5379
  r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;
5380
  r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;
5381
  r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;
5382
 
5383
  return r;
5384
}
5385
 
5386
#endif /* GL_ARB_texture_compression */
5387
 
5388
#ifdef GL_ARB_texture_compression_bptc
5389
 
5390
#endif /* GL_ARB_texture_compression_bptc */
5391
 
5392
#ifdef GL_ARB_texture_compression_rgtc
5393
 
5394
#endif /* GL_ARB_texture_compression_rgtc */
5395
 
5396
#ifdef GL_ARB_texture_cube_map
5397
 
5398
#endif /* GL_ARB_texture_cube_map */
5399
 
5400
#ifdef GL_ARB_texture_cube_map_array
5401
 
5402
#endif /* GL_ARB_texture_cube_map_array */
5403
 
5404
#ifdef GL_ARB_texture_env_add
5405
 
5406
#endif /* GL_ARB_texture_env_add */
5407
 
5408
#ifdef GL_ARB_texture_env_combine
5409
 
5410
#endif /* GL_ARB_texture_env_combine */
5411
 
5412
#ifdef GL_ARB_texture_env_crossbar
5413
 
5414
#endif /* GL_ARB_texture_env_crossbar */
5415
 
5416
#ifdef GL_ARB_texture_env_dot3
5417
 
5418
#endif /* GL_ARB_texture_env_dot3 */
5419
 
5420
#ifdef GL_ARB_texture_float
5421
 
5422
#endif /* GL_ARB_texture_float */
5423
 
5424
#ifdef GL_ARB_texture_gather
5425
 
5426
#endif /* GL_ARB_texture_gather */
5427
 
677 janba 5428
#ifdef GL_ARB_texture_mirror_clamp_to_edge
5429
 
5430
#endif /* GL_ARB_texture_mirror_clamp_to_edge */
5431
 
667 khor 5432
#ifdef GL_ARB_texture_mirrored_repeat
5433
 
5434
#endif /* GL_ARB_texture_mirrored_repeat */
5435
 
5436
#ifdef GL_ARB_texture_multisample
5437
 
5438
static GLboolean _glewInit_GL_ARB_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
5439
{
5440
  GLboolean r = GL_FALSE;
5441
 
5442
  r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r;
5443
  r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r;
5444
  r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r;
5445
  r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r;
5446
 
5447
  return r;
5448
}
5449
 
5450
#endif /* GL_ARB_texture_multisample */
5451
 
5452
#ifdef GL_ARB_texture_non_power_of_two
5453
 
5454
#endif /* GL_ARB_texture_non_power_of_two */
5455
 
5456
#ifdef GL_ARB_texture_query_levels
5457
 
5458
#endif /* GL_ARB_texture_query_levels */
5459
 
5460
#ifdef GL_ARB_texture_query_lod
5461
 
5462
#endif /* GL_ARB_texture_query_lod */
5463
 
5464
#ifdef GL_ARB_texture_rectangle
5465
 
5466
#endif /* GL_ARB_texture_rectangle */
5467
 
5468
#ifdef GL_ARB_texture_rg
5469
 
5470
#endif /* GL_ARB_texture_rg */
5471
 
5472
#ifdef GL_ARB_texture_rgb10_a2ui
5473
 
5474
#endif /* GL_ARB_texture_rgb10_a2ui */
5475
 
677 janba 5476
#ifdef GL_ARB_texture_stencil8
5477
 
5478
#endif /* GL_ARB_texture_stencil8 */
5479
 
667 khor 5480
#ifdef GL_ARB_texture_storage
5481
 
5482
static GLboolean _glewInit_GL_ARB_texture_storage (GLEW_CONTEXT_ARG_DEF_INIT)
5483
{
5484
  GLboolean r = GL_FALSE;
5485
 
5486
  r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r;
5487
  r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r;
5488
  r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r;
5489
  r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r;
5490
  r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r;
5491
  r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r;
5492
 
5493
  return r;
5494
}
5495
 
5496
#endif /* GL_ARB_texture_storage */
5497
 
5498
#ifdef GL_ARB_texture_storage_multisample
5499
 
5500
static GLboolean _glewInit_GL_ARB_texture_storage_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
5501
{
5502
  GLboolean r = GL_FALSE;
5503
 
5504
  r = ((glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2DMultisample")) == NULL) || r;
5505
  r = ((glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DMultisample")) == NULL) || r;
5506
  r = ((glTextureStorage2DMultisampleEXT = (PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DMultisampleEXT")) == NULL) || r;
5507
  r = ((glTextureStorage3DMultisampleEXT = (PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DMultisampleEXT")) == NULL) || r;
5508
 
5509
  return r;
5510
}
5511
 
5512
#endif /* GL_ARB_texture_storage_multisample */
5513
 
5514
#ifdef GL_ARB_texture_swizzle
5515
 
5516
#endif /* GL_ARB_texture_swizzle */
5517
 
5518
#ifdef GL_ARB_texture_view
5519
 
5520
static GLboolean _glewInit_GL_ARB_texture_view (GLEW_CONTEXT_ARG_DEF_INIT)
5521
{
5522
  GLboolean r = GL_FALSE;
5523
 
5524
  r = ((glTextureView = (PFNGLTEXTUREVIEWPROC)glewGetProcAddress((const GLubyte*)"glTextureView")) == NULL) || r;
5525
 
5526
  return r;
5527
}
5528
 
5529
#endif /* GL_ARB_texture_view */
5530
 
5531
#ifdef GL_ARB_timer_query
5532
 
5533
static GLboolean _glewInit_GL_ARB_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
5534
{
5535
  GLboolean r = GL_FALSE;
5536
 
5537
  r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r;
5538
  r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r;
5539
  r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r;
5540
 
5541
  return r;
5542
}
5543
 
5544
#endif /* GL_ARB_timer_query */
5545
 
5546
#ifdef GL_ARB_transform_feedback2
5547
 
5548
static GLboolean _glewInit_GL_ARB_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
5549
{
5550
  GLboolean r = GL_FALSE;
5551
 
5552
  r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r;
5553
  r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r;
5554
  r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r;
5555
  r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r;
5556
  r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r;
5557
  r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r;
5558
  r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r;
5559
 
5560
  return r;
5561
}
5562
 
5563
#endif /* GL_ARB_transform_feedback2 */
5564
 
5565
#ifdef GL_ARB_transform_feedback3
5566
 
5567
static GLboolean _glewInit_GL_ARB_transform_feedback3 (GLEW_CONTEXT_ARG_DEF_INIT)
5568
{
5569
  GLboolean r = GL_FALSE;
5570
 
5571
  r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r;
5572
  r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r;
5573
  r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r;
5574
  r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r;
5575
 
5576
  return r;
5577
}
5578
 
5579
#endif /* GL_ARB_transform_feedback3 */
5580
 
5581
#ifdef GL_ARB_transform_feedback_instanced
5582
 
5583
static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
5584
{
5585
  GLboolean r = GL_FALSE;
5586
 
5587
  r = ((glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstanced")) == NULL) || r;
5588
  r = ((glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStreamInstanced")) == NULL) || r;
5589
 
5590
  return r;
5591
}
5592
 
5593
#endif /* GL_ARB_transform_feedback_instanced */
5594
 
5595
#ifdef GL_ARB_transpose_matrix
5596
 
5597
static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)
5598
{
5599
  GLboolean r = GL_FALSE;
5600
 
5601
  r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r;
5602
  r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r;
5603
  r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r;
5604
  r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r;
5605
 
5606
  return r;
5607
}
5608
 
5609
#endif /* GL_ARB_transpose_matrix */
5610
 
5611
#ifdef GL_ARB_uniform_buffer_object
5612
 
5613
static GLboolean _glewInit_GL_ARB_uniform_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
5614
{
5615
  GLboolean r = GL_FALSE;
5616
 
5617
  r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;
5618
  r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;
5619
  r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r;
5620
  r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r;
5621
  r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r;
5622
  r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r;
5623
  r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;
5624
  r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r;
5625
  r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r;
5626
  r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r;
5627
 
5628
  return r;
5629
}
5630
 
5631
#endif /* GL_ARB_uniform_buffer_object */
5632
 
5633
#ifdef GL_ARB_vertex_array_bgra
5634
 
5635
#endif /* GL_ARB_vertex_array_bgra */
5636
 
5637
#ifdef GL_ARB_vertex_array_object
5638
 
5639
static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
5640
{
5641
  GLboolean r = GL_FALSE;
5642
 
5643
  r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r;
5644
  r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r;
5645
  r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r;
5646
  r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r;
5647
 
5648
  return r;
5649
}
5650
 
5651
#endif /* GL_ARB_vertex_array_object */
5652
 
5653
#ifdef GL_ARB_vertex_attrib_64bit
5654
 
5655
static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
5656
{
5657
  GLboolean r = GL_FALSE;
5658
 
5659
  r = ((glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdv")) == NULL) || r;
5660
  r = ((glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1d")) == NULL) || r;
5661
  r = ((glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dv")) == NULL) || r;
5662
  r = ((glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2d")) == NULL) || r;
5663
  r = ((glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dv")) == NULL) || r;
5664
  r = ((glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3d")) == NULL) || r;
5665
  r = ((glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dv")) == NULL) || r;
5666
  r = ((glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4d")) == NULL) || r;
5667
  r = ((glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dv")) == NULL) || r;
5668
  r = ((glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointer")) == NULL) || r;
5669
 
5670
  return r;
5671
}
5672
 
5673
#endif /* GL_ARB_vertex_attrib_64bit */
5674
 
5675
#ifdef GL_ARB_vertex_attrib_binding
5676
 
5677
static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (GLEW_CONTEXT_ARG_DEF_INIT)
5678
{
5679
  GLboolean r = GL_FALSE;
5680
 
5681
  r = ((glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffer")) == NULL) || r;
5682
  r = ((glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribBinding")) == NULL) || r;
5683
  r = ((glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormat")) == NULL) || r;
5684
  r = ((glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormat")) == NULL) || r;
5685
  r = ((glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormat")) == NULL) || r;
5686
  r = ((glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexBindingDivisor")) == NULL) || r;
5687
 
5688
  return r;
5689
}
5690
 
5691
#endif /* GL_ARB_vertex_attrib_binding */
5692
 
5693
#ifdef GL_ARB_vertex_blend
5694
 
5695
static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT)
5696
{
5697
  GLboolean r = GL_FALSE;
5698
 
5699
  r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r;
5700
  r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r;
5701
  r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r;
5702
  r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r;
5703
  r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r;
5704
  r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r;
5705
  r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r;
5706
  r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r;
5707
  r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r;
5708
  r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r;
5709
 
5710
  return r;
5711
}
5712
 
5713
#endif /* GL_ARB_vertex_blend */
5714
 
5715
#ifdef GL_ARB_vertex_buffer_object
5716
 
5717
static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
5718
{
5719
  GLboolean r = GL_FALSE;
5720
 
5721
  r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;
5722
  r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;
5723
  r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;
5724
  r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;
5725
  r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;
5726
  r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;
5727
  r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;
5728
  r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;
5729
  r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;
5730
  r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;
5731
  r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;
5732
 
5733
  return r;
5734
}
5735
 
5736
#endif /* GL_ARB_vertex_buffer_object */
5737
 
5738
#ifdef GL_ARB_vertex_program
5739
 
5740
static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
5741
{
5742
  GLboolean r = GL_FALSE;
5743
 
5744
  r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;
5745
  r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;
5746
  r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;
5747
  r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;
5748
  r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;
5749
  r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;
5750
  r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;
5751
  r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;
5752
  r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;
5753
  r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;
5754
  r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;
5755
  r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;
5756
  r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;
5757
  r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;
5758
  r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;
5759
  r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;
5760
  r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;
5761
  r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;
5762
  r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;
5763
  r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;
5764
  r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;
5765
  r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;
5766
  r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;
5767
  r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;
5768
  r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;
5769
  r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;
5770
  r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;
5771
  r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;
5772
  r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;
5773
  r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;
5774
  r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;
5775
  r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;
5776
  r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;
5777
  r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;
5778
  r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;
5779
  r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;
5780
  r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;
5781
  r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;
5782
  r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;
5783
  r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;
5784
  r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;
5785
  r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;
5786
  r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;
5787
  r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;
5788
  r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;
5789
  r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;
5790
  r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;
5791
  r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;
5792
  r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;
5793
  r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;
5794
  r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;
5795
  r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;
5796
  r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;
5797
  r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;
5798
  r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;
5799
  r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;
5800
  r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;
5801
  r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;
5802
  r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;
5803
  r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;
5804
  r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;
5805
  r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;
5806
 
5807
  return r;
5808
}
5809
 
5810
#endif /* GL_ARB_vertex_program */
5811
 
5812
#ifdef GL_ARB_vertex_shader
5813
 
5814
static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
5815
{
5816
  GLboolean r = GL_FALSE;
5817
 
5818
  r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;
5819
  r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;
5820
  r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;
5821
 
5822
  return r;
5823
}
5824
 
5825
#endif /* GL_ARB_vertex_shader */
5826
 
677 janba 5827
#ifdef GL_ARB_vertex_type_10f_11f_11f_rev
5828
 
5829
#endif /* GL_ARB_vertex_type_10f_11f_11f_rev */
5830
 
667 khor 5831
#ifdef GL_ARB_vertex_type_2_10_10_10_rev
5832
 
5833
static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (GLEW_CONTEXT_ARG_DEF_INIT)
5834
{
5835
  GLboolean r = GL_FALSE;
5836
 
5837
  r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r;
5838
  r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r;
5839
  r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r;
5840
  r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r;
5841
  r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r;
5842
  r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r;
5843
  r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r;
5844
  r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r;
5845
  r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r;
5846
  r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r;
5847
  r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r;
5848
  r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r;
5849
  r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r;
5850
  r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r;
5851
  r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r;
5852
  r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r;
5853
  r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r;
5854
  r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r;
5855
  r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r;
5856
  r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r;
5857
  r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r;
5858
  r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r;
5859
  r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r;
5860
  r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r;
5861
  r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r;
5862
  r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r;
5863
  r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r;
5864
  r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r;
5865
  r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r;
5866
  r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r;
5867
  r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r;
5868
  r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r;
5869
  r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r;
5870
  r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r;
5871
  r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r;
5872
  r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r;
5873
  r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r;
5874
  r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r;
5875
 
5876
  return r;
5877
}
5878
 
5879
#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
5880
 
5881
#ifdef GL_ARB_viewport_array
5882
 
5883
static GLboolean _glewInit_GL_ARB_viewport_array (GLEW_CONTEXT_ARG_DEF_INIT)
5884
{
5885
  GLboolean r = GL_FALSE;
5886
 
5887
  r = ((glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayv")) == NULL) || r;
5888
  r = ((glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexed")) == NULL) || r;
5889
  r = ((glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_v")) == NULL) || r;
5890
  r = ((glGetFloati_v = (PFNGLGETFLOATI_VPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_v")) == NULL) || r;
5891
  r = ((glScissorArrayv = (PFNGLSCISSORARRAYVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayv")) == NULL) || r;
5892
  r = ((glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexed")) == NULL) || r;
5893
  r = ((glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedv")) == NULL) || r;
5894
  r = ((glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayv")) == NULL) || r;
5895
  r = ((glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedf")) == NULL) || r;
5896
  r = ((glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfv")) == NULL) || r;
5897
 
5898
  return r;
5899
}
5900
 
5901
#endif /* GL_ARB_viewport_array */
5902
 
5903
#ifdef GL_ARB_window_pos
5904
 
5905
static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
5906
{
5907
  GLboolean r = GL_FALSE;
5908
 
5909
  r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r;
5910
  r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r;
5911
  r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r;
5912
  r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r;
5913
  r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r;
5914
  r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r;
5915
  r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r;
5916
  r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r;
5917
  r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r;
5918
  r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r;
5919
  r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r;
5920
  r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r;
5921
  r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r;
5922
  r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r;
5923
  r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r;
5924
  r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r;
5925
 
5926
  return r;
5927
}
5928
 
5929
#endif /* GL_ARB_window_pos */
5930
 
5931
#ifdef GL_ATIX_point_sprites
5932
 
5933
#endif /* GL_ATIX_point_sprites */
5934
 
5935
#ifdef GL_ATIX_texture_env_combine3
5936
 
5937
#endif /* GL_ATIX_texture_env_combine3 */
5938
 
5939
#ifdef GL_ATIX_texture_env_route
5940
 
5941
#endif /* GL_ATIX_texture_env_route */
5942
 
5943
#ifdef GL_ATIX_vertex_shader_output_point_size
5944
 
5945
#endif /* GL_ATIX_vertex_shader_output_point_size */
5946
 
5947
#ifdef GL_ATI_draw_buffers
5948
 
5949
static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
5950
{
5951
  GLboolean r = GL_FALSE;
5952
 
5953
  r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;
5954
 
5955
  return r;
5956
}
5957
 
5958
#endif /* GL_ATI_draw_buffers */
5959
 
5960
#ifdef GL_ATI_element_array
5961
 
5962
static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT)
5963
{
5964
  GLboolean r = GL_FALSE;
5965
 
5966
  r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r;
5967
  r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r;
5968
  r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r;
5969
 
5970
  return r;
5971
}
5972
 
5973
#endif /* GL_ATI_element_array */
5974
 
5975
#ifdef GL_ATI_envmap_bumpmap
5976
 
5977
static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT)
5978
{
5979
  GLboolean r = GL_FALSE;
5980
 
5981
  r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r;
5982
  r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r;
5983
  r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r;
5984
  r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r;
5985
 
5986
  return r;
5987
}
5988
 
5989
#endif /* GL_ATI_envmap_bumpmap */
5990
 
5991
#ifdef GL_ATI_fragment_shader
5992
 
5993
static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)
5994
{
5995
  GLboolean r = GL_FALSE;
5996
 
5997
  r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;
5998
  r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;
5999
  r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;
6000
  r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;
6001
  r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;
6002
  r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;
6003
  r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;
6004
  r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;
6005
  r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;
6006
  r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;
6007
  r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;
6008
  r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;
6009
  r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;
6010
  r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;
6011
 
6012
  return r;
6013
}
6014
 
6015
#endif /* GL_ATI_fragment_shader */
6016
 
6017
#ifdef GL_ATI_map_object_buffer
6018
 
6019
static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
6020
{
6021
  GLboolean r = GL_FALSE;
6022
 
6023
  r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r;
6024
  r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r;
6025
 
6026
  return r;
6027
}
6028
 
6029
#endif /* GL_ATI_map_object_buffer */
6030
 
6031
#ifdef GL_ATI_meminfo
6032
 
6033
#endif /* GL_ATI_meminfo */
6034
 
6035
#ifdef GL_ATI_pn_triangles
6036
 
6037
static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)
6038
{
6039
  GLboolean r = GL_FALSE;
6040
 
6041
  r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r;
6042
  r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r;
6043
 
6044
  return r;
6045
}
6046
 
6047
#endif /* GL_ATI_pn_triangles */
6048
 
6049
#ifdef GL_ATI_separate_stencil
6050
 
6051
static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT)
6052
{
6053
  GLboolean r = GL_FALSE;
6054
 
6055
  r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r;
6056
  r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r;
6057
 
6058
  return r;
6059
}
6060
 
6061
#endif /* GL_ATI_separate_stencil */
6062
 
6063
#ifdef GL_ATI_shader_texture_lod
6064
 
6065
#endif /* GL_ATI_shader_texture_lod */
6066
 
6067
#ifdef GL_ATI_text_fragment_shader
6068
 
6069
#endif /* GL_ATI_text_fragment_shader */
6070
 
6071
#ifdef GL_ATI_texture_compression_3dc
6072
 
6073
#endif /* GL_ATI_texture_compression_3dc */
6074
 
6075
#ifdef GL_ATI_texture_env_combine3
6076
 
6077
#endif /* GL_ATI_texture_env_combine3 */
6078
 
6079
#ifdef GL_ATI_texture_float
6080
 
6081
#endif /* GL_ATI_texture_float */
6082
 
6083
#ifdef GL_ATI_texture_mirror_once
6084
 
6085
#endif /* GL_ATI_texture_mirror_once */
6086
 
6087
#ifdef GL_ATI_vertex_array_object
6088
 
6089
static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
6090
{
6091
  GLboolean r = GL_FALSE;
6092
 
6093
  r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r;
6094
  r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r;
6095
  r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r;
6096
  r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r;
6097
  r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r;
6098
  r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r;
6099
  r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r;
6100
  r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r;
6101
  r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r;
6102
  r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r;
6103
  r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r;
6104
  r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r;
6105
 
6106
  return r;
6107
}
6108
 
6109
#endif /* GL_ATI_vertex_array_object */
6110
 
6111
#ifdef GL_ATI_vertex_attrib_array_object
6112
 
6113
static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
6114
{
6115
  GLboolean r = GL_FALSE;
6116
 
6117
  r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r;
6118
  r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r;
6119
  r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r;
6120
 
6121
  return r;
6122
}
6123
 
6124
#endif /* GL_ATI_vertex_attrib_array_object */
6125
 
6126
#ifdef GL_ATI_vertex_streams
6127
 
6128
static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT)
6129
{
6130
  GLboolean r = GL_FALSE;
6131
 
6132
  r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r;
6133
  r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r;
6134
  r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r;
6135
  r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r;
6136
  r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r;
6137
  r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r;
6138
  r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r;
6139
  r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r;
6140
  r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r;
6141
  r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r;
6142
  r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r;
6143
  r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r;
6144
  r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r;
6145
  r = ((glVertexStream1dATI = (PFNGLVERTEXSTREAM1DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dATI")) == NULL) || r;
6146
  r = ((glVertexStream1dvATI = (PFNGLVERTEXSTREAM1DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dvATI")) == NULL) || r;
6147
  r = ((glVertexStream1fATI = (PFNGLVERTEXSTREAM1FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fATI")) == NULL) || r;
6148
  r = ((glVertexStream1fvATI = (PFNGLVERTEXSTREAM1FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fvATI")) == NULL) || r;
6149
  r = ((glVertexStream1iATI = (PFNGLVERTEXSTREAM1IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1iATI")) == NULL) || r;
6150
  r = ((glVertexStream1ivATI = (PFNGLVERTEXSTREAM1IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1ivATI")) == NULL) || r;
6151
  r = ((glVertexStream1sATI = (PFNGLVERTEXSTREAM1SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1sATI")) == NULL) || r;
6152
  r = ((glVertexStream1svATI = (PFNGLVERTEXSTREAM1SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1svATI")) == NULL) || r;
6153
  r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r;
6154
  r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r;
6155
  r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r;
6156
  r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r;
6157
  r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r;
6158
  r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r;
6159
  r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r;
6160
  r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r;
6161
  r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r;
6162
  r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r;
6163
  r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r;
6164
  r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r;
6165
  r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r;
6166
  r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r;
6167
  r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r;
6168
  r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r;
6169
  r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r;
6170
  r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r;
6171
  r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r;
6172
  r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r;
6173
  r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r;
6174
  r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r;
6175
  r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r;
6176
  r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r;
6177
 
6178
  return r;
6179
}
6180
 
6181
#endif /* GL_ATI_vertex_streams */
6182
 
6183
#ifdef GL_EXT_422_pixels
6184
 
6185
#endif /* GL_EXT_422_pixels */
6186
 
6187
#ifdef GL_EXT_Cg_shader
6188
 
6189
#endif /* GL_EXT_Cg_shader */
6190
 
6191
#ifdef GL_EXT_abgr
6192
 
6193
#endif /* GL_EXT_abgr */
6194
 
6195
#ifdef GL_EXT_bgra
6196
 
6197
#endif /* GL_EXT_bgra */
6198
 
6199
#ifdef GL_EXT_bindable_uniform
6200
 
6201
static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT)
6202
{
6203
  GLboolean r = GL_FALSE;
6204
 
6205
  r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r;
6206
  r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r;
6207
  r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r;
6208
 
6209
  return r;
6210
}
6211
 
6212
#endif /* GL_EXT_bindable_uniform */
6213
 
6214
#ifdef GL_EXT_blend_color
6215
 
6216
static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT)
6217
{
6218
  GLboolean r = GL_FALSE;
6219
 
6220
  r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r;
6221
 
6222
  return r;
6223
}
6224
 
6225
#endif /* GL_EXT_blend_color */
6226
 
6227
#ifdef GL_EXT_blend_equation_separate
6228
 
6229
static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT)
6230
{
6231
  GLboolean r = GL_FALSE;
6232
 
6233
  r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r;
6234
 
6235
  return r;
6236
}
6237
 
6238
#endif /* GL_EXT_blend_equation_separate */
6239
 
6240
#ifdef GL_EXT_blend_func_separate
6241
 
6242
static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT)
6243
{
6244
  GLboolean r = GL_FALSE;
6245
 
6246
  r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r;
6247
 
6248
  return r;
6249
}
6250
 
6251
#endif /* GL_EXT_blend_func_separate */
6252
 
6253
#ifdef GL_EXT_blend_logic_op
6254
 
6255
#endif /* GL_EXT_blend_logic_op */
6256
 
6257
#ifdef GL_EXT_blend_minmax
6258
 
6259
static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT)
6260
{
6261
  GLboolean r = GL_FALSE;
6262
 
6263
  r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r;
6264
 
6265
  return r;
6266
}
6267
 
6268
#endif /* GL_EXT_blend_minmax */
6269
 
6270
#ifdef GL_EXT_blend_subtract
6271
 
6272
#endif /* GL_EXT_blend_subtract */
6273
 
6274
#ifdef GL_EXT_clip_volume_hint
6275
 
6276
#endif /* GL_EXT_clip_volume_hint */
6277
 
6278
#ifdef GL_EXT_cmyka
6279
 
6280
#endif /* GL_EXT_cmyka */
6281
 
6282
#ifdef GL_EXT_color_subtable
6283
 
6284
static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT)
6285
{
6286
  GLboolean r = GL_FALSE;
6287
 
6288
  r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r;
6289
  r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r;
6290
 
6291
  return r;
6292
}
6293
 
6294
#endif /* GL_EXT_color_subtable */
6295
 
6296
#ifdef GL_EXT_compiled_vertex_array
6297
 
6298
static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
6299
{
6300
  GLboolean r = GL_FALSE;
6301
 
6302
  r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r;
6303
  r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r;
6304
 
6305
  return r;
6306
}
6307
 
6308
#endif /* GL_EXT_compiled_vertex_array */
6309
 
6310
#ifdef GL_EXT_convolution
6311
 
6312
static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT)
6313
{
6314
  GLboolean r = GL_FALSE;
6315
 
6316
  r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r;
6317
  r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r;
6318
  r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r;
6319
  r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r;
6320
  r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r;
6321
  r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r;
6322
  r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r;
6323
  r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r;
6324
  r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r;
6325
  r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r;
6326
  r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r;
6327
  r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r;
6328
  r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r;
6329
 
6330
  return r;
6331
}
6332
 
6333
#endif /* GL_EXT_convolution */
6334
 
6335
#ifdef GL_EXT_coordinate_frame
6336
 
6337
static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT)
6338
{
6339
  GLboolean r = GL_FALSE;
6340
 
6341
  r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r;
6342
  r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r;
6343
 
6344
  return r;
6345
}
6346
 
6347
#endif /* GL_EXT_coordinate_frame */
6348
 
6349
#ifdef GL_EXT_copy_texture
6350
 
6351
static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT)
6352
{
6353
  GLboolean r = GL_FALSE;
6354
 
6355
  r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r;
6356
  r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r;
6357
  r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r;
6358
  r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r;
6359
  r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r;
6360
 
6361
  return r;
6362
}
6363
 
6364
#endif /* GL_EXT_copy_texture */
6365
 
6366
#ifdef GL_EXT_cull_vertex
6367
 
6368
static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
6369
{
6370
  GLboolean r = GL_FALSE;
6371
 
6372
  r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r;
6373
  r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r;
6374
 
6375
  return r;
6376
}
6377
 
6378
#endif /* GL_EXT_cull_vertex */
6379
 
6380
#ifdef GL_EXT_debug_marker
6381
 
6382
static GLboolean _glewInit_GL_EXT_debug_marker (GLEW_CONTEXT_ARG_DEF_INIT)
6383
{
6384
  GLboolean r = GL_FALSE;
6385
 
6386
  r = ((glInsertEventMarkerEXT = (PFNGLINSERTEVENTMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glInsertEventMarkerEXT")) == NULL) || r;
6387
  r = ((glPopGroupMarkerEXT = (PFNGLPOPGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPopGroupMarkerEXT")) == NULL) || r;
6388
  r = ((glPushGroupMarkerEXT = (PFNGLPUSHGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPushGroupMarkerEXT")) == NULL) || r;
6389
 
6390
  return r;
6391
}
6392
 
6393
#endif /* GL_EXT_debug_marker */
6394
 
6395
#ifdef GL_EXT_depth_bounds_test
6396
 
6397
static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT)
6398
{
6399
  GLboolean r = GL_FALSE;
6400
 
6401
  r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r;
6402
 
6403
  return r;
6404
}
6405
 
6406
#endif /* GL_EXT_depth_bounds_test */
6407
 
6408
#ifdef GL_EXT_direct_state_access
6409
 
6410
static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT)
6411
{
6412
  GLboolean r = GL_FALSE;
6413
 
6414
  r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r;
6415
  r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r;
6416
  r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r;
6417
  r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r;
6418
  r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r;
6419
  r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r;
6420
  r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r;
6421
  r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r;
6422
  r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r;
6423
  r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r;
6424
  r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r;
6425
  r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r;
6426
  r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r;
6427
  r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r;
6428
  r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r;
6429
  r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r;
6430
  r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r;
6431
  r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r;
6432
  r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r;
6433
  r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r;
6434
  r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r;
6435
  r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r;
6436
  r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r;
6437
  r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r;
6438
  r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r;
6439
  r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r;
6440
  r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r;
6441
  r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r;
6442
  r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r;
6443
  r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r;
6444
  r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r;
6445
  r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r;
6446
  r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r;
6447
  r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r;
6448
  r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r;
6449
  r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r;
6450
  r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r;
6451
  r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r;
6452
  r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r;
6453
  r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r;
6454
  r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r;
6455
  r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r;
6456
  r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r;
6457
  r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r;
6458
  r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r;
6459
  r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r;
6460
  r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r;
6461
  r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r;
6462
  r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r;
6463
  r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r;
6464
  r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r;
6465
  r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r;
6466
  r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r;
6467
  r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r;
6468
  r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r;
6469
  r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r;
6470
  r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r;
6471
  r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r;
6472
  r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r;
6473
  r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r;
6474
  r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r;
6475
  r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r;
6476
  r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r;
6477
  r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r;
6478
  r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r;
6479
  r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r;
6480
  r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r;
6481
  r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r;
6482
  r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r;
6483
  r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r;
6484
  r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r;
6485
  r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r;
6486
  r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r;
6487
  r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r;
6488
  r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r;
6489
  r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r;
6490
  r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r;
6491
  r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r;
6492
  r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r;
6493
  r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r;
6494
  r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r;
6495
  r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r;
6496
  r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r;
6497
  r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r;
6498
  r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r;
6499
  r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r;
6500
  r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r;
6501
  r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r;
6502
  r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r;
6503
  r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r;
6504
  r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r;
6505
  r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r;
6506
  r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r;
6507
  r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r;
6508
  r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r;
6509
  r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r;
6510
  r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r;
6511
  r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r;
6512
  r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r;
6513
  r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r;
6514
  r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r;
6515
  r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r;
6516
  r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r;
6517
  r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r;
6518
  r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r;
6519
  r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r;
6520
  r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r;
6521
  r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r;
6522
  r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r;
6523
  r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r;
6524
  r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r;
6525
  r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r;
6526
  r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r;
6527
  r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r;
6528
  r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r;
6529
  r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r;
6530
  r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r;
6531
  r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r;
6532
  r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r;
6533
  r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r;
6534
  r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r;
6535
  r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r;
6536
  r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r;
6537
  r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r;
6538
  r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r;
6539
  r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r;
6540
  r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r;
6541
  r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;
6542
  r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;
6543
  r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;
6544
  r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r;
6545
  r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;
6546
  r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r;
6547
  r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r;
6548
  r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r;
6549
  r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r;
6550
  r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r;
6551
  r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r;
6552
  r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r;
6553
  r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r;
6554
  r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r;
6555
  r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r;
6556
  r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r;
6557
  r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r;
6558
  r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r;
6559
  r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r;
6560
  r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r;
6561
  r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r;
6562
  r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r;
6563
  r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r;
6564
  r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r;
6565
  r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r;
6566
  r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r;
6567
  r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r;
6568
  r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r;
6569
  r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r;
6570
  r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r;
6571
  r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r;
6572
  r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r;
6573
  r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r;
6574
  r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r;
6575
  r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r;
6576
  r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r;
6577
  r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r;
6578
  r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r;
6579
  r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r;
6580
  r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r;
6581
  r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r;
6582
  r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r;
6583
  r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r;
6584
  r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r;
6585
  r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r;
6586
  r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r;
6587
  r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r;
6588
  r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r;
6589
  r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r;
6590
  r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r;
6591
  r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r;
6592
  r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r;
6593
  r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r;
6594
  r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r;
6595
  r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r;
6596
  r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r;
6597
  r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r;
6598
  r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r;
6599
  r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r;
6600
  r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r;
6601
  r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r;
6602
  r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r;
6603
  r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r;
6604
  r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r;
6605
  r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r;
6606
  r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r;
6607
  r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r;
6608
  r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r;
6609
  r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r;
6610
  r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r;
6611
  r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r;
6612
  r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r;
6613
  r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r;
6614
  r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r;
6615
  r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r;
6616
  r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r;
6617
  r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r;
6618
  r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r;
6619
  r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r;
6620
  r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r;
6621
  r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r;
6622
  r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r;
6623
  r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r;
6624
  r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r;
6625
  r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r;
6626
  r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r;
6627
 
6628
  return r;
6629
}
6630
 
6631
#endif /* GL_EXT_direct_state_access */
6632
 
6633
#ifdef GL_EXT_draw_buffers2
6634
 
6635
static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT)
6636
{
6637
  GLboolean r = GL_FALSE;
6638
 
6639
  r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r;
6640
  r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r;
6641
  r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r;
6642
  r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r;
6643
  r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r;
6644
  r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r;
6645
 
6646
  return r;
6647
}
6648
 
6649
#endif /* GL_EXT_draw_buffers2 */
6650
 
6651
#ifdef GL_EXT_draw_instanced
6652
 
6653
static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
6654
{
6655
  GLboolean r = GL_FALSE;
6656
 
6657
  r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r;
6658
  r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r;
6659
 
6660
  return r;
6661
}
6662
 
6663
#endif /* GL_EXT_draw_instanced */
6664
 
6665
#ifdef GL_EXT_draw_range_elements
6666
 
6667
static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT)
6668
{
6669
  GLboolean r = GL_FALSE;
6670
 
6671
  r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r;
6672
 
6673
  return r;
6674
}
6675
 
6676
#endif /* GL_EXT_draw_range_elements */
6677
 
6678
#ifdef GL_EXT_fog_coord
6679
 
6680
static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT)
6681
{
6682
  GLboolean r = GL_FALSE;
6683
 
6684
  r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r;
6685
  r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r;
6686
  r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r;
6687
  r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r;
6688
  r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r;
6689
 
6690
  return r;
6691
}
6692
 
6693
#endif /* GL_EXT_fog_coord */
6694
 
6695
#ifdef GL_EXT_fragment_lighting
6696
 
6697
static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT)
6698
{
6699
  GLboolean r = GL_FALSE;
6700
 
6701
  r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r;
6702
  r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r;
6703
  r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r;
6704
  r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r;
6705
  r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r;
6706
  r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r;
6707
  r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r;
6708
  r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r;
6709
  r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r;
6710
  r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r;
6711
  r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r;
6712
  r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r;
6713
  r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r;
6714
  r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r;
6715
  r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r;
6716
  r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r;
6717
  r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r;
6718
  r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r;
6719
 
6720
  return r;
6721
}
6722
 
6723
#endif /* GL_EXT_fragment_lighting */
6724
 
6725
#ifdef GL_EXT_framebuffer_blit
6726
 
6727
static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT)
6728
{
6729
  GLboolean r = GL_FALSE;
6730
 
6731
  r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r;
6732
 
6733
  return r;
6734
}
6735
 
6736
#endif /* GL_EXT_framebuffer_blit */
6737
 
6738
#ifdef GL_EXT_framebuffer_multisample
6739
 
6740
static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
6741
{
6742
  GLboolean r = GL_FALSE;
6743
 
6744
  r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r;
6745
 
6746
  return r;
6747
}
6748
 
6749
#endif /* GL_EXT_framebuffer_multisample */
6750
 
6751
#ifdef GL_EXT_framebuffer_multisample_blit_scaled
6752
 
6753
#endif /* GL_EXT_framebuffer_multisample_blit_scaled */
6754
 
6755
#ifdef GL_EXT_framebuffer_object
6756
 
6757
static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
6758
{
6759
  GLboolean r = GL_FALSE;
6760
 
6761
  r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;
6762
  r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;
6763
  r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;
6764
  r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;
6765
  r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;
6766
  r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;
6767
  r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;
6768
  r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;
6769
  r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;
6770
  r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;
6771
  r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;
6772
  r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;
6773
  r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;
6774
  r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;
6775
  r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;
6776
  r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;
6777
  r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;
6778
 
6779
  return r;
6780
}
6781
 
6782
#endif /* GL_EXT_framebuffer_object */
6783
 
6784
#ifdef GL_EXT_framebuffer_sRGB
6785
 
6786
#endif /* GL_EXT_framebuffer_sRGB */
6787
 
6788
#ifdef GL_EXT_geometry_shader4
6789
 
6790
static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
6791
{
6792
  GLboolean r = GL_FALSE;
6793
 
6794
  r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r;
6795
  r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r;
6796
  r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r;
6797
 
6798
  return r;
6799
}
6800
 
6801
#endif /* GL_EXT_geometry_shader4 */
6802
 
6803
#ifdef GL_EXT_gpu_program_parameters
6804
 
6805
static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
6806
{
6807
  GLboolean r = GL_FALSE;
6808
 
6809
  r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r;
6810
  r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r;
6811
 
6812
  return r;
6813
}
6814
 
6815
#endif /* GL_EXT_gpu_program_parameters */
6816
 
6817
#ifdef GL_EXT_gpu_shader4
6818
 
6819
static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
6820
{
6821
  GLboolean r = GL_FALSE;
6822
 
6823
  r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r;
6824
  r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r;
6825
  r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r;
6826
  r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r;
6827
  r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r;
6828
  r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r;
6829
  r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r;
6830
  r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r;
6831
  r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r;
6832
  r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r;
6833
  r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r;
6834
  r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r;
6835
  r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r;
6836
  r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r;
6837
  r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r;
6838
  r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r;
6839
  r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r;
6840
  r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r;
6841
  r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r;
6842
  r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r;
6843
  r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r;
6844
  r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r;
6845
  r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r;
6846
  r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r;
6847
  r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r;
6848
  r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r;
6849
  r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r;
6850
  r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r;
6851
  r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r;
6852
  r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r;
6853
  r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r;
6854
  r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r;
6855
  r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r;
6856
  r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r;
6857
 
6858
  return r;
6859
}
6860
 
6861
#endif /* GL_EXT_gpu_shader4 */
6862
 
6863
#ifdef GL_EXT_histogram
6864
 
6865
static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT)
6866
{
6867
  GLboolean r = GL_FALSE;
6868
 
6869
  r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r;
6870
  r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r;
6871
  r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r;
6872
  r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r;
6873
  r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r;
6874
  r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r;
6875
  r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r;
6876
  r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r;
6877
  r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r;
6878
  r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r;
6879
 
6880
  return r;
6881
}
6882
 
6883
#endif /* GL_EXT_histogram */
6884
 
6885
#ifdef GL_EXT_index_array_formats
6886
 
6887
#endif /* GL_EXT_index_array_formats */
6888
 
6889
#ifdef GL_EXT_index_func
6890
 
6891
static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT)
6892
{
6893
  GLboolean r = GL_FALSE;
6894
 
6895
  r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r;
6896
 
6897
  return r;
6898
}
6899
 
6900
#endif /* GL_EXT_index_func */
6901
 
6902
#ifdef GL_EXT_index_material
6903
 
6904
static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT)
6905
{
6906
  GLboolean r = GL_FALSE;
6907
 
6908
  r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r;
6909
 
6910
  return r;
6911
}
6912
 
6913
#endif /* GL_EXT_index_material */
6914
 
6915
#ifdef GL_EXT_index_texture
6916
 
6917
#endif /* GL_EXT_index_texture */
6918
 
6919
#ifdef GL_EXT_light_texture
6920
 
6921
static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT)
6922
{
6923
  GLboolean r = GL_FALSE;
6924
 
6925
  r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r;
6926
  r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r;
6927
  r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r;
6928
 
6929
  return r;
6930
}
6931
 
6932
#endif /* GL_EXT_light_texture */
6933
 
6934
#ifdef GL_EXT_misc_attribute
6935
 
6936
#endif /* GL_EXT_misc_attribute */
6937
 
6938
#ifdef GL_EXT_multi_draw_arrays
6939
 
6940
static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
6941
{
6942
  GLboolean r = GL_FALSE;
6943
 
6944
  r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r;
6945
  r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r;
6946
 
6947
  return r;
6948
}
6949
 
6950
#endif /* GL_EXT_multi_draw_arrays */
6951
 
6952
#ifdef GL_EXT_multisample
6953
 
6954
static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
6955
{
6956
  GLboolean r = GL_FALSE;
6957
 
6958
  r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r;
6959
  r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r;
6960
 
6961
  return r;
6962
}
6963
 
6964
#endif /* GL_EXT_multisample */
6965
 
6966
#ifdef GL_EXT_packed_depth_stencil
6967
 
6968
#endif /* GL_EXT_packed_depth_stencil */
6969
 
6970
#ifdef GL_EXT_packed_float
6971
 
6972
#endif /* GL_EXT_packed_float */
6973
 
6974
#ifdef GL_EXT_packed_pixels
6975
 
6976
#endif /* GL_EXT_packed_pixels */
6977
 
6978
#ifdef GL_EXT_paletted_texture
6979
 
6980
static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT)
6981
{
6982
  GLboolean r = GL_FALSE;
6983
 
6984
  r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r;
6985
  r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r;
6986
  r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r;
6987
  r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r;
6988
 
6989
  return r;
6990
}
6991
 
6992
#endif /* GL_EXT_paletted_texture */
6993
 
6994
#ifdef GL_EXT_pixel_buffer_object
6995
 
6996
#endif /* GL_EXT_pixel_buffer_object */
6997
 
6998
#ifdef GL_EXT_pixel_transform
6999
 
7000
static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT)
7001
{
7002
  GLboolean r = GL_FALSE;
7003
 
7004
  r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r;
7005
  r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r;
7006
  r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r;
7007
  r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r;
7008
  r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r;
7009
  r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r;
7010
 
7011
  return r;
7012
}
7013
 
7014
#endif /* GL_EXT_pixel_transform */
7015
 
7016
#ifdef GL_EXT_pixel_transform_color_table
7017
 
7018
#endif /* GL_EXT_pixel_transform_color_table */
7019
 
7020
#ifdef GL_EXT_point_parameters
7021
 
7022
static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
7023
{
7024
  GLboolean r = GL_FALSE;
7025
 
7026
  r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;
7027
  r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;
7028
 
7029
  return r;
7030
}
7031
 
7032
#endif /* GL_EXT_point_parameters */
7033
 
7034
#ifdef GL_EXT_polygon_offset
7035
 
7036
static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)
7037
{
7038
  GLboolean r = GL_FALSE;
7039
 
7040
  r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r;
7041
 
7042
  return r;
7043
}
7044
 
7045
#endif /* GL_EXT_polygon_offset */
7046
 
7047
#ifdef GL_EXT_provoking_vertex
7048
 
7049
static GLboolean _glewInit_GL_EXT_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
7050
{
7051
  GLboolean r = GL_FALSE;
7052
 
7053
  r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r;
7054
 
7055
  return r;
7056
}
7057
 
7058
#endif /* GL_EXT_provoking_vertex */
7059
 
7060
#ifdef GL_EXT_rescale_normal
7061
 
7062
#endif /* GL_EXT_rescale_normal */
7063
 
7064
#ifdef GL_EXT_scene_marker
7065
 
7066
static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT)
7067
{
7068
  GLboolean r = GL_FALSE;
7069
 
7070
  r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r;
7071
  r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r;
7072
 
7073
  return r;
7074
}
7075
 
7076
#endif /* GL_EXT_scene_marker */
7077
 
7078
#ifdef GL_EXT_secondary_color
7079
 
7080
static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)
7081
{
7082
  GLboolean r = GL_FALSE;
7083
 
7084
  r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;
7085
  r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;
7086
  r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;
7087
  r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;
7088
  r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;
7089
  r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;
7090
  r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;
7091
  r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;
7092
  r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;
7093
  r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;
7094
  r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;
7095
  r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;
7096
  r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;
7097
  r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;
7098
  r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;
7099
  r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;
7100
  r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;
7101
 
7102
  return r;
7103
}
7104
 
7105
#endif /* GL_EXT_secondary_color */
7106
 
7107
#ifdef GL_EXT_separate_shader_objects
7108
 
7109
static GLboolean _glewInit_GL_EXT_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
7110
{
7111
  GLboolean r = GL_FALSE;
7112
 
7113
  r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r;
7114
  r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r;
7115
  r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r;
7116
 
7117
  return r;
7118
}
7119
 
7120
#endif /* GL_EXT_separate_shader_objects */
7121
 
7122
#ifdef GL_EXT_separate_specular_color
7123
 
7124
#endif /* GL_EXT_separate_specular_color */
7125
 
7126
#ifdef GL_EXT_shader_image_load_store
7127
 
7128
static GLboolean _glewInit_GL_EXT_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
7129
{
7130
  GLboolean r = GL_FALSE;
7131
 
7132
  r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r;
7133
  r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r;
7134
 
7135
  return r;
7136
}
7137
 
7138
#endif /* GL_EXT_shader_image_load_store */
7139
 
7140
#ifdef GL_EXT_shadow_funcs
7141
 
7142
#endif /* GL_EXT_shadow_funcs */
7143
 
7144
#ifdef GL_EXT_shared_texture_palette
7145
 
7146
#endif /* GL_EXT_shared_texture_palette */
7147
 
7148
#ifdef GL_EXT_stencil_clear_tag
7149
 
7150
#endif /* GL_EXT_stencil_clear_tag */
7151
 
7152
#ifdef GL_EXT_stencil_two_side
7153
 
7154
static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)
7155
{
7156
  GLboolean r = GL_FALSE;
7157
 
7158
  r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;
7159
 
7160
  return r;
7161
}
7162
 
7163
#endif /* GL_EXT_stencil_two_side */
7164
 
7165
#ifdef GL_EXT_stencil_wrap
7166
 
7167
#endif /* GL_EXT_stencil_wrap */
7168
 
7169
#ifdef GL_EXT_subtexture
7170
 
7171
static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT)
7172
{
7173
  GLboolean r = GL_FALSE;
7174
 
7175
  r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r;
7176
  r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r;
7177
  r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r;
7178
 
7179
  return r;
7180
}
7181
 
7182
#endif /* GL_EXT_subtexture */
7183
 
7184
#ifdef GL_EXT_texture
7185
 
7186
#endif /* GL_EXT_texture */
7187
 
7188
#ifdef GL_EXT_texture3D
7189
 
7190
static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT)
7191
{
7192
  GLboolean r = GL_FALSE;
7193
 
7194
  r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r;
7195
 
7196
  return r;
7197
}
7198
 
7199
#endif /* GL_EXT_texture3D */
7200
 
7201
#ifdef GL_EXT_texture_array
7202
 
7203
static GLboolean _glewInit_GL_EXT_texture_array (GLEW_CONTEXT_ARG_DEF_INIT)
7204
{
7205
  GLboolean r = GL_FALSE;
7206
 
7207
  r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r;
7208
 
7209
  return r;
7210
}
7211
 
7212
#endif /* GL_EXT_texture_array */
7213
 
7214
#ifdef GL_EXT_texture_buffer_object
7215
 
7216
static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
7217
{
7218
  GLboolean r = GL_FALSE;
7219
 
7220
  r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r;
7221
 
7222
  return r;
7223
}
7224
 
7225
#endif /* GL_EXT_texture_buffer_object */
7226
 
7227
#ifdef GL_EXT_texture_compression_dxt1
7228
 
7229
#endif /* GL_EXT_texture_compression_dxt1 */
7230
 
7231
#ifdef GL_EXT_texture_compression_latc
7232
 
7233
#endif /* GL_EXT_texture_compression_latc */
7234
 
7235
#ifdef GL_EXT_texture_compression_rgtc
7236
 
7237
#endif /* GL_EXT_texture_compression_rgtc */
7238
 
7239
#ifdef GL_EXT_texture_compression_s3tc
7240
 
7241
#endif /* GL_EXT_texture_compression_s3tc */
7242
 
7243
#ifdef GL_EXT_texture_cube_map
7244
 
7245
#endif /* GL_EXT_texture_cube_map */
7246
 
7247
#ifdef GL_EXT_texture_edge_clamp
7248
 
7249
#endif /* GL_EXT_texture_edge_clamp */
7250
 
7251
#ifdef GL_EXT_texture_env
7252
 
7253
#endif /* GL_EXT_texture_env */
7254
 
7255
#ifdef GL_EXT_texture_env_add
7256
 
7257
#endif /* GL_EXT_texture_env_add */
7258
 
7259
#ifdef GL_EXT_texture_env_combine
7260
 
7261
#endif /* GL_EXT_texture_env_combine */
7262
 
7263
#ifdef GL_EXT_texture_env_dot3
7264
 
7265
#endif /* GL_EXT_texture_env_dot3 */
7266
 
7267
#ifdef GL_EXT_texture_filter_anisotropic
7268
 
7269
#endif /* GL_EXT_texture_filter_anisotropic */
7270
 
7271
#ifdef GL_EXT_texture_integer
7272
 
7273
static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT)
7274
{
7275
  GLboolean r = GL_FALSE;
7276
 
7277
  r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r;
7278
  r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r;
7279
  r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r;
7280
  r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r;
7281
  r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r;
7282
  r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r;
7283
 
7284
  return r;
7285
}
7286
 
7287
#endif /* GL_EXT_texture_integer */
7288
 
7289
#ifdef GL_EXT_texture_lod_bias
7290
 
7291
#endif /* GL_EXT_texture_lod_bias */
7292
 
7293
#ifdef GL_EXT_texture_mirror_clamp
7294
 
7295
#endif /* GL_EXT_texture_mirror_clamp */
7296
 
7297
#ifdef GL_EXT_texture_object
7298
 
7299
static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT)
7300
{
7301
  GLboolean r = GL_FALSE;
7302
 
7303
  r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r;
7304
  r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r;
7305
  r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r;
7306
  r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;
7307
  r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;
7308
  r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;
7309
 
7310
  return r;
7311
}
7312
 
7313
#endif /* GL_EXT_texture_object */
7314
 
7315
#ifdef GL_EXT_texture_perturb_normal
7316
 
7317
static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT)
7318
{
7319
  GLboolean r = GL_FALSE;
7320
 
7321
  r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;
7322
 
7323
  return r;
7324
}
7325
 
7326
#endif /* GL_EXT_texture_perturb_normal */
7327
 
7328
#ifdef GL_EXT_texture_rectangle
7329
 
7330
#endif /* GL_EXT_texture_rectangle */
7331
 
7332
#ifdef GL_EXT_texture_sRGB
7333
 
7334
#endif /* GL_EXT_texture_sRGB */
7335
 
7336
#ifdef GL_EXT_texture_sRGB_decode
7337
 
7338
#endif /* GL_EXT_texture_sRGB_decode */
7339
 
7340
#ifdef GL_EXT_texture_shared_exponent
7341
 
7342
#endif /* GL_EXT_texture_shared_exponent */
7343
 
7344
#ifdef GL_EXT_texture_snorm
7345
 
7346
#endif /* GL_EXT_texture_snorm */
7347
 
7348
#ifdef GL_EXT_texture_swizzle
7349
 
7350
#endif /* GL_EXT_texture_swizzle */
7351
 
7352
#ifdef GL_EXT_timer_query
7353
 
7354
static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
7355
{
7356
  GLboolean r = GL_FALSE;
7357
 
7358
  r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r;
7359
  r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r;
7360
 
7361
  return r;
7362
}
7363
 
7364
#endif /* GL_EXT_timer_query */
7365
 
7366
#ifdef GL_EXT_transform_feedback
7367
 
7368
static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
7369
{
7370
  GLboolean r = GL_FALSE;
7371
 
7372
  r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r;
7373
  r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r;
7374
  r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r;
7375
  r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r;
7376
  r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r;
7377
  r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r;
7378
  r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r;
7379
 
7380
  return r;
7381
}
7382
 
7383
#endif /* GL_EXT_transform_feedback */
7384
 
7385
#ifdef GL_EXT_vertex_array
7386
 
7387
static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
7388
{
7389
  GLboolean r = GL_FALSE;
7390
 
7391
  r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;
7392
  r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;
7393
  r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;
7394
  r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;
7395
  r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;
7396
  r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;
7397
  r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;
7398
  r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;
7399
 
7400
  return r;
7401
}
7402
 
7403
#endif /* GL_EXT_vertex_array */
7404
 
7405
#ifdef GL_EXT_vertex_array_bgra
7406
 
7407
#endif /* GL_EXT_vertex_array_bgra */
7408
 
7409
#ifdef GL_EXT_vertex_attrib_64bit
7410
 
7411
static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
7412
{
7413
  GLboolean r = GL_FALSE;
7414
 
7415
  r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r;
7416
  r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r;
7417
  r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r;
7418
  r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r;
7419
  r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r;
7420
  r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r;
7421
  r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r;
7422
  r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r;
7423
  r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r;
7424
  r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r;
7425
  r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r;
7426
 
7427
  return r;
7428
}
7429
 
7430
#endif /* GL_EXT_vertex_attrib_64bit */
7431
 
7432
#ifdef GL_EXT_vertex_shader
7433
 
7434
static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
7435
{
7436
  GLboolean r = GL_FALSE;
7437
 
7438
  r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;
7439
  r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;
7440
  r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;
7441
  r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;
7442
  r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;
7443
  r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;
7444
  r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;
7445
  r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;
7446
  r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;
7447
  r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;
7448
  r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;
7449
  r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;
7450
  r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;
7451
  r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;
7452
  r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;
7453
  r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;
7454
  r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;
7455
  r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;
7456
  r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;
7457
  r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;
7458
  r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;
7459
  r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;
7460
  r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;
7461
  r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;
7462
  r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;
7463
  r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;
7464
  r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;
7465
  r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;
7466
  r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;
7467
  r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;
7468
  r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;
7469
  r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;
7470
  r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;
7471
  r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;
7472
  r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;
7473
  r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;
7474
  r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;
7475
  r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;
7476
  r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;
7477
  r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;
7478
  r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;
7479
  r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;
7480
 
7481
  return r;
7482
}
7483
 
7484
#endif /* GL_EXT_vertex_shader */
7485
 
7486
#ifdef GL_EXT_vertex_weighting
7487
 
7488
static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT)
7489
{
7490
  GLboolean r = GL_FALSE;
7491
 
7492
  r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;
7493
  r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;
7494
  r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;
7495
 
7496
  return r;
7497
}
7498
 
7499
#endif /* GL_EXT_vertex_weighting */
7500
 
7501
#ifdef GL_EXT_x11_sync_object
7502
 
7503
static GLboolean _glewInit_GL_EXT_x11_sync_object (GLEW_CONTEXT_ARG_DEF_INIT)
7504
{
7505
  GLboolean r = GL_FALSE;
7506
 
7507
  r = ((glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSyncEXT")) == NULL) || r;
7508
 
7509
  return r;
7510
}
7511
 
7512
#endif /* GL_EXT_x11_sync_object */
7513
 
7514
#ifdef GL_GREMEDY_frame_terminator
7515
 
7516
static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT)
7517
{
7518
  GLboolean r = GL_FALSE;
7519
 
7520
  r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r;
7521
 
7522
  return r;
7523
}
7524
 
7525
#endif /* GL_GREMEDY_frame_terminator */
7526
 
7527
#ifdef GL_GREMEDY_string_marker
7528
 
7529
static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT)
7530
{
7531
  GLboolean r = GL_FALSE;
7532
 
7533
  r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r;
7534
 
7535
  return r;
7536
}
7537
 
7538
#endif /* GL_GREMEDY_string_marker */
7539
 
7540
#ifdef GL_HP_convolution_border_modes
7541
 
7542
#endif /* GL_HP_convolution_border_modes */
7543
 
7544
#ifdef GL_HP_image_transform
7545
 
7546
static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT)
7547
{
7548
  GLboolean r = GL_FALSE;
7549
 
7550
  r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;
7551
  r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;
7552
  r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;
7553
  r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;
7554
  r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;
7555
  r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;
7556
 
7557
  return r;
7558
}
7559
 
7560
#endif /* GL_HP_image_transform */
7561
 
7562
#ifdef GL_HP_occlusion_test
7563
 
7564
#endif /* GL_HP_occlusion_test */
7565
 
7566
#ifdef GL_HP_texture_lighting
7567
 
7568
#endif /* GL_HP_texture_lighting */
7569
 
7570
#ifdef GL_IBM_cull_vertex
7571
 
7572
#endif /* GL_IBM_cull_vertex */
7573
 
7574
#ifdef GL_IBM_multimode_draw_arrays
7575
 
7576
static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
7577
{
7578
  GLboolean r = GL_FALSE;
7579
 
7580
  r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;
7581
  r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;
7582
 
7583
  return r;
7584
}
7585
 
7586
#endif /* GL_IBM_multimode_draw_arrays */
7587
 
7588
#ifdef GL_IBM_rasterpos_clip
7589
 
7590
#endif /* GL_IBM_rasterpos_clip */
7591
 
7592
#ifdef GL_IBM_static_data
7593
 
7594
#endif /* GL_IBM_static_data */
7595
 
7596
#ifdef GL_IBM_texture_mirrored_repeat
7597
 
7598
#endif /* GL_IBM_texture_mirrored_repeat */
7599
 
7600
#ifdef GL_IBM_vertex_array_lists
7601
 
7602
static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT)
7603
{
7604
  GLboolean r = GL_FALSE;
7605
 
7606
  r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;
7607
  r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;
7608
  r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;
7609
  r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;
7610
  r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;
7611
  r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;
7612
  r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;
7613
  r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;
7614
 
7615
  return r;
7616
}
7617
 
7618
#endif /* GL_IBM_vertex_array_lists */
7619
 
7620
#ifdef GL_INGR_color_clamp
7621
 
7622
#endif /* GL_INGR_color_clamp */
7623
 
7624
#ifdef GL_INGR_interlace_read
7625
 
7626
#endif /* GL_INGR_interlace_read */
7627
 
677 janba 7628
#ifdef GL_INTEL_map_texture
7629
 
7630
static GLboolean _glewInit_GL_INTEL_map_texture (GLEW_CONTEXT_ARG_DEF_INIT)
7631
{
7632
  GLboolean r = GL_FALSE;
7633
 
7634
  r = ((glMapTexture2DINTEL = (PFNGLMAPTEXTURE2DINTELPROC)glewGetProcAddress((const GLubyte*)"glMapTexture2DINTEL")) == NULL) || r;
7635
  r = ((glSyncTextureINTEL = (PFNGLSYNCTEXTUREINTELPROC)glewGetProcAddress((const GLubyte*)"glSyncTextureINTEL")) == NULL) || r;
7636
  r = ((glUnmapTexture2DINTEL = (PFNGLUNMAPTEXTURE2DINTELPROC)glewGetProcAddress((const GLubyte*)"glUnmapTexture2DINTEL")) == NULL) || r;
7637
 
7638
  return r;
7639
}
7640
 
7641
#endif /* GL_INTEL_map_texture */
7642
 
667 khor 7643
#ifdef GL_INTEL_parallel_arrays
7644
 
7645
static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
7646
{
7647
  GLboolean r = GL_FALSE;
7648
 
7649
  r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;
7650
  r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;
7651
  r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;
7652
  r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;
7653
 
7654
  return r;
7655
}
7656
 
7657
#endif /* GL_INTEL_parallel_arrays */
7658
 
7659
#ifdef GL_INTEL_texture_scissor
7660
 
7661
static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT)
7662
{
7663
  GLboolean r = GL_FALSE;
7664
 
7665
  r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;
7666
  r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;
7667
 
7668
  return r;
7669
}
7670
 
7671
#endif /* GL_INTEL_texture_scissor */
7672
 
7673
#ifdef GL_KHR_debug
7674
 
7675
static GLboolean _glewInit_GL_KHR_debug (GLEW_CONTEXT_ARG_DEF_INIT)
7676
{
7677
  GLboolean r = GL_FALSE;
7678
 
7679
  r = ((glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallback")) == NULL) || r;
7680
  r = ((glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControl")) == NULL) || r;
7681
  r = ((glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsert")) == NULL) || r;
7682
  r = ((glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLog")) == NULL) || r;
7683
  r = ((glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabel")) == NULL) || r;
7684
  r = ((glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectPtrLabel")) == NULL) || r;
7685
  r = ((glObjectLabel = (PFNGLOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectLabel")) == NULL) || r;
7686
  r = ((glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectPtrLabel")) == NULL) || r;
677 janba 7687
  r = ((glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPopDebugGroup")) == NULL) || r;
667 khor 7688
  r = ((glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPushDebugGroup")) == NULL) || r;
7689
 
7690
  return r;
7691
}
7692
 
7693
#endif /* GL_KHR_debug */
7694
 
7695
#ifdef GL_KHR_texture_compression_astc_ldr
7696
 
7697
#endif /* GL_KHR_texture_compression_astc_ldr */
7698
 
7699
#ifdef GL_KTX_buffer_region
7700
 
7701
static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT)
7702
{
7703
  GLboolean r = GL_FALSE;
7704
 
7705
  r = ((glBufferRegionEnabled = (PFNGLBUFFERREGIONENABLEDPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabled")) == NULL) || r;
7706
  r = ((glDeleteBufferRegion = (PFNGLDELETEBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegion")) == NULL) || r;
7707
  r = ((glDrawBufferRegion = (PFNGLDRAWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegion")) == NULL) || r;
7708
  r = ((glNewBufferRegion = (PFNGLNEWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegion")) == NULL) || r;
7709
  r = ((glReadBufferRegion = (PFNGLREADBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegion")) == NULL) || r;
7710
 
7711
  return r;
7712
}
7713
 
7714
#endif /* GL_KTX_buffer_region */
7715
 
7716
#ifdef GL_MESAX_texture_stack
7717
 
7718
#endif /* GL_MESAX_texture_stack */
7719
 
7720
#ifdef GL_MESA_pack_invert
7721
 
7722
#endif /* GL_MESA_pack_invert */
7723
 
7724
#ifdef GL_MESA_resize_buffers
7725
 
7726
static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
7727
{
7728
  GLboolean r = GL_FALSE;
7729
 
7730
  r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;
7731
 
7732
  return r;
7733
}
7734
 
7735
#endif /* GL_MESA_resize_buffers */
7736
 
7737
#ifdef GL_MESA_window_pos
7738
 
7739
static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
7740
{
7741
  GLboolean r = GL_FALSE;
7742
 
7743
  r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;
7744
  r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;
7745
  r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;
7746
  r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;
7747
  r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;
7748
  r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;
7749
  r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;
7750
  r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;
7751
  r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;
7752
  r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;
7753
  r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;
7754
  r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;
7755
  r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;
7756
  r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;
7757
  r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;
7758
  r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;
7759
  r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;
7760
  r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;
7761
  r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;
7762
  r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;
7763
  r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;
7764
  r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;
7765
  r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;
7766
  r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;
7767
 
7768
  return r;
7769
}
7770
 
7771
#endif /* GL_MESA_window_pos */
7772
 
7773
#ifdef GL_MESA_ycbcr_texture
7774
 
7775
#endif /* GL_MESA_ycbcr_texture */
7776
 
677 janba 7777
#ifdef GL_NVX_conditional_render
7778
 
7779
static GLboolean _glewInit_GL_NVX_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT)
7780
{
7781
  GLboolean r = GL_FALSE;
7782
 
7783
  r = ((glBeginConditionalRenderNVX = (PFNGLBEGINCONDITIONALRENDERNVXPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNVX")) == NULL) || r;
7784
  r = ((glEndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNVX")) == NULL) || r;
7785
 
7786
  return r;
7787
}
7788
 
7789
#endif /* GL_NVX_conditional_render */
7790
 
667 khor 7791
#ifdef GL_NVX_gpu_memory_info
7792
 
7793
#endif /* GL_NVX_gpu_memory_info */
7794
 
677 janba 7795
#ifdef GL_NV_bindless_multi_draw_indirect
7796
 
7797
static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
7798
{
7799
  GLboolean r = GL_FALSE;
7800
 
7801
  r = ((glMultiDrawArraysIndirectBindlessNV = (PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectBindlessNV")) == NULL) || r;
7802
  r = ((glMultiDrawElementsIndirectBindlessNV = (PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectBindlessNV")) == NULL) || r;
7803
 
7804
  return r;
7805
}
7806
 
7807
#endif /* GL_NV_bindless_multi_draw_indirect */
7808
 
667 khor 7809
#ifdef GL_NV_bindless_texture
7810
 
7811
static GLboolean _glewInit_GL_NV_bindless_texture (GLEW_CONTEXT_ARG_DEF_INIT)
7812
{
7813
  GLboolean r = GL_FALSE;
7814
 
7815
  r = ((glGetImageHandleNV = (PFNGLGETIMAGEHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleNV")) == NULL) || r;
7816
  r = ((glGetTextureHandleNV = (PFNGLGETTEXTUREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleNV")) == NULL) || r;
7817
  r = ((glGetTextureSamplerHandleNV = (PFNGLGETTEXTURESAMPLERHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleNV")) == NULL) || r;
7818
  r = ((glIsImageHandleResidentNV = (PFNGLISIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentNV")) == NULL) || r;
7819
  r = ((glIsTextureHandleResidentNV = (PFNGLISTEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentNV")) == NULL) || r;
7820
  r = ((glMakeImageHandleNonResidentNV = (PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentNV")) == NULL) || r;
7821
  r = ((glMakeImageHandleResidentNV = (PFNGLMAKEIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentNV")) == NULL) || r;
7822
  r = ((glMakeTextureHandleNonResidentNV = (PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentNV")) == NULL) || r;
7823
  r = ((glMakeTextureHandleResidentNV = (PFNGLMAKETEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentNV")) == NULL) || r;
7824
  r = ((glProgramUniformHandleui64NV = (PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64NV")) == NULL) || r;
7825
  r = ((glProgramUniformHandleui64vNV = (PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vNV")) == NULL) || r;
7826
  r = ((glUniformHandleui64NV = (PFNGLUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64NV")) == NULL) || r;
7827
  r = ((glUniformHandleui64vNV = (PFNGLUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vNV")) == NULL) || r;
7828
 
7829
  return r;
7830
}
7831
 
7832
#endif /* GL_NV_bindless_texture */
7833
 
677 janba 7834
#ifdef GL_NV_blend_equation_advanced
7835
 
7836
static GLboolean _glewInit_GL_NV_blend_equation_advanced (GLEW_CONTEXT_ARG_DEF_INIT)
7837
{
7838
  GLboolean r = GL_FALSE;
7839
 
7840
  r = ((glBlendBarrierNV = (PFNGLBLENDBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glBlendBarrierNV")) == NULL) || r;
7841
  r = ((glBlendParameteriNV = (PFNGLBLENDPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glBlendParameteriNV")) == NULL) || r;
7842
 
7843
  return r;
7844
}
7845
 
7846
#endif /* GL_NV_blend_equation_advanced */
7847
 
7848
#ifdef GL_NV_blend_equation_advanced_coherent
7849
 
7850
#endif /* GL_NV_blend_equation_advanced_coherent */
7851
 
667 khor 7852
#ifdef GL_NV_blend_square
7853
 
7854
#endif /* GL_NV_blend_square */
7855
 
677 janba 7856
#ifdef GL_NV_compute_program5
7857
 
7858
#endif /* GL_NV_compute_program5 */
7859
 
667 khor 7860
#ifdef GL_NV_conditional_render
7861
 
7862
static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT)
7863
{
7864
  GLboolean r = GL_FALSE;
7865
 
7866
  r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r;
7867
  r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r;
7868
 
7869
  return r;
7870
}
7871
 
7872
#endif /* GL_NV_conditional_render */
7873
 
7874
#ifdef GL_NV_copy_depth_to_color
7875
 
7876
#endif /* GL_NV_copy_depth_to_color */
7877
 
7878
#ifdef GL_NV_copy_image
7879
 
7880
static GLboolean _glewInit_GL_NV_copy_image (GLEW_CONTEXT_ARG_DEF_INIT)
7881
{
7882
  GLboolean r = GL_FALSE;
7883
 
7884
  r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r;
7885
 
7886
  return r;
7887
}
7888
 
7889
#endif /* GL_NV_copy_image */
7890
 
677 janba 7891
#ifdef GL_NV_deep_texture3D
7892
 
7893
#endif /* GL_NV_deep_texture3D */
7894
 
667 khor 7895
#ifdef GL_NV_depth_buffer_float
7896
 
7897
static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
7898
{
7899
  GLboolean r = GL_FALSE;
7900
 
7901
  r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r;
7902
  r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r;
7903
  r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r;
7904
 
7905
  return r;
7906
}
7907
 
7908
#endif /* GL_NV_depth_buffer_float */
7909
 
7910
#ifdef GL_NV_depth_clamp
7911
 
7912
#endif /* GL_NV_depth_clamp */
7913
 
7914
#ifdef GL_NV_depth_range_unclamped
7915
 
7916
#endif /* GL_NV_depth_range_unclamped */
7917
 
677 janba 7918
#ifdef GL_NV_draw_texture
7919
 
7920
static GLboolean _glewInit_GL_NV_draw_texture (GLEW_CONTEXT_ARG_DEF_INIT)
7921
{
7922
  GLboolean r = GL_FALSE;
7923
 
7924
  r = ((glDrawTextureNV = (PFNGLDRAWTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glDrawTextureNV")) == NULL) || r;
7925
 
7926
  return r;
7927
}
7928
 
7929
#endif /* GL_NV_draw_texture */
7930
 
667 khor 7931
#ifdef GL_NV_evaluators
7932
 
7933
static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
7934
{
7935
  GLboolean r = GL_FALSE;
7936
 
7937
  r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;
7938
  r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;
7939
  r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;
7940
  r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;
7941
  r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;
7942
  r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;
7943
  r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;
7944
  r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;
7945
  r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;
7946
 
7947
  return r;
7948
}
7949
 
7950
#endif /* GL_NV_evaluators */
7951
 
7952
#ifdef GL_NV_explicit_multisample
7953
 
7954
static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
7955
{
7956
  GLboolean r = GL_FALSE;
7957
 
7958
  r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r;
7959
  r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r;
7960
  r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r;
7961
 
7962
  return r;
7963
}
7964
 
7965
#endif /* GL_NV_explicit_multisample */
7966
 
7967
#ifdef GL_NV_fence
7968
 
7969
static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT)
7970
{
7971
  GLboolean r = GL_FALSE;
7972
 
7973
  r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;
7974
  r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;
7975
  r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;
7976
  r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;
7977
  r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;
7978
  r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;
7979
  r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;
7980
 
7981
  return r;
7982
}
7983
 
7984
#endif /* GL_NV_fence */
7985
 
7986
#ifdef GL_NV_float_buffer
7987
 
7988
#endif /* GL_NV_float_buffer */
7989
 
7990
#ifdef GL_NV_fog_distance
7991
 
7992
#endif /* GL_NV_fog_distance */
7993
 
7994
#ifdef GL_NV_fragment_program
7995
 
7996
static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)
7997
{
7998
  GLboolean r = GL_FALSE;
7999
 
8000
  r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;
8001
  r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;
8002
  r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;
8003
  r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;
8004
  r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;
8005
  r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;
8006
 
8007
  return r;
8008
}
8009
 
8010
#endif /* GL_NV_fragment_program */
8011
 
8012
#ifdef GL_NV_fragment_program2
8013
 
8014
#endif /* GL_NV_fragment_program2 */
8015
 
8016
#ifdef GL_NV_fragment_program4
8017
 
8018
#endif /* GL_NV_fragment_program4 */
8019
 
8020
#ifdef GL_NV_fragment_program_option
8021
 
8022
#endif /* GL_NV_fragment_program_option */
8023
 
8024
#ifdef GL_NV_framebuffer_multisample_coverage
8025
 
8026
static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT)
8027
{
8028
  GLboolean r = GL_FALSE;
8029
 
8030
  r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r;
8031
 
8032
  return r;
8033
}
8034
 
8035
#endif /* GL_NV_framebuffer_multisample_coverage */
8036
 
8037
#ifdef GL_NV_geometry_program4
8038
 
8039
static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
8040
{
8041
  GLboolean r = GL_FALSE;
8042
 
8043
  r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r;
8044
 
8045
  return r;
8046
}
8047
 
8048
#endif /* GL_NV_geometry_program4 */
8049
 
8050
#ifdef GL_NV_geometry_shader4
8051
 
8052
#endif /* GL_NV_geometry_shader4 */
8053
 
8054
#ifdef GL_NV_gpu_program4
8055
 
8056
static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
8057
{
8058
  GLboolean r = GL_FALSE;
8059
 
8060
  r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r;
8061
  r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r;
8062
  r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r;
8063
  r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r;
8064
  r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r;
8065
  r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r;
8066
  r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r;
8067
  r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r;
8068
  r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r;
8069
  r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r;
8070
  r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r;
8071
  r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r;
8072
 
8073
  return r;
8074
}
8075
 
8076
#endif /* GL_NV_gpu_program4 */
8077
 
8078
#ifdef GL_NV_gpu_program5
8079
 
8080
#endif /* GL_NV_gpu_program5 */
8081
 
677 janba 8082
#ifdef GL_NV_gpu_program5_mem_extended
8083
 
8084
#endif /* GL_NV_gpu_program5_mem_extended */
8085
 
667 khor 8086
#ifdef GL_NV_gpu_program_fp64
8087
 
8088
#endif /* GL_NV_gpu_program_fp64 */
8089
 
8090
#ifdef GL_NV_gpu_shader5
8091
 
8092
static GLboolean _glewInit_GL_NV_gpu_shader5 (GLEW_CONTEXT_ARG_DEF_INIT)
8093
{
8094
  GLboolean r = GL_FALSE;
8095
 
8096
  r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r;
8097
  r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r;
8098
  r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r;
8099
  r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r;
8100
  r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r;
8101
  r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r;
8102
  r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r;
8103
  r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r;
8104
  r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r;
8105
  r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r;
8106
  r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r;
8107
  r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r;
8108
  r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r;
8109
  r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r;
8110
  r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r;
8111
  r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r;
8112
  r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r;
8113
  r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r;
8114
  r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r;
8115
  r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r;
8116
  r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r;
8117
  r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r;
8118
  r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r;
8119
  r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r;
8120
  r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r;
8121
  r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r;
8122
  r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r;
8123
  r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r;
8124
  r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r;
8125
  r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r;
8126
  r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r;
8127
  r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r;
8128
  r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r;
8129
  r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r;
8130
 
8131
  return r;
8132
}
8133
 
8134
#endif /* GL_NV_gpu_shader5 */
8135
 
8136
#ifdef GL_NV_half_float
8137
 
8138
static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)
8139
{
8140
  GLboolean r = GL_FALSE;
8141
 
8142
  r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;
8143
  r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;
8144
  r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;
8145
  r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;
8146
  r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;
8147
  r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;
8148
  r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;
8149
  r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;
8150
  r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;
8151
  r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;
8152
  r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;
8153
  r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;
8154
  r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;
8155
  r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;
8156
  r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;
8157
  r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;
8158
  r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;
8159
  r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;
8160
  r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;
8161
  r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;
8162
  r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;
8163
  r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;
8164
  r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;
8165
  r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;
8166
  r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;
8167
  r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;
8168
  r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;
8169
  r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;
8170
  r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;
8171
  r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;
8172
  r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;
8173
  r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;
8174
  r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;
8175
  r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;
8176
  r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;
8177
  r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;
8178
  r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;
8179
  r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;
8180
  r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;
8181
  r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;
8182
  r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;
8183
  r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;
8184
  r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;
8185
  r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;
8186
  r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;
8187
  r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;
8188
 
8189
  return r;
8190
}
8191
 
8192
#endif /* GL_NV_half_float */
8193
 
8194
#ifdef GL_NV_light_max_exponent
8195
 
8196
#endif /* GL_NV_light_max_exponent */
8197
 
8198
#ifdef GL_NV_multisample_coverage
8199
 
8200
#endif /* GL_NV_multisample_coverage */
8201
 
8202
#ifdef GL_NV_multisample_filter_hint
8203
 
8204
#endif /* GL_NV_multisample_filter_hint */
8205
 
8206
#ifdef GL_NV_occlusion_query
8207
 
8208
static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
8209
{
8210
  GLboolean r = GL_FALSE;
8211
 
8212
  r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;
8213
  r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;
8214
  r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;
8215
  r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;
8216
  r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;
8217
  r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;
8218
  r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;
8219
 
8220
  return r;
8221
}
8222
 
8223
#endif /* GL_NV_occlusion_query */
8224
 
8225
#ifdef GL_NV_packed_depth_stencil
8226
 
8227
#endif /* GL_NV_packed_depth_stencil */
8228
 
8229
#ifdef GL_NV_parameter_buffer_object
8230
 
8231
static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
8232
{
8233
  GLboolean r = GL_FALSE;
8234
 
8235
  r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r;
8236
  r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r;
8237
  r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r;
8238
 
8239
  return r;
8240
}
8241
 
8242
#endif /* GL_NV_parameter_buffer_object */
8243
 
8244
#ifdef GL_NV_parameter_buffer_object2
8245
 
8246
#endif /* GL_NV_parameter_buffer_object2 */
8247
 
8248
#ifdef GL_NV_path_rendering
8249
 
8250
static GLboolean _glewInit_GL_NV_path_rendering (GLEW_CONTEXT_ARG_DEF_INIT)
8251
{
8252
  GLboolean r = GL_FALSE;
8253
 
8254
  r = ((glCopyPathNV = (PFNGLCOPYPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCopyPathNV")) == NULL) || r;
8255
  r = ((glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathInstancedNV")) == NULL) || r;
8256
  r = ((glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathNV")) == NULL) || r;
8257
  r = ((glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathInstancedNV")) == NULL) || r;
8258
  r = ((glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathNV")) == NULL) || r;
8259
  r = ((glDeletePathsNV = (PFNGLDELETEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glDeletePathsNV")) == NULL) || r;
8260
  r = ((glGenPathsNV = (PFNGLGENPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glGenPathsNV")) == NULL) || r;
8261
  r = ((glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenfvNV")) == NULL) || r;
8262
  r = ((glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenivNV")) == NULL) || r;
8263
  r = ((glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCommandsNV")) == NULL) || r;
8264
  r = ((glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCoordsNV")) == NULL) || r;
8265
  r = ((glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathDashArrayNV")) == NULL) || r;
8266
  r = ((glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathLengthNV")) == NULL) || r;
8267
  r = ((glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricRangeNV")) == NULL) || r;
8268
  r = ((glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricsNV")) == NULL) || r;
8269
  r = ((glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterfvNV")) == NULL) || r;
8270
  r = ((glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterivNV")) == NULL) || r;
8271
  r = ((glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathSpacingNV")) == NULL) || r;
8272
  r = ((glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenfvNV")) == NULL) || r;
8273
  r = ((glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenivNV")) == NULL) || r;
8274
  r = ((glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glInterpolatePathsNV")) == NULL) || r;
8275
  r = ((glIsPathNV = (PFNGLISPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPathNV")) == NULL) || r;
8276
  r = ((glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInFillPathNV")) == NULL) || r;
8277
  r = ((glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInStrokePathNV")) == NULL) || r;
8278
  r = ((glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathColorGenNV")) == NULL) || r;
8279
  r = ((glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCommandsNV")) == NULL) || r;
8280
  r = ((glPathCoordsNV = (PFNGLPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoordsNV")) == NULL) || r;
8281
  r = ((glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoverDepthFuncNV")) == NULL) || r;
8282
  r = ((glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathDashArrayNV")) == NULL) || r;
8283
  r = ((glPathFogGenNV = (PFNGLPATHFOGGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathFogGenNV")) == NULL) || r;
8284
  r = ((glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphRangeNV")) == NULL) || r;
8285
  r = ((glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphsNV")) == NULL) || r;
8286
  r = ((glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfNV")) == NULL) || r;
8287
  r = ((glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfvNV")) == NULL) || r;
8288
  r = ((glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPathParameteriNV")) == NULL) || r;
8289
  r = ((glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterivNV")) == NULL) || r;
8290
  r = ((glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilDepthOffsetNV")) == NULL) || r;
8291
  r = ((glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilFuncNV")) == NULL) || r;
8292
  r = ((glPathStringNV = (PFNGLPATHSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glPathStringNV")) == NULL) || r;
8293
  r = ((glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCommandsNV")) == NULL) || r;
8294
  r = ((glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCoordsNV")) == NULL) || r;
8295
  r = ((glPathTexGenNV = (PFNGLPATHTEXGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathTexGenNV")) == NULL) || r;
8296
  r = ((glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC)glewGetProcAddress((const GLubyte*)"glPointAlongPathNV")) == NULL) || r;
8297
  r = ((glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathInstancedNV")) == NULL) || r;
8298
  r = ((glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathNV")) == NULL) || r;
8299
  r = ((glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathInstancedNV")) == NULL) || r;
8300
  r = ((glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathNV")) == NULL) || r;
8301
  r = ((glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC)glewGetProcAddress((const GLubyte*)"glTransformPathNV")) == NULL) || r;
8302
  r = ((glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glWeightPathsNV")) == NULL) || r;
8303
 
8304
  return r;
8305
}
8306
 
8307
#endif /* GL_NV_path_rendering */
8308
 
8309
#ifdef GL_NV_pixel_data_range
8310
 
8311
static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)
8312
{
8313
  GLboolean r = GL_FALSE;
8314
 
8315
  r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;
8316
  r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;
8317
 
8318
  return r;
8319
}
8320
 
8321
#endif /* GL_NV_pixel_data_range */
8322
 
8323
#ifdef GL_NV_point_sprite
8324
 
8325
static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT)
8326
{
8327
  GLboolean r = GL_FALSE;
8328
 
8329
  r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;
8330
  r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;
8331
 
8332
  return r;
8333
}
8334
 
8335
#endif /* GL_NV_point_sprite */
8336
 
8337
#ifdef GL_NV_present_video
8338
 
8339
static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT)
8340
{
8341
  GLboolean r = GL_FALSE;
8342
 
8343
  r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r;
8344
  r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r;
8345
  r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r;
8346
  r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r;
8347
  r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r;
8348
  r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r;
8349
 
8350
  return r;
8351
}
8352
 
8353
#endif /* GL_NV_present_video */
8354
 
8355
#ifdef GL_NV_primitive_restart
8356
 
8357
static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT)
8358
{
8359
  GLboolean r = GL_FALSE;
8360
 
8361
  r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;
8362
  r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;
8363
 
8364
  return r;
8365
}
8366
 
8367
#endif /* GL_NV_primitive_restart */
8368
 
8369
#ifdef GL_NV_register_combiners
8370
 
8371
static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)
8372
{
8373
  GLboolean r = GL_FALSE;
8374
 
8375
  r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;
8376
  r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;
8377
  r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;
8378
  r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;
8379
  r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;
8380
  r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;
8381
  r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;
8382
  r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;
8383
  r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;
8384
  r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;
8385
  r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;
8386
  r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;
8387
  r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;
8388
 
8389
  return r;
8390
}
8391
 
8392
#endif /* GL_NV_register_combiners */
8393
 
8394
#ifdef GL_NV_register_combiners2
8395
 
8396
static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)
8397
{
8398
  GLboolean r = GL_FALSE;
8399
 
8400
  r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;
8401
  r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;
8402
 
8403
  return r;
8404
}
8405
 
8406
#endif /* GL_NV_register_combiners2 */
8407
 
677 janba 8408
#ifdef GL_NV_shader_atomic_counters
8409
 
8410
#endif /* GL_NV_shader_atomic_counters */
8411
 
667 khor 8412
#ifdef GL_NV_shader_atomic_float
8413
 
8414
#endif /* GL_NV_shader_atomic_float */
8415
 
8416
#ifdef GL_NV_shader_buffer_load
8417
 
8418
static GLboolean _glewInit_GL_NV_shader_buffer_load (GLEW_CONTEXT_ARG_DEF_INIT)
8419
{
8420
  GLboolean r = GL_FALSE;
8421
 
8422
  r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r;
8423
  r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r;
8424
  r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r;
8425
  r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r;
8426
  r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r;
8427
  r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r;
8428
  r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r;
8429
  r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r;
8430
  r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r;
8431
  r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r;
8432
  r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r;
8433
  r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r;
8434
  r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r;
8435
 
8436
  return r;
8437
}
8438
 
8439
#endif /* GL_NV_shader_buffer_load */
8440
 
677 janba 8441
#ifdef GL_NV_shader_storage_buffer_object
8442
 
8443
#endif /* GL_NV_shader_storage_buffer_object */
8444
 
667 khor 8445
#ifdef GL_NV_tessellation_program5
8446
 
8447
#endif /* GL_NV_tessellation_program5 */
8448
 
8449
#ifdef GL_NV_texgen_emboss
8450
 
8451
#endif /* GL_NV_texgen_emboss */
8452
 
8453
#ifdef GL_NV_texgen_reflection
8454
 
8455
#endif /* GL_NV_texgen_reflection */
8456
 
8457
#ifdef GL_NV_texture_barrier
8458
 
8459
static GLboolean _glewInit_GL_NV_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT)
8460
{
8461
  GLboolean r = GL_FALSE;
8462
 
8463
  r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r;
8464
 
8465
  return r;
8466
}
8467
 
8468
#endif /* GL_NV_texture_barrier */
8469
 
8470
#ifdef GL_NV_texture_compression_vtc
8471
 
8472
#endif /* GL_NV_texture_compression_vtc */
8473
 
8474
#ifdef GL_NV_texture_env_combine4
8475
 
8476
#endif /* GL_NV_texture_env_combine4 */
8477
 
8478
#ifdef GL_NV_texture_expand_normal
8479
 
8480
#endif /* GL_NV_texture_expand_normal */
8481
 
8482
#ifdef GL_NV_texture_multisample
8483
 
8484
static GLboolean _glewInit_GL_NV_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
8485
{
8486
  GLboolean r = GL_FALSE;
8487
 
8488
  r = ((glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisampleCoverageNV")) == NULL) || r;
8489
  r = ((glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisampleCoverageNV")) == NULL) || r;
8490
  r = ((glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleCoverageNV")) == NULL) || r;
8491
  r = ((glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleNV")) == NULL) || r;
8492
  r = ((glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleCoverageNV")) == NULL) || r;
8493
  r = ((glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleNV")) == NULL) || r;
8494
 
8495
  return r;
8496
}
8497
 
8498
#endif /* GL_NV_texture_multisample */
8499
 
8500
#ifdef GL_NV_texture_rectangle
8501
 
8502
#endif /* GL_NV_texture_rectangle */
8503
 
8504
#ifdef GL_NV_texture_shader
8505
 
8506
#endif /* GL_NV_texture_shader */
8507
 
8508
#ifdef GL_NV_texture_shader2
8509
 
8510
#endif /* GL_NV_texture_shader2 */
8511
 
8512
#ifdef GL_NV_texture_shader3
8513
 
8514
#endif /* GL_NV_texture_shader3 */
8515
 
8516
#ifdef GL_NV_transform_feedback
8517
 
8518
static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
8519
{
8520
  GLboolean r = GL_FALSE;
8521
 
8522
  r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r;
8523
  r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r;
8524
  r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r;
8525
  r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r;
8526
  r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r;
8527
  r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r;
8528
  r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r;
8529
  r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r;
8530
  r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r;
8531
  r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r;
8532
  r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r;
8533
 
8534
  return r;
8535
}
8536
 
8537
#endif /* GL_NV_transform_feedback */
8538
 
8539
#ifdef GL_NV_transform_feedback2
8540
 
8541
static GLboolean _glewInit_GL_NV_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
8542
{
8543
  GLboolean r = GL_FALSE;
8544
 
8545
  r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r;
8546
  r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r;
8547
  r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r;
8548
  r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r;
8549
  r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r;
8550
  r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r;
8551
  r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r;
8552
 
8553
  return r;
8554
}
8555
 
8556
#endif /* GL_NV_transform_feedback2 */
8557
 
8558
#ifdef GL_NV_vdpau_interop
8559
 
8560
static GLboolean _glewInit_GL_NV_vdpau_interop (GLEW_CONTEXT_ARG_DEF_INIT)
8561
{
8562
  GLboolean r = GL_FALSE;
8563
 
8564
  r = ((glVDPAUFiniNV = (PFNGLVDPAUFININVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUFiniNV")) == NULL) || r;
8565
  r = ((glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUGetSurfaceivNV")) == NULL) || r;
8566
  r = ((glVDPAUInitNV = (PFNGLVDPAUINITNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUInitNV")) == NULL) || r;
8567
  r = ((glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUIsSurfaceNV")) == NULL) || r;
8568
  r = ((glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUMapSurfacesNV")) == NULL) || r;
8569
  r = ((glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterOutputSurfaceNV")) == NULL) || r;
8570
  r = ((glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterVideoSurfaceNV")) == NULL) || r;
8571
  r = ((glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUSurfaceAccessNV")) == NULL) || r;
8572
  r = ((glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnmapSurfacesNV")) == NULL) || r;
8573
  r = ((glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnregisterSurfaceNV")) == NULL) || r;
8574
 
8575
  return r;
8576
}
8577
 
8578
#endif /* GL_NV_vdpau_interop */
8579
 
8580
#ifdef GL_NV_vertex_array_range
8581
 
8582
static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
8583
{
8584
  GLboolean r = GL_FALSE;
8585
 
8586
  r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;
8587
  r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;
8588
 
8589
  return r;
8590
}
8591
 
8592
#endif /* GL_NV_vertex_array_range */
8593
 
8594
#ifdef GL_NV_vertex_array_range2
8595
 
8596
#endif /* GL_NV_vertex_array_range2 */
8597
 
8598
#ifdef GL_NV_vertex_attrib_integer_64bit
8599
 
8600
static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
8601
{
8602
  GLboolean r = GL_FALSE;
8603
 
8604
  r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r;
8605
  r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r;
8606
  r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r;
8607
  r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r;
8608
  r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r;
8609
  r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r;
8610
  r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r;
8611
  r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r;
8612
  r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r;
8613
  r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r;
8614
  r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r;
8615
  r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r;
8616
  r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r;
8617
  r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r;
8618
  r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r;
8619
  r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r;
8620
  r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r;
8621
  r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r;
8622
  r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r;
8623
 
8624
  return r;
8625
}
8626
 
8627
#endif /* GL_NV_vertex_attrib_integer_64bit */
8628
 
8629
#ifdef GL_NV_vertex_buffer_unified_memory
8630
 
8631
static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (GLEW_CONTEXT_ARG_DEF_INIT)
8632
{
8633
  GLboolean r = GL_FALSE;
8634
 
8635
  r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r;
8636
  r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r;
8637
  r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r;
8638
  r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r;
8639
  r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r;
8640
  r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r;
8641
  r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r;
8642
  r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r;
8643
  r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r;
8644
  r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r;
8645
  r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r;
8646
  r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r;
8647
 
8648
  return r;
8649
}
8650
 
8651
#endif /* GL_NV_vertex_buffer_unified_memory */
8652
 
8653
#ifdef GL_NV_vertex_program
8654
 
8655
static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
8656
{
8657
  GLboolean r = GL_FALSE;
8658
 
8659
  r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;
8660
  r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;
8661
  r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;
8662
  r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;
8663
  r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;
8664
  r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;
8665
  r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;
8666
  r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;
8667
  r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;
8668
  r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;
8669
  r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;
8670
  r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;
8671
  r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;
8672
  r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;
8673
  r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;
8674
  r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;
8675
  r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;
8676
  r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;
8677
  r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;
8678
  r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;
8679
  r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;
8680
  r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;
8681
  r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;
8682
  r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;
8683
  r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;
8684
  r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;
8685
  r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;
8686
  r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;
8687
  r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;
8688
  r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;
8689
  r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;
8690
  r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;
8691
  r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;
8692
  r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;
8693
  r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;
8694
  r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;
8695
  r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;
8696
  r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;
8697
  r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;
8698
  r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;
8699
  r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;
8700
  r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;
8701
  r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;
8702
  r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;
8703
  r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;
8704
  r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;
8705
  r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;
8706
  r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;
8707
  r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;
8708
  r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;
8709
  r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;
8710
  r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;
8711
  r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;
8712
  r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;
8713
  r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;
8714
  r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;
8715
  r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;
8716
  r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;
8717
  r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;
8718
  r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;
8719
  r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;
8720
  r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;
8721
  r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;
8722
  r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;
8723
 
8724
  return r;
8725
}
8726
 
8727
#endif /* GL_NV_vertex_program */
8728
 
8729
#ifdef GL_NV_vertex_program1_1
8730
 
8731
#endif /* GL_NV_vertex_program1_1 */
8732
 
8733
#ifdef GL_NV_vertex_program2
8734
 
8735
#endif /* GL_NV_vertex_program2 */
8736
 
8737
#ifdef GL_NV_vertex_program2_option
8738
 
8739
#endif /* GL_NV_vertex_program2_option */
8740
 
8741
#ifdef GL_NV_vertex_program3
8742
 
8743
#endif /* GL_NV_vertex_program3 */
8744
 
8745
#ifdef GL_NV_vertex_program4
8746
 
8747
#endif /* GL_NV_vertex_program4 */
8748
 
8749
#ifdef GL_NV_video_capture
8750
 
8751
static GLboolean _glewInit_GL_NV_video_capture (GLEW_CONTEXT_ARG_DEF_INIT)
8752
{
8753
  GLboolean r = GL_FALSE;
8754
 
8755
  r = ((glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glBeginVideoCaptureNV")) == NULL) || r;
8756
  r = ((glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamBufferNV")) == NULL) || r;
8757
  r = ((glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamTextureNV")) == NULL) || r;
8758
  r = ((glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glEndVideoCaptureNV")) == NULL) || r;
8759
  r = ((glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamdvNV")) == NULL) || r;
8760
  r = ((glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamfvNV")) == NULL) || r;
8761
  r = ((glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamivNV")) == NULL) || r;
8762
  r = ((glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureivNV")) == NULL) || r;
8763
  r = ((glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureNV")) == NULL) || r;
8764
  r = ((glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterdvNV")) == NULL) || r;
8765
  r = ((glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterfvNV")) == NULL) || r;
8766
  r = ((glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterivNV")) == NULL) || r;
8767
 
8768
  return r;
8769
}
8770
 
8771
#endif /* GL_NV_video_capture */
8772
 
8773
#ifdef GL_OES_byte_coordinates
8774
 
8775
#endif /* GL_OES_byte_coordinates */
8776
 
8777
#ifdef GL_OES_compressed_paletted_texture
8778
 
8779
#endif /* GL_OES_compressed_paletted_texture */
8780
 
8781
#ifdef GL_OES_read_format
8782
 
8783
#endif /* GL_OES_read_format */
8784
 
8785
#ifdef GL_OES_single_precision
8786
 
8787
static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT)
8788
{
8789
  GLboolean r = GL_FALSE;
8790
 
8791
  r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r;
8792
  r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r;
8793
  r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r;
8794
  r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r;
8795
  r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r;
8796
  r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r;
8797
 
8798
  return r;
8799
}
8800
 
8801
#endif /* GL_OES_single_precision */
8802
 
8803
#ifdef GL_OML_interlace
8804
 
8805
#endif /* GL_OML_interlace */
8806
 
8807
#ifdef GL_OML_resample
8808
 
8809
#endif /* GL_OML_resample */
8810
 
8811
#ifdef GL_OML_subsample
8812
 
8813
#endif /* GL_OML_subsample */
8814
 
8815
#ifdef GL_PGI_misc_hints
8816
 
8817
#endif /* GL_PGI_misc_hints */
8818
 
8819
#ifdef GL_PGI_vertex_hints
8820
 
8821
#endif /* GL_PGI_vertex_hints */
8822
 
677 janba 8823
#ifdef GL_REGAL_ES1_0_compatibility
8824
 
8825
static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (GLEW_CONTEXT_ARG_DEF_INIT)
8826
{
8827
  GLboolean r = GL_FALSE;
8828
 
8829
  r = ((glAlphaFuncx = (PFNGLALPHAFUNCXPROC)glewGetProcAddress((const GLubyte*)"glAlphaFuncx")) == NULL) || r;
8830
  r = ((glClearColorx = (PFNGLCLEARCOLORXPROC)glewGetProcAddress((const GLubyte*)"glClearColorx")) == NULL) || r;
8831
  r = ((glClearDepthx = (PFNGLCLEARDEPTHXPROC)glewGetProcAddress((const GLubyte*)"glClearDepthx")) == NULL) || r;
8832
  r = ((glColor4x = (PFNGLCOLOR4XPROC)glewGetProcAddress((const GLubyte*)"glColor4x")) == NULL) || r;
8833
  r = ((glDepthRangex = (PFNGLDEPTHRANGEXPROC)glewGetProcAddress((const GLubyte*)"glDepthRangex")) == NULL) || r;
8834
  r = ((glFogx = (PFNGLFOGXPROC)glewGetProcAddress((const GLubyte*)"glFogx")) == NULL) || r;
8835
  r = ((glFogxv = (PFNGLFOGXVPROC)glewGetProcAddress((const GLubyte*)"glFogxv")) == NULL) || r;
8836
  r = ((glFrustumf = (PFNGLFRUSTUMFPROC)glewGetProcAddress((const GLubyte*)"glFrustumf")) == NULL) || r;
8837
  r = ((glFrustumx = (PFNGLFRUSTUMXPROC)glewGetProcAddress((const GLubyte*)"glFrustumx")) == NULL) || r;
8838
  r = ((glLightModelx = (PFNGLLIGHTMODELXPROC)glewGetProcAddress((const GLubyte*)"glLightModelx")) == NULL) || r;
8839
  r = ((glLightModelxv = (PFNGLLIGHTMODELXVPROC)glewGetProcAddress((const GLubyte*)"glLightModelxv")) == NULL) || r;
8840
  r = ((glLightx = (PFNGLLIGHTXPROC)glewGetProcAddress((const GLubyte*)"glLightx")) == NULL) || r;
8841
  r = ((glLightxv = (PFNGLLIGHTXVPROC)glewGetProcAddress((const GLubyte*)"glLightxv")) == NULL) || r;
8842
  r = ((glLineWidthx = (PFNGLLINEWIDTHXPROC)glewGetProcAddress((const GLubyte*)"glLineWidthx")) == NULL) || r;
8843
  r = ((glLoadMatrixx = (PFNGLLOADMATRIXXPROC)glewGetProcAddress((const GLubyte*)"glLoadMatrixx")) == NULL) || r;
8844
  r = ((glMaterialx = (PFNGLMATERIALXPROC)glewGetProcAddress((const GLubyte*)"glMaterialx")) == NULL) || r;
8845
  r = ((glMaterialxv = (PFNGLMATERIALXVPROC)glewGetProcAddress((const GLubyte*)"glMaterialxv")) == NULL) || r;
8846
  r = ((glMultMatrixx = (PFNGLMULTMATRIXXPROC)glewGetProcAddress((const GLubyte*)"glMultMatrixx")) == NULL) || r;
8847
  r = ((glMultiTexCoord4x = (PFNGLMULTITEXCOORD4XPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4x")) == NULL) || r;
8848
  r = ((glNormal3x = (PFNGLNORMAL3XPROC)glewGetProcAddress((const GLubyte*)"glNormal3x")) == NULL) || r;
8849
  r = ((glOrthof = (PFNGLORTHOFPROC)glewGetProcAddress((const GLubyte*)"glOrthof")) == NULL) || r;
8850
  r = ((glOrthox = (PFNGLORTHOXPROC)glewGetProcAddress((const GLubyte*)"glOrthox")) == NULL) || r;
8851
  r = ((glPointSizex = (PFNGLPOINTSIZEXPROC)glewGetProcAddress((const GLubyte*)"glPointSizex")) == NULL) || r;
8852
  r = ((glPolygonOffsetx = (PFNGLPOLYGONOFFSETXPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetx")) == NULL) || r;
8853
  r = ((glRotatex = (PFNGLROTATEXPROC)glewGetProcAddress((const GLubyte*)"glRotatex")) == NULL) || r;
8854
  r = ((glSampleCoveragex = (PFNGLSAMPLECOVERAGEXPROC)glewGetProcAddress((const GLubyte*)"glSampleCoveragex")) == NULL) || r;
8855
  r = ((glScalex = (PFNGLSCALEXPROC)glewGetProcAddress((const GLubyte*)"glScalex")) == NULL) || r;
8856
  r = ((glTexEnvx = (PFNGLTEXENVXPROC)glewGetProcAddress((const GLubyte*)"glTexEnvx")) == NULL) || r;
8857
  r = ((glTexEnvxv = (PFNGLTEXENVXVPROC)glewGetProcAddress((const GLubyte*)"glTexEnvxv")) == NULL) || r;
8858
  r = ((glTexParameterx = (PFNGLTEXPARAMETERXPROC)glewGetProcAddress((const GLubyte*)"glTexParameterx")) == NULL) || r;
8859
  r = ((glTranslatex = (PFNGLTRANSLATEXPROC)glewGetProcAddress((const GLubyte*)"glTranslatex")) == NULL) || r;
8860
 
8861
  return r;
8862
}
8863
 
8864
#endif /* GL_REGAL_ES1_0_compatibility */
8865
 
8866
#ifdef GL_REGAL_ES1_1_compatibility
8867
 
8868
static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (GLEW_CONTEXT_ARG_DEF_INIT)
8869
{
8870
  GLboolean r = GL_FALSE;
8871
 
8872
  r = ((glClipPlanef = (PFNGLCLIPPLANEFPROC)glewGetProcAddress((const GLubyte*)"glClipPlanef")) == NULL) || r;
8873
  r = ((glClipPlanex = (PFNGLCLIPPLANEXPROC)glewGetProcAddress((const GLubyte*)"glClipPlanex")) == NULL) || r;
8874
  r = ((glGetClipPlanef = (PFNGLGETCLIPPLANEFPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanef")) == NULL) || r;
8875
  r = ((glGetClipPlanex = (PFNGLGETCLIPPLANEXPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanex")) == NULL) || r;
8876
  r = ((glGetFixedv = (PFNGLGETFIXEDVPROC)glewGetProcAddress((const GLubyte*)"glGetFixedv")) == NULL) || r;
8877
  r = ((glGetLightxv = (PFNGLGETLIGHTXVPROC)glewGetProcAddress((const GLubyte*)"glGetLightxv")) == NULL) || r;
8878
  r = ((glGetMaterialxv = (PFNGLGETMATERIALXVPROC)glewGetProcAddress((const GLubyte*)"glGetMaterialxv")) == NULL) || r;
8879
  r = ((glGetTexEnvxv = (PFNGLGETTEXENVXVPROC)glewGetProcAddress((const GLubyte*)"glGetTexEnvxv")) == NULL) || r;
8880
  r = ((glGetTexParameterxv = (PFNGLGETTEXPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterxv")) == NULL) || r;
8881
  r = ((glPointParameterx = (PFNGLPOINTPARAMETERXPROC)glewGetProcAddress((const GLubyte*)"glPointParameterx")) == NULL) || r;
8882
  r = ((glPointParameterxv = (PFNGLPOINTPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterxv")) == NULL) || r;
8883
  r = ((glPointSizePointerOES = (PFNGLPOINTSIZEPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glPointSizePointerOES")) == NULL) || r;
8884
  r = ((glTexParameterxv = (PFNGLTEXPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterxv")) == NULL) || r;
8885
 
8886
  return r;
8887
}
8888
 
8889
#endif /* GL_REGAL_ES1_1_compatibility */
8890
 
8891
#ifdef GL_REGAL_enable
8892
 
8893
#endif /* GL_REGAL_enable */
8894
 
667 khor 8895
#ifdef GL_REGAL_error_string
8896
 
8897
static GLboolean _glewInit_GL_REGAL_error_string (GLEW_CONTEXT_ARG_DEF_INIT)
8898
{
8899
  GLboolean r = GL_FALSE;
8900
 
8901
  r = ((glErrorStringREGAL = (PFNGLERRORSTRINGREGALPROC)glewGetProcAddress((const GLubyte*)"glErrorStringREGAL")) == NULL) || r;
8902
 
8903
  return r;
8904
}
8905
 
8906
#endif /* GL_REGAL_error_string */
8907
 
8908
#ifdef GL_REGAL_extension_query
8909
 
8910
static GLboolean _glewInit_GL_REGAL_extension_query (GLEW_CONTEXT_ARG_DEF_INIT)
8911
{
8912
  GLboolean r = GL_FALSE;
8913
 
8914
  r = ((glGetExtensionREGAL = (PFNGLGETEXTENSIONREGALPROC)glewGetProcAddress((const GLubyte*)"glGetExtensionREGAL")) == NULL) || r;
8915
  r = ((glIsSupportedREGAL = (PFNGLISSUPPORTEDREGALPROC)glewGetProcAddress((const GLubyte*)"glIsSupportedREGAL")) == NULL) || r;
8916
 
8917
  return r;
8918
}
8919
 
8920
#endif /* GL_REGAL_extension_query */
8921
 
8922
#ifdef GL_REGAL_log
8923
 
677 janba 8924
static GLboolean _glewInit_GL_REGAL_log (GLEW_CONTEXT_ARG_DEF_INIT)
8925
{
8926
  GLboolean r = GL_FALSE;
8927
 
8928
  r = ((glLogMessageCallbackREGAL = (PFNGLLOGMESSAGECALLBACKREGALPROC)glewGetProcAddress((const GLubyte*)"glLogMessageCallbackREGAL")) == NULL) || r;
8929
 
8930
  return r;
8931
}
8932
 
667 khor 8933
#endif /* GL_REGAL_log */
8934
 
8935
#ifdef GL_REND_screen_coordinates
8936
 
8937
#endif /* GL_REND_screen_coordinates */
8938
 
8939
#ifdef GL_S3_s3tc
8940
 
8941
#endif /* GL_S3_s3tc */
8942
 
8943
#ifdef GL_SGIS_color_range
8944
 
8945
#endif /* GL_SGIS_color_range */
8946
 
8947
#ifdef GL_SGIS_detail_texture
8948
 
8949
static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT)
8950
{
8951
  GLboolean r = GL_FALSE;
8952
 
8953
  r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;
8954
  r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;
8955
 
8956
  return r;
8957
}
8958
 
8959
#endif /* GL_SGIS_detail_texture */
8960
 
8961
#ifdef GL_SGIS_fog_function
8962
 
8963
static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT)
8964
{
8965
  GLboolean r = GL_FALSE;
8966
 
8967
  r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;
8968
  r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;
8969
 
8970
  return r;
8971
}
8972
 
8973
#endif /* GL_SGIS_fog_function */
8974
 
8975
#ifdef GL_SGIS_generate_mipmap
8976
 
8977
#endif /* GL_SGIS_generate_mipmap */
8978
 
8979
#ifdef GL_SGIS_multisample
8980
 
8981
static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
8982
{
8983
  GLboolean r = GL_FALSE;
8984
 
8985
  r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;
8986
  r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;
8987
 
8988
  return r;
8989
}
8990
 
8991
#endif /* GL_SGIS_multisample */
8992
 
8993
#ifdef GL_SGIS_pixel_texture
8994
 
8995
#endif /* GL_SGIS_pixel_texture */
8996
 
8997
#ifdef GL_SGIS_point_line_texgen
8998
 
8999
#endif /* GL_SGIS_point_line_texgen */
9000
 
9001
#ifdef GL_SGIS_sharpen_texture
9002
 
9003
static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT)
9004
{
9005
  GLboolean r = GL_FALSE;
9006
 
9007
  r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;
9008
  r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;
9009
 
9010
  return r;
9011
}
9012
 
9013
#endif /* GL_SGIS_sharpen_texture */
9014
 
9015
#ifdef GL_SGIS_texture4D
9016
 
9017
static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT)
9018
{
9019
  GLboolean r = GL_FALSE;
9020
 
9021
  r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;
9022
  r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;
9023
 
9024
  return r;
9025
}
9026
 
9027
#endif /* GL_SGIS_texture4D */
9028
 
9029
#ifdef GL_SGIS_texture_border_clamp
9030
 
9031
#endif /* GL_SGIS_texture_border_clamp */
9032
 
9033
#ifdef GL_SGIS_texture_edge_clamp
9034
 
9035
#endif /* GL_SGIS_texture_edge_clamp */
9036
 
9037
#ifdef GL_SGIS_texture_filter4
9038
 
9039
static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT)
9040
{
9041
  GLboolean r = GL_FALSE;
9042
 
9043
  r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;
9044
  r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;
9045
 
9046
  return r;
9047
}
9048
 
9049
#endif /* GL_SGIS_texture_filter4 */
9050
 
9051
#ifdef GL_SGIS_texture_lod
9052
 
9053
#endif /* GL_SGIS_texture_lod */
9054
 
9055
#ifdef GL_SGIS_texture_select
9056
 
9057
#endif /* GL_SGIS_texture_select */
9058
 
9059
#ifdef GL_SGIX_async
9060
 
9061
static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT)
9062
{
9063
  GLboolean r = GL_FALSE;
9064
 
9065
  r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;
9066
  r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;
9067
  r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;
9068
  r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;
9069
  r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;
9070
  r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;
9071
 
9072
  return r;
9073
}
9074
 
9075
#endif /* GL_SGIX_async */
9076
 
9077
#ifdef GL_SGIX_async_histogram
9078
 
9079
#endif /* GL_SGIX_async_histogram */
9080
 
9081
#ifdef GL_SGIX_async_pixel
9082
 
9083
#endif /* GL_SGIX_async_pixel */
9084
 
9085
#ifdef GL_SGIX_blend_alpha_minmax
9086
 
9087
#endif /* GL_SGIX_blend_alpha_minmax */
9088
 
9089
#ifdef GL_SGIX_clipmap
9090
 
9091
#endif /* GL_SGIX_clipmap */
9092
 
9093
#ifdef GL_SGIX_convolution_accuracy
9094
 
9095
#endif /* GL_SGIX_convolution_accuracy */
9096
 
9097
#ifdef GL_SGIX_depth_texture
9098
 
9099
#endif /* GL_SGIX_depth_texture */
9100
 
9101
#ifdef GL_SGIX_flush_raster
9102
 
9103
static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT)
9104
{
9105
  GLboolean r = GL_FALSE;
9106
 
9107
  r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;
9108
 
9109
  return r;
9110
}
9111
 
9112
#endif /* GL_SGIX_flush_raster */
9113
 
9114
#ifdef GL_SGIX_fog_offset
9115
 
9116
#endif /* GL_SGIX_fog_offset */
9117
 
9118
#ifdef GL_SGIX_fog_texture
9119
 
9120
static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT)
9121
{
9122
  GLboolean r = GL_FALSE;
9123
 
9124
  r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;
9125
 
9126
  return r;
9127
}
9128
 
9129
#endif /* GL_SGIX_fog_texture */
9130
 
9131
#ifdef GL_SGIX_fragment_specular_lighting
9132
 
9133
static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT)
9134
{
9135
  GLboolean r = GL_FALSE;
9136
 
9137
  r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;
9138
  r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;
9139
  r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;
9140
  r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;
9141
  r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;
9142
  r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;
9143
  r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;
9144
  r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;
9145
  r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;
9146
  r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;
9147
  r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;
9148
  r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;
9149
  r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;
9150
  r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;
9151
  r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;
9152
  r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;
9153
  r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;
9154
 
9155
  return r;
9156
}
9157
 
9158
#endif /* GL_SGIX_fragment_specular_lighting */
9159
 
9160
#ifdef GL_SGIX_framezoom
9161
 
9162
static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT)
9163
{
9164
  GLboolean r = GL_FALSE;
9165
 
9166
  r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;
9167
 
9168
  return r;
9169
}
9170
 
9171
#endif /* GL_SGIX_framezoom */
9172
 
9173
#ifdef GL_SGIX_interlace
9174
 
9175
#endif /* GL_SGIX_interlace */
9176
 
9177
#ifdef GL_SGIX_ir_instrument1
9178
 
9179
#endif /* GL_SGIX_ir_instrument1 */
9180
 
9181
#ifdef GL_SGIX_list_priority
9182
 
9183
#endif /* GL_SGIX_list_priority */
9184
 
9185
#ifdef GL_SGIX_pixel_texture
9186
 
9187
static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT)
9188
{
9189
  GLboolean r = GL_FALSE;
9190
 
9191
  r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;
9192
 
9193
  return r;
9194
}
9195
 
9196
#endif /* GL_SGIX_pixel_texture */
9197
 
9198
#ifdef GL_SGIX_pixel_texture_bits
9199
 
9200
#endif /* GL_SGIX_pixel_texture_bits */
9201
 
9202
#ifdef GL_SGIX_reference_plane
9203
 
9204
static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT)
9205
{
9206
  GLboolean r = GL_FALSE;
9207
 
9208
  r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;
9209
 
9210
  return r;
9211
}
9212
 
9213
#endif /* GL_SGIX_reference_plane */
9214
 
9215
#ifdef GL_SGIX_resample
9216
 
9217
#endif /* GL_SGIX_resample */
9218
 
9219
#ifdef GL_SGIX_shadow
9220
 
9221
#endif /* GL_SGIX_shadow */
9222
 
9223
#ifdef GL_SGIX_shadow_ambient
9224
 
9225
#endif /* GL_SGIX_shadow_ambient */
9226
 
9227
#ifdef GL_SGIX_sprite
9228
 
9229
static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT)
9230
{
9231
  GLboolean r = GL_FALSE;
9232
 
9233
  r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;
9234
  r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;
9235
  r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;
9236
  r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;
9237
 
9238
  return r;
9239
}
9240
 
9241
#endif /* GL_SGIX_sprite */
9242
 
9243
#ifdef GL_SGIX_tag_sample_buffer
9244
 
9245
static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
9246
{
9247
  GLboolean r = GL_FALSE;
9248
 
9249
  r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;
9250
 
9251
  return r;
9252
}
9253
 
9254
#endif /* GL_SGIX_tag_sample_buffer */
9255
 
9256
#ifdef GL_SGIX_texture_add_env
9257
 
9258
#endif /* GL_SGIX_texture_add_env */
9259
 
9260
#ifdef GL_SGIX_texture_coordinate_clamp
9261
 
9262
#endif /* GL_SGIX_texture_coordinate_clamp */
9263
 
9264
#ifdef GL_SGIX_texture_lod_bias
9265
 
9266
#endif /* GL_SGIX_texture_lod_bias */
9267
 
9268
#ifdef GL_SGIX_texture_multi_buffer
9269
 
9270
#endif /* GL_SGIX_texture_multi_buffer */
9271
 
9272
#ifdef GL_SGIX_texture_range
9273
 
9274
#endif /* GL_SGIX_texture_range */
9275
 
9276
#ifdef GL_SGIX_texture_scale_bias
9277
 
9278
#endif /* GL_SGIX_texture_scale_bias */
9279
 
9280
#ifdef GL_SGIX_vertex_preclip
9281
 
9282
#endif /* GL_SGIX_vertex_preclip */
9283
 
9284
#ifdef GL_SGIX_vertex_preclip_hint
9285
 
9286
#endif /* GL_SGIX_vertex_preclip_hint */
9287
 
9288
#ifdef GL_SGIX_ycrcb
9289
 
9290
#endif /* GL_SGIX_ycrcb */
9291
 
9292
#ifdef GL_SGI_color_matrix
9293
 
9294
#endif /* GL_SGI_color_matrix */
9295
 
9296
#ifdef GL_SGI_color_table
9297
 
9298
static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT)
9299
{
9300
  GLboolean r = GL_FALSE;
9301
 
9302
  r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;
9303
  r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;
9304
  r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;
9305
  r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;
9306
  r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;
9307
  r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;
9308
  r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;
9309
 
9310
  return r;
9311
}
9312
 
9313
#endif /* GL_SGI_color_table */
9314
 
9315
#ifdef GL_SGI_texture_color_table
9316
 
9317
#endif /* GL_SGI_texture_color_table */
9318
 
9319
#ifdef GL_SUNX_constant_data
9320
 
9321
static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT)
9322
{
9323
  GLboolean r = GL_FALSE;
9324
 
9325
  r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;
9326
 
9327
  return r;
9328
}
9329
 
9330
#endif /* GL_SUNX_constant_data */
9331
 
9332
#ifdef GL_SUN_convolution_border_modes
9333
 
9334
#endif /* GL_SUN_convolution_border_modes */
9335
 
9336
#ifdef GL_SUN_global_alpha
9337
 
9338
static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT)
9339
{
9340
  GLboolean r = GL_FALSE;
9341
 
9342
  r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;
9343
  r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;
9344
  r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;
9345
  r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;
9346
  r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;
9347
  r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;
9348
  r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;
9349
  r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;
9350
 
9351
  return r;
9352
}
9353
 
9354
#endif /* GL_SUN_global_alpha */
9355
 
9356
#ifdef GL_SUN_mesh_array
9357
 
9358
#endif /* GL_SUN_mesh_array */
9359
 
9360
#ifdef GL_SUN_read_video_pixels
9361
 
9362
static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT)
9363
{
9364
  GLboolean r = GL_FALSE;
9365
 
9366
  r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;
9367
 
9368
  return r;
9369
}
9370
 
9371
#endif /* GL_SUN_read_video_pixels */
9372
 
9373
#ifdef GL_SUN_slice_accum
9374
 
9375
#endif /* GL_SUN_slice_accum */
9376
 
9377
#ifdef GL_SUN_triangle_list
9378
 
9379
static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT)
9380
{
9381
  GLboolean r = GL_FALSE;
9382
 
9383
  r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;
9384
  r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;
9385
  r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;
9386
  r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;
9387
  r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;
9388
  r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;
9389
  r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;
9390
 
9391
  return r;
9392
}
9393
 
9394
#endif /* GL_SUN_triangle_list */
9395
 
9396
#ifdef GL_SUN_vertex
9397
 
9398
static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
9399
{
9400
  GLboolean r = GL_FALSE;
9401
 
9402
  r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;
9403
  r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;
9404
  r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;
9405
  r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;
9406
  r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;
9407
  r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;
9408
  r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;
9409
  r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;
9410
  r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;
9411
  r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;
9412
  r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;
9413
  r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;
9414
  r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;
9415
  r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;
9416
  r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;
9417
  r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;
9418
  r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;
9419
  r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;
9420
  r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;
9421
  r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;
9422
  r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;
9423
  r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;
9424
  r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;
9425
  r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;
9426
  r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;
9427
  r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;
9428
  r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;
9429
  r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;
9430
  r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;
9431
  r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;
9432
  r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;
9433
  r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;
9434
  r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;
9435
  r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;
9436
  r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;
9437
  r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;
9438
  r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;
9439
  r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;
9440
  r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;
9441
  r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;
9442
 
9443
  return r;
9444
}
9445
 
9446
#endif /* GL_SUN_vertex */
9447
 
9448
#ifdef GL_WIN_phong_shading
9449
 
9450
#endif /* GL_WIN_phong_shading */
9451
 
9452
#ifdef GL_WIN_specular_fog
9453
 
9454
#endif /* GL_WIN_specular_fog */
9455
 
9456
#ifdef GL_WIN_swap_hint
9457
 
9458
static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT)
9459
{
9460
  GLboolean r = GL_FALSE;
9461
 
9462
  r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;
9463
 
9464
  return r;
9465
}
9466
 
9467
#endif /* GL_WIN_swap_hint */
9468
 
9469
/* ------------------------------------------------------------------------- */
9470
 
9471
GLboolean GLEWAPIENTRY glewGetExtension (const char* name)
9472
{    
9473
  const GLubyte* start;
9474
  const GLubyte* end;
9475
  start = (const GLubyte*)glGetString(GL_EXTENSIONS);
9476
  if (start == 0)
9477
    return GL_FALSE;
9478
  end = start + _glewStrLen(start);
9479
  return _glewSearchExtension(name, start, end);
9480
}
9481
 
9482
/* ------------------------------------------------------------------------- */
9483
 
9484
#ifndef GLEW_MX
9485
static
9486
#endif
9487
GLenum GLEWAPIENTRY glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
9488
{
9489
  const GLubyte* s;
9490
  GLuint dot;
9491
  GLint major, minor;
9492
  const GLubyte* extStart;
9493
  const GLubyte* extEnd;
9494
  /* query opengl version */
9495
  s = glGetString(GL_VERSION);
9496
  dot = _glewStrCLen(s, '.');
9497
  if (dot == 0)
9498
    return GLEW_ERROR_NO_GL_VERSION;
9499
 
9500
  major = s[dot-1]-'0';
9501
  minor = s[dot+1]-'0';
9502
 
9503
  if (minor < 0 || minor > 9)
9504
    minor = 0;
9505
  if (major<0 || major>9)
9506
    return GLEW_ERROR_NO_GL_VERSION;
9507
 
9508
 
9509
  if (major == 1 && minor == 0)
9510
  {
9511
    return GLEW_ERROR_GL_VERSION_10_ONLY;
9512
  }
9513
  else
9514
  {
677 janba 9515
    CONST_CAST(GLEW_VERSION_4_4)   = ( major > 4 )                 || ( major == 4 && minor >= 4 ) ? GL_TRUE : GL_FALSE;
9516
    CONST_CAST(GLEW_VERSION_4_3)   = GLEW_VERSION_4_4   == GL_TRUE || ( major == 4 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
667 khor 9517
    CONST_CAST(GLEW_VERSION_4_2)   = GLEW_VERSION_4_3   == GL_TRUE || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
9518
    CONST_CAST(GLEW_VERSION_4_1)   = GLEW_VERSION_4_2   == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
9519
    CONST_CAST(GLEW_VERSION_4_0)   = GLEW_VERSION_4_1   == GL_TRUE || ( major == 4               ) ? GL_TRUE : GL_FALSE;
9520
    CONST_CAST(GLEW_VERSION_3_3)   = GLEW_VERSION_4_0   == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
9521
    CONST_CAST(GLEW_VERSION_3_2)   = GLEW_VERSION_3_3   == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
9522
    CONST_CAST(GLEW_VERSION_3_1)   = GLEW_VERSION_3_2   == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
9523
    CONST_CAST(GLEW_VERSION_3_0)   = GLEW_VERSION_3_1   == GL_TRUE || ( major == 3               ) ? GL_TRUE : GL_FALSE;
9524
    CONST_CAST(GLEW_VERSION_2_1)   = GLEW_VERSION_3_0   == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE;    
9525
    CONST_CAST(GLEW_VERSION_2_0)   = GLEW_VERSION_2_1   == GL_TRUE || ( major == 2               ) ? GL_TRUE : GL_FALSE;
9526
    CONST_CAST(GLEW_VERSION_1_5)   = GLEW_VERSION_2_0   == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE;
9527
    CONST_CAST(GLEW_VERSION_1_4)   = GLEW_VERSION_1_5   == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE;
9528
    CONST_CAST(GLEW_VERSION_1_3)   = GLEW_VERSION_1_4   == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
9529
    CONST_CAST(GLEW_VERSION_1_2_1) = GLEW_VERSION_1_3   == GL_TRUE                                 ? GL_TRUE : GL_FALSE; 
9530
    CONST_CAST(GLEW_VERSION_1_2)   = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
9531
    CONST_CAST(GLEW_VERSION_1_1)   = GLEW_VERSION_1_2   == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
9532
  }
9533
 
9534
  /* query opengl extensions string */
9535
  extStart = glGetString(GL_EXTENSIONS);
9536
  if (extStart == 0)
9537
    extStart = (const GLubyte*)"";
9538
  extEnd = extStart + _glewStrLen(extStart);
9539
 
9540
  /* initialize extensions */
9541
#ifdef GL_VERSION_1_2
9542
  if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);
9543
#endif /* GL_VERSION_1_2 */
9544
#ifdef GL_VERSION_1_2_1
9545
#endif /* GL_VERSION_1_2_1 */
9546
#ifdef GL_VERSION_1_3
9547
  if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
9548
#endif /* GL_VERSION_1_3 */
9549
#ifdef GL_VERSION_1_4
9550
  if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);
9551
#endif /* GL_VERSION_1_4 */
9552
#ifdef GL_VERSION_1_5
9553
  if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);
9554
#endif /* GL_VERSION_1_5 */
9555
#ifdef GL_VERSION_2_0
9556
  if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);
9557
#endif /* GL_VERSION_2_0 */
9558
#ifdef GL_VERSION_2_1
9559
  if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT);
9560
#endif /* GL_VERSION_2_1 */
9561
#ifdef GL_VERSION_3_0
9562
  if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT);
9563
#endif /* GL_VERSION_3_0 */
9564
#ifdef GL_VERSION_3_1
9565
  if (glewExperimental || GLEW_VERSION_3_1) CONST_CAST(GLEW_VERSION_3_1) = !_glewInit_GL_VERSION_3_1(GLEW_CONTEXT_ARG_VAR_INIT);
9566
#endif /* GL_VERSION_3_1 */
9567
#ifdef GL_VERSION_3_2
9568
  if (glewExperimental || GLEW_VERSION_3_2) CONST_CAST(GLEW_VERSION_3_2) = !_glewInit_GL_VERSION_3_2(GLEW_CONTEXT_ARG_VAR_INIT);
9569
#endif /* GL_VERSION_3_2 */
9570
#ifdef GL_VERSION_3_3
9571
  if (glewExperimental || GLEW_VERSION_3_3) CONST_CAST(GLEW_VERSION_3_3) = !_glewInit_GL_VERSION_3_3(GLEW_CONTEXT_ARG_VAR_INIT);
9572
#endif /* GL_VERSION_3_3 */
9573
#ifdef GL_VERSION_4_0
9574
  if (glewExperimental || GLEW_VERSION_4_0) CONST_CAST(GLEW_VERSION_4_0) = !_glewInit_GL_VERSION_4_0(GLEW_CONTEXT_ARG_VAR_INIT);
9575
#endif /* GL_VERSION_4_0 */
9576
#ifdef GL_VERSION_4_1
9577
#endif /* GL_VERSION_4_1 */
9578
#ifdef GL_VERSION_4_2
9579
#endif /* GL_VERSION_4_2 */
9580
#ifdef GL_VERSION_4_3
9581
#endif /* GL_VERSION_4_3 */
677 janba 9582
#ifdef GL_VERSION_4_4
9583
#endif /* GL_VERSION_4_4 */
667 khor 9584
#ifdef GL_3DFX_multisample
9585
  CONST_CAST(GLEW_3DFX_multisample) = _glewSearchExtension("GL_3DFX_multisample", extStart, extEnd);
9586
#endif /* GL_3DFX_multisample */
9587
#ifdef GL_3DFX_tbuffer
9588
  CONST_CAST(GLEW_3DFX_tbuffer) = _glewSearchExtension("GL_3DFX_tbuffer", extStart, extEnd);
9589
  if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
9590
#endif /* GL_3DFX_tbuffer */
9591
#ifdef GL_3DFX_texture_compression_FXT1
9592
  CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = _glewSearchExtension("GL_3DFX_texture_compression_FXT1", extStart, extEnd);
9593
#endif /* GL_3DFX_texture_compression_FXT1 */
9594
#ifdef GL_AMD_blend_minmax_factor
9595
  CONST_CAST(GLEW_AMD_blend_minmax_factor) = _glewSearchExtension("GL_AMD_blend_minmax_factor", extStart, extEnd);
9596
#endif /* GL_AMD_blend_minmax_factor */
9597
#ifdef GL_AMD_conservative_depth
9598
  CONST_CAST(GLEW_AMD_conservative_depth) = _glewSearchExtension("GL_AMD_conservative_depth", extStart, extEnd);
9599
#endif /* GL_AMD_conservative_depth */
9600
#ifdef GL_AMD_debug_output
9601
  CONST_CAST(GLEW_AMD_debug_output) = _glewSearchExtension("GL_AMD_debug_output", extStart, extEnd);
9602
  if (glewExperimental || GLEW_AMD_debug_output) CONST_CAST(GLEW_AMD_debug_output) = !_glewInit_GL_AMD_debug_output(GLEW_CONTEXT_ARG_VAR_INIT);
9603
#endif /* GL_AMD_debug_output */
9604
#ifdef GL_AMD_depth_clamp_separate
9605
  CONST_CAST(GLEW_AMD_depth_clamp_separate) = _glewSearchExtension("GL_AMD_depth_clamp_separate", extStart, extEnd);
9606
#endif /* GL_AMD_depth_clamp_separate */
9607
#ifdef GL_AMD_draw_buffers_blend
9608
  CONST_CAST(GLEW_AMD_draw_buffers_blend) = _glewSearchExtension("GL_AMD_draw_buffers_blend", extStart, extEnd);
9609
  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);
9610
#endif /* GL_AMD_draw_buffers_blend */
677 janba 9611
#ifdef GL_AMD_interleaved_elements
9612
  CONST_CAST(GLEW_AMD_interleaved_elements) = _glewSearchExtension("GL_AMD_interleaved_elements", extStart, extEnd);
9613
  if (glewExperimental || GLEW_AMD_interleaved_elements) CONST_CAST(GLEW_AMD_interleaved_elements) = !_glewInit_GL_AMD_interleaved_elements(GLEW_CONTEXT_ARG_VAR_INIT);
9614
#endif /* GL_AMD_interleaved_elements */
667 khor 9615
#ifdef GL_AMD_multi_draw_indirect
9616
  CONST_CAST(GLEW_AMD_multi_draw_indirect) = _glewSearchExtension("GL_AMD_multi_draw_indirect", extStart, extEnd);
9617
  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);
9618
#endif /* GL_AMD_multi_draw_indirect */
9619
#ifdef GL_AMD_name_gen_delete
9620
  CONST_CAST(GLEW_AMD_name_gen_delete) = _glewSearchExtension("GL_AMD_name_gen_delete", extStart, extEnd);
9621
  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);
9622
#endif /* GL_AMD_name_gen_delete */
9623
#ifdef GL_AMD_performance_monitor
9624
  CONST_CAST(GLEW_AMD_performance_monitor) = _glewSearchExtension("GL_AMD_performance_monitor", extStart, extEnd);
9625
  if (glewExperimental || GLEW_AMD_performance_monitor) CONST_CAST(GLEW_AMD_performance_monitor) = !_glewInit_GL_AMD_performance_monitor(GLEW_CONTEXT_ARG_VAR_INIT);
9626
#endif /* GL_AMD_performance_monitor */
9627
#ifdef GL_AMD_pinned_memory
9628
  CONST_CAST(GLEW_AMD_pinned_memory) = _glewSearchExtension("GL_AMD_pinned_memory", extStart, extEnd);
9629
#endif /* GL_AMD_pinned_memory */
9630
#ifdef GL_AMD_query_buffer_object
9631
  CONST_CAST(GLEW_AMD_query_buffer_object) = _glewSearchExtension("GL_AMD_query_buffer_object", extStart, extEnd);
9632
#endif /* GL_AMD_query_buffer_object */
9633
#ifdef GL_AMD_sample_positions
9634
  CONST_CAST(GLEW_AMD_sample_positions) = _glewSearchExtension("GL_AMD_sample_positions", extStart, extEnd);
9635
  if (glewExperimental || GLEW_AMD_sample_positions) CONST_CAST(GLEW_AMD_sample_positions) = !_glewInit_GL_AMD_sample_positions(GLEW_CONTEXT_ARG_VAR_INIT);
9636
#endif /* GL_AMD_sample_positions */
9637
#ifdef GL_AMD_seamless_cubemap_per_texture
9638
  CONST_CAST(GLEW_AMD_seamless_cubemap_per_texture) = _glewSearchExtension("GL_AMD_seamless_cubemap_per_texture", extStart, extEnd);
9639
#endif /* GL_AMD_seamless_cubemap_per_texture */
9640
#ifdef GL_AMD_shader_stencil_export
9641
  CONST_CAST(GLEW_AMD_shader_stencil_export) = _glewSearchExtension("GL_AMD_shader_stencil_export", extStart, extEnd);
9642
#endif /* GL_AMD_shader_stencil_export */
677 janba 9643
#ifdef GL_AMD_shader_trinary_minmax
9644
  CONST_CAST(GLEW_AMD_shader_trinary_minmax) = _glewSearchExtension("GL_AMD_shader_trinary_minmax", extStart, extEnd);
9645
#endif /* GL_AMD_shader_trinary_minmax */
9646
#ifdef GL_AMD_sparse_texture
9647
  CONST_CAST(GLEW_AMD_sparse_texture) = _glewSearchExtension("GL_AMD_sparse_texture", extStart, extEnd);
9648
  if (glewExperimental || GLEW_AMD_sparse_texture) CONST_CAST(GLEW_AMD_sparse_texture) = !_glewInit_GL_AMD_sparse_texture(GLEW_CONTEXT_ARG_VAR_INIT);
9649
#endif /* GL_AMD_sparse_texture */
667 khor 9650
#ifdef GL_AMD_stencil_operation_extended
9651
  CONST_CAST(GLEW_AMD_stencil_operation_extended) = _glewSearchExtension("GL_AMD_stencil_operation_extended", extStart, extEnd);
9652
  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);
9653
#endif /* GL_AMD_stencil_operation_extended */
9654
#ifdef GL_AMD_texture_texture4
9655
  CONST_CAST(GLEW_AMD_texture_texture4) = _glewSearchExtension("GL_AMD_texture_texture4", extStart, extEnd);
9656
#endif /* GL_AMD_texture_texture4 */
9657
#ifdef GL_AMD_transform_feedback3_lines_triangles
9658
  CONST_CAST(GLEW_AMD_transform_feedback3_lines_triangles) = _glewSearchExtension("GL_AMD_transform_feedback3_lines_triangles", extStart, extEnd);
9659
#endif /* GL_AMD_transform_feedback3_lines_triangles */
9660
#ifdef GL_AMD_vertex_shader_layer
9661
  CONST_CAST(GLEW_AMD_vertex_shader_layer) = _glewSearchExtension("GL_AMD_vertex_shader_layer", extStart, extEnd);
9662
#endif /* GL_AMD_vertex_shader_layer */
9663
#ifdef GL_AMD_vertex_shader_tessellator
9664
  CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = _glewSearchExtension("GL_AMD_vertex_shader_tessellator", extStart, extEnd);
9665
  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);
9666
#endif /* GL_AMD_vertex_shader_tessellator */
9667
#ifdef GL_AMD_vertex_shader_viewport_index
9668
  CONST_CAST(GLEW_AMD_vertex_shader_viewport_index) = _glewSearchExtension("GL_AMD_vertex_shader_viewport_index", extStart, extEnd);
9669
#endif /* GL_AMD_vertex_shader_viewport_index */
677 janba 9670
#ifdef GL_ANGLE_depth_texture
9671
  CONST_CAST(GLEW_ANGLE_depth_texture) = _glewSearchExtension("GL_ANGLE_depth_texture", extStart, extEnd);
9672
#endif /* GL_ANGLE_depth_texture */
9673
#ifdef GL_ANGLE_framebuffer_blit
9674
  CONST_CAST(GLEW_ANGLE_framebuffer_blit) = _glewSearchExtension("GL_ANGLE_framebuffer_blit", extStart, extEnd);
9675
  if (glewExperimental || GLEW_ANGLE_framebuffer_blit) CONST_CAST(GLEW_ANGLE_framebuffer_blit) = !_glewInit_GL_ANGLE_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT);
9676
#endif /* GL_ANGLE_framebuffer_blit */
9677
#ifdef GL_ANGLE_framebuffer_multisample
9678
  CONST_CAST(GLEW_ANGLE_framebuffer_multisample) = _glewSearchExtension("GL_ANGLE_framebuffer_multisample", extStart, extEnd);
9679
  if (glewExperimental || GLEW_ANGLE_framebuffer_multisample) CONST_CAST(GLEW_ANGLE_framebuffer_multisample) = !_glewInit_GL_ANGLE_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9680
#endif /* GL_ANGLE_framebuffer_multisample */
9681
#ifdef GL_ANGLE_instanced_arrays
9682
  CONST_CAST(GLEW_ANGLE_instanced_arrays) = _glewSearchExtension("GL_ANGLE_instanced_arrays", extStart, extEnd);
9683
  if (glewExperimental || GLEW_ANGLE_instanced_arrays) CONST_CAST(GLEW_ANGLE_instanced_arrays) = !_glewInit_GL_ANGLE_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
9684
#endif /* GL_ANGLE_instanced_arrays */
9685
#ifdef GL_ANGLE_pack_reverse_row_order
9686
  CONST_CAST(GLEW_ANGLE_pack_reverse_row_order) = _glewSearchExtension("GL_ANGLE_pack_reverse_row_order", extStart, extEnd);
9687
#endif /* GL_ANGLE_pack_reverse_row_order */
9688
#ifdef GL_ANGLE_program_binary
9689
  CONST_CAST(GLEW_ANGLE_program_binary) = _glewSearchExtension("GL_ANGLE_program_binary", extStart, extEnd);
9690
#endif /* GL_ANGLE_program_binary */
9691
#ifdef GL_ANGLE_texture_compression_dxt1
9692
  CONST_CAST(GLEW_ANGLE_texture_compression_dxt1) = _glewSearchExtension("GL_ANGLE_texture_compression_dxt1", extStart, extEnd);
9693
#endif /* GL_ANGLE_texture_compression_dxt1 */
9694
#ifdef GL_ANGLE_texture_compression_dxt3
9695
  CONST_CAST(GLEW_ANGLE_texture_compression_dxt3) = _glewSearchExtension("GL_ANGLE_texture_compression_dxt3", extStart, extEnd);
9696
#endif /* GL_ANGLE_texture_compression_dxt3 */
9697
#ifdef GL_ANGLE_texture_compression_dxt5
9698
  CONST_CAST(GLEW_ANGLE_texture_compression_dxt5) = _glewSearchExtension("GL_ANGLE_texture_compression_dxt5", extStart, extEnd);
9699
#endif /* GL_ANGLE_texture_compression_dxt5 */
9700
#ifdef GL_ANGLE_texture_usage
9701
  CONST_CAST(GLEW_ANGLE_texture_usage) = _glewSearchExtension("GL_ANGLE_texture_usage", extStart, extEnd);
9702
#endif /* GL_ANGLE_texture_usage */
9703
#ifdef GL_ANGLE_timer_query
9704
  CONST_CAST(GLEW_ANGLE_timer_query) = _glewSearchExtension("GL_ANGLE_timer_query", extStart, extEnd);
9705
  if (glewExperimental || GLEW_ANGLE_timer_query) CONST_CAST(GLEW_ANGLE_timer_query) = !_glewInit_GL_ANGLE_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
9706
#endif /* GL_ANGLE_timer_query */
9707
#ifdef GL_ANGLE_translated_shader_source
9708
  CONST_CAST(GLEW_ANGLE_translated_shader_source) = _glewSearchExtension("GL_ANGLE_translated_shader_source", extStart, extEnd);
9709
  if (glewExperimental || GLEW_ANGLE_translated_shader_source) CONST_CAST(GLEW_ANGLE_translated_shader_source) = !_glewInit_GL_ANGLE_translated_shader_source(GLEW_CONTEXT_ARG_VAR_INIT);
9710
#endif /* GL_ANGLE_translated_shader_source */
667 khor 9711
#ifdef GL_APPLE_aux_depth_stencil
9712
  CONST_CAST(GLEW_APPLE_aux_depth_stencil) = _glewSearchExtension("GL_APPLE_aux_depth_stencil", extStart, extEnd);
9713
#endif /* GL_APPLE_aux_depth_stencil */
9714
#ifdef GL_APPLE_client_storage
9715
  CONST_CAST(GLEW_APPLE_client_storage) = _glewSearchExtension("GL_APPLE_client_storage", extStart, extEnd);
9716
#endif /* GL_APPLE_client_storage */
9717
#ifdef GL_APPLE_element_array
9718
  CONST_CAST(GLEW_APPLE_element_array) = _glewSearchExtension("GL_APPLE_element_array", extStart, extEnd);
9719
  if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT);
9720
#endif /* GL_APPLE_element_array */
9721
#ifdef GL_APPLE_fence
9722
  CONST_CAST(GLEW_APPLE_fence) = _glewSearchExtension("GL_APPLE_fence", extStart, extEnd);
9723
  if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT);
9724
#endif /* GL_APPLE_fence */
9725
#ifdef GL_APPLE_float_pixels
9726
  CONST_CAST(GLEW_APPLE_float_pixels) = _glewSearchExtension("GL_APPLE_float_pixels", extStart, extEnd);
9727
#endif /* GL_APPLE_float_pixels */
9728
#ifdef GL_APPLE_flush_buffer_range
9729
  CONST_CAST(GLEW_APPLE_flush_buffer_range) = _glewSearchExtension("GL_APPLE_flush_buffer_range", extStart, extEnd);
9730
  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);
9731
#endif /* GL_APPLE_flush_buffer_range */
9732
#ifdef GL_APPLE_object_purgeable
9733
  CONST_CAST(GLEW_APPLE_object_purgeable) = _glewSearchExtension("GL_APPLE_object_purgeable", extStart, extEnd);
9734
  if (glewExperimental || GLEW_APPLE_object_purgeable) CONST_CAST(GLEW_APPLE_object_purgeable) = !_glewInit_GL_APPLE_object_purgeable(GLEW_CONTEXT_ARG_VAR_INIT);
9735
#endif /* GL_APPLE_object_purgeable */
9736
#ifdef GL_APPLE_pixel_buffer
9737
  CONST_CAST(GLEW_APPLE_pixel_buffer) = _glewSearchExtension("GL_APPLE_pixel_buffer", extStart, extEnd);
9738
#endif /* GL_APPLE_pixel_buffer */
9739
#ifdef GL_APPLE_rgb_422
9740
  CONST_CAST(GLEW_APPLE_rgb_422) = _glewSearchExtension("GL_APPLE_rgb_422", extStart, extEnd);
9741
#endif /* GL_APPLE_rgb_422 */
9742
#ifdef GL_APPLE_row_bytes
9743
  CONST_CAST(GLEW_APPLE_row_bytes) = _glewSearchExtension("GL_APPLE_row_bytes", extStart, extEnd);
9744
#endif /* GL_APPLE_row_bytes */
9745
#ifdef GL_APPLE_specular_vector
9746
  CONST_CAST(GLEW_APPLE_specular_vector) = _glewSearchExtension("GL_APPLE_specular_vector", extStart, extEnd);
9747
#endif /* GL_APPLE_specular_vector */
9748
#ifdef GL_APPLE_texture_range
9749
  CONST_CAST(GLEW_APPLE_texture_range) = _glewSearchExtension("GL_APPLE_texture_range", extStart, extEnd);
9750
  if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT);
9751
#endif /* GL_APPLE_texture_range */
9752
#ifdef GL_APPLE_transform_hint
9753
  CONST_CAST(GLEW_APPLE_transform_hint) = _glewSearchExtension("GL_APPLE_transform_hint", extStart, extEnd);
9754
#endif /* GL_APPLE_transform_hint */
9755
#ifdef GL_APPLE_vertex_array_object
9756
  CONST_CAST(GLEW_APPLE_vertex_array_object) = _glewSearchExtension("GL_APPLE_vertex_array_object", extStart, extEnd);
9757
  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);
9758
#endif /* GL_APPLE_vertex_array_object */
9759
#ifdef GL_APPLE_vertex_array_range
9760
  CONST_CAST(GLEW_APPLE_vertex_array_range) = _glewSearchExtension("GL_APPLE_vertex_array_range", extStart, extEnd);
9761
  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);
9762
#endif /* GL_APPLE_vertex_array_range */
9763
#ifdef GL_APPLE_vertex_program_evaluators
9764
  CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = _glewSearchExtension("GL_APPLE_vertex_program_evaluators", extStart, extEnd);
9765
  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);
9766
#endif /* GL_APPLE_vertex_program_evaluators */
9767
#ifdef GL_APPLE_ycbcr_422
9768
  CONST_CAST(GLEW_APPLE_ycbcr_422) = _glewSearchExtension("GL_APPLE_ycbcr_422", extStart, extEnd);
9769
#endif /* GL_APPLE_ycbcr_422 */
9770
#ifdef GL_ARB_ES2_compatibility
9771
  CONST_CAST(GLEW_ARB_ES2_compatibility) = _glewSearchExtension("GL_ARB_ES2_compatibility", extStart, extEnd);
9772
  if (glewExperimental || GLEW_ARB_ES2_compatibility) CONST_CAST(GLEW_ARB_ES2_compatibility) = !_glewInit_GL_ARB_ES2_compatibility(GLEW_CONTEXT_ARG_VAR_INIT);
9773
#endif /* GL_ARB_ES2_compatibility */
9774
#ifdef GL_ARB_ES3_compatibility
9775
  CONST_CAST(GLEW_ARB_ES3_compatibility) = _glewSearchExtension("GL_ARB_ES3_compatibility", extStart, extEnd);
9776
#endif /* GL_ARB_ES3_compatibility */
9777
#ifdef GL_ARB_arrays_of_arrays
9778
  CONST_CAST(GLEW_ARB_arrays_of_arrays) = _glewSearchExtension("GL_ARB_arrays_of_arrays", extStart, extEnd);
9779
#endif /* GL_ARB_arrays_of_arrays */
9780
#ifdef GL_ARB_base_instance
9781
  CONST_CAST(GLEW_ARB_base_instance) = _glewSearchExtension("GL_ARB_base_instance", extStart, extEnd);
9782
  if (glewExperimental || GLEW_ARB_base_instance) CONST_CAST(GLEW_ARB_base_instance) = !_glewInit_GL_ARB_base_instance(GLEW_CONTEXT_ARG_VAR_INIT);
9783
#endif /* GL_ARB_base_instance */
677 janba 9784
#ifdef GL_ARB_bindless_texture
9785
  CONST_CAST(GLEW_ARB_bindless_texture) = _glewSearchExtension("GL_ARB_bindless_texture", extStart, extEnd);
9786
  if (glewExperimental || GLEW_ARB_bindless_texture) CONST_CAST(GLEW_ARB_bindless_texture) = !_glewInit_GL_ARB_bindless_texture(GLEW_CONTEXT_ARG_VAR_INIT);
9787
#endif /* GL_ARB_bindless_texture */
667 khor 9788
#ifdef GL_ARB_blend_func_extended
9789
  CONST_CAST(GLEW_ARB_blend_func_extended) = _glewSearchExtension("GL_ARB_blend_func_extended", extStart, extEnd);
9790
  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);
9791
#endif /* GL_ARB_blend_func_extended */
677 janba 9792
#ifdef GL_ARB_buffer_storage
9793
  CONST_CAST(GLEW_ARB_buffer_storage) = _glewSearchExtension("GL_ARB_buffer_storage", extStart, extEnd);
9794
  if (glewExperimental || GLEW_ARB_buffer_storage) CONST_CAST(GLEW_ARB_buffer_storage) = !_glewInit_GL_ARB_buffer_storage(GLEW_CONTEXT_ARG_VAR_INIT);
9795
#endif /* GL_ARB_buffer_storage */
667 khor 9796
#ifdef GL_ARB_cl_event
9797
  CONST_CAST(GLEW_ARB_cl_event) = _glewSearchExtension("GL_ARB_cl_event", extStart, extEnd);
9798
  if (glewExperimental || GLEW_ARB_cl_event) CONST_CAST(GLEW_ARB_cl_event) = !_glewInit_GL_ARB_cl_event(GLEW_CONTEXT_ARG_VAR_INIT);
9799
#endif /* GL_ARB_cl_event */
9800
#ifdef GL_ARB_clear_buffer_object
9801
  CONST_CAST(GLEW_ARB_clear_buffer_object) = _glewSearchExtension("GL_ARB_clear_buffer_object", extStart, extEnd);
9802
  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);
9803
#endif /* GL_ARB_clear_buffer_object */
677 janba 9804
#ifdef GL_ARB_clear_texture
9805
  CONST_CAST(GLEW_ARB_clear_texture) = _glewSearchExtension("GL_ARB_clear_texture", extStart, extEnd);
9806
  if (glewExperimental || GLEW_ARB_clear_texture) CONST_CAST(GLEW_ARB_clear_texture) = !_glewInit_GL_ARB_clear_texture(GLEW_CONTEXT_ARG_VAR_INIT);
9807
#endif /* GL_ARB_clear_texture */
667 khor 9808
#ifdef GL_ARB_color_buffer_float
9809
  CONST_CAST(GLEW_ARB_color_buffer_float) = _glewSearchExtension("GL_ARB_color_buffer_float", extStart, extEnd);
9810
  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);
9811
#endif /* GL_ARB_color_buffer_float */
9812
#ifdef GL_ARB_compatibility
9813
  CONST_CAST(GLEW_ARB_compatibility) = _glewSearchExtension("GL_ARB_compatibility", extStart, extEnd);
9814
#endif /* GL_ARB_compatibility */
9815
#ifdef GL_ARB_compressed_texture_pixel_storage
9816
  CONST_CAST(GLEW_ARB_compressed_texture_pixel_storage) = _glewSearchExtension("GL_ARB_compressed_texture_pixel_storage", extStart, extEnd);
9817
#endif /* GL_ARB_compressed_texture_pixel_storage */
9818
#ifdef GL_ARB_compute_shader
9819
  CONST_CAST(GLEW_ARB_compute_shader) = _glewSearchExtension("GL_ARB_compute_shader", extStart, extEnd);
9820
  if (glewExperimental || GLEW_ARB_compute_shader) CONST_CAST(GLEW_ARB_compute_shader) = !_glewInit_GL_ARB_compute_shader(GLEW_CONTEXT_ARG_VAR_INIT);
9821
#endif /* GL_ARB_compute_shader */
677 janba 9822
#ifdef GL_ARB_compute_variable_group_size
9823
  CONST_CAST(GLEW_ARB_compute_variable_group_size) = _glewSearchExtension("GL_ARB_compute_variable_group_size", extStart, extEnd);
9824
  if (glewExperimental || GLEW_ARB_compute_variable_group_size) CONST_CAST(GLEW_ARB_compute_variable_group_size) = !_glewInit_GL_ARB_compute_variable_group_size(GLEW_CONTEXT_ARG_VAR_INIT);
9825
#endif /* GL_ARB_compute_variable_group_size */
667 khor 9826
#ifdef GL_ARB_conservative_depth
9827
  CONST_CAST(GLEW_ARB_conservative_depth) = _glewSearchExtension("GL_ARB_conservative_depth", extStart, extEnd);
9828
#endif /* GL_ARB_conservative_depth */
9829
#ifdef GL_ARB_copy_buffer
9830
  CONST_CAST(GLEW_ARB_copy_buffer) = _glewSearchExtension("GL_ARB_copy_buffer", extStart, extEnd);
9831
  if (glewExperimental || GLEW_ARB_copy_buffer) CONST_CAST(GLEW_ARB_copy_buffer) = !_glewInit_GL_ARB_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
9832
#endif /* GL_ARB_copy_buffer */
9833
#ifdef GL_ARB_copy_image
9834
  CONST_CAST(GLEW_ARB_copy_image) = _glewSearchExtension("GL_ARB_copy_image", extStart, extEnd);
9835
  if (glewExperimental || GLEW_ARB_copy_image) CONST_CAST(GLEW_ARB_copy_image) = !_glewInit_GL_ARB_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
9836
#endif /* GL_ARB_copy_image */
9837
#ifdef GL_ARB_debug_output
9838
  CONST_CAST(GLEW_ARB_debug_output) = _glewSearchExtension("GL_ARB_debug_output", extStart, extEnd);
9839
  if (glewExperimental || GLEW_ARB_debug_output) CONST_CAST(GLEW_ARB_debug_output) = !_glewInit_GL_ARB_debug_output(GLEW_CONTEXT_ARG_VAR_INIT);
9840
#endif /* GL_ARB_debug_output */
9841
#ifdef GL_ARB_depth_buffer_float
9842
  CONST_CAST(GLEW_ARB_depth_buffer_float) = _glewSearchExtension("GL_ARB_depth_buffer_float", extStart, extEnd);
9843
#endif /* GL_ARB_depth_buffer_float */
9844
#ifdef GL_ARB_depth_clamp
9845
  CONST_CAST(GLEW_ARB_depth_clamp) = _glewSearchExtension("GL_ARB_depth_clamp", extStart, extEnd);
9846
#endif /* GL_ARB_depth_clamp */
9847
#ifdef GL_ARB_depth_texture
9848
  CONST_CAST(GLEW_ARB_depth_texture) = _glewSearchExtension("GL_ARB_depth_texture", extStart, extEnd);
9849
#endif /* GL_ARB_depth_texture */
9850
#ifdef GL_ARB_draw_buffers
9851
  CONST_CAST(GLEW_ARB_draw_buffers) = _glewSearchExtension("GL_ARB_draw_buffers", extStart, extEnd);
9852
  if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
9853
#endif /* GL_ARB_draw_buffers */
9854
#ifdef GL_ARB_draw_buffers_blend
9855
  CONST_CAST(GLEW_ARB_draw_buffers_blend) = _glewSearchExtension("GL_ARB_draw_buffers_blend", extStart, extEnd);
9856
  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);
9857
#endif /* GL_ARB_draw_buffers_blend */
9858
#ifdef GL_ARB_draw_elements_base_vertex
9859
  CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = _glewSearchExtension("GL_ARB_draw_elements_base_vertex", extStart, extEnd);
9860
  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);
9861
#endif /* GL_ARB_draw_elements_base_vertex */
9862
#ifdef GL_ARB_draw_indirect
9863
  CONST_CAST(GLEW_ARB_draw_indirect) = _glewSearchExtension("GL_ARB_draw_indirect", extStart, extEnd);
9864
  if (glewExperimental || GLEW_ARB_draw_indirect) CONST_CAST(GLEW_ARB_draw_indirect) = !_glewInit_GL_ARB_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
9865
#endif /* GL_ARB_draw_indirect */
9866
#ifdef GL_ARB_draw_instanced
9867
  CONST_CAST(GLEW_ARB_draw_instanced) = _glewSearchExtension("GL_ARB_draw_instanced", extStart, extEnd);
9868
#endif /* GL_ARB_draw_instanced */
677 janba 9869
#ifdef GL_ARB_enhanced_layouts
9870
  CONST_CAST(GLEW_ARB_enhanced_layouts) = _glewSearchExtension("GL_ARB_enhanced_layouts", extStart, extEnd);
9871
#endif /* GL_ARB_enhanced_layouts */
667 khor 9872
#ifdef GL_ARB_explicit_attrib_location
9873
  CONST_CAST(GLEW_ARB_explicit_attrib_location) = _glewSearchExtension("GL_ARB_explicit_attrib_location", extStart, extEnd);
9874
#endif /* GL_ARB_explicit_attrib_location */
9875
#ifdef GL_ARB_explicit_uniform_location
9876
  CONST_CAST(GLEW_ARB_explicit_uniform_location) = _glewSearchExtension("GL_ARB_explicit_uniform_location", extStart, extEnd);
9877
#endif /* GL_ARB_explicit_uniform_location */
9878
#ifdef GL_ARB_fragment_coord_conventions
9879
  CONST_CAST(GLEW_ARB_fragment_coord_conventions) = _glewSearchExtension("GL_ARB_fragment_coord_conventions", extStart, extEnd);
9880
#endif /* GL_ARB_fragment_coord_conventions */
9881
#ifdef GL_ARB_fragment_layer_viewport
9882
  CONST_CAST(GLEW_ARB_fragment_layer_viewport) = _glewSearchExtension("GL_ARB_fragment_layer_viewport", extStart, extEnd);
9883
#endif /* GL_ARB_fragment_layer_viewport */
9884
#ifdef GL_ARB_fragment_program
9885
  CONST_CAST(GLEW_ARB_fragment_program) = _glewSearchExtension("GL_ARB_fragment_program", extStart, extEnd);
9886
#endif /* GL_ARB_fragment_program */
9887
#ifdef GL_ARB_fragment_program_shadow
9888
  CONST_CAST(GLEW_ARB_fragment_program_shadow) = _glewSearchExtension("GL_ARB_fragment_program_shadow", extStart, extEnd);
9889
#endif /* GL_ARB_fragment_program_shadow */
9890
#ifdef GL_ARB_fragment_shader
9891
  CONST_CAST(GLEW_ARB_fragment_shader) = _glewSearchExtension("GL_ARB_fragment_shader", extStart, extEnd);
9892
#endif /* GL_ARB_fragment_shader */
9893
#ifdef GL_ARB_framebuffer_no_attachments
9894
  CONST_CAST(GLEW_ARB_framebuffer_no_attachments) = _glewSearchExtension("GL_ARB_framebuffer_no_attachments", extStart, extEnd);
9895
  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);
9896
#endif /* GL_ARB_framebuffer_no_attachments */
9897
#ifdef GL_ARB_framebuffer_object
9898
  CONST_CAST(GLEW_ARB_framebuffer_object) = _glewSearchExtension("GL_ARB_framebuffer_object", extStart, extEnd);
9899
  if (glewExperimental || GLEW_ARB_framebuffer_object) CONST_CAST(GLEW_ARB_framebuffer_object) = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
9900
#endif /* GL_ARB_framebuffer_object */
9901
#ifdef GL_ARB_framebuffer_sRGB
9902
  CONST_CAST(GLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GL_ARB_framebuffer_sRGB", extStart, extEnd);
9903
#endif /* GL_ARB_framebuffer_sRGB */
9904
#ifdef GL_ARB_geometry_shader4
9905
  CONST_CAST(GLEW_ARB_geometry_shader4) = _glewSearchExtension("GL_ARB_geometry_shader4", extStart, extEnd);
9906
  if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
9907
#endif /* GL_ARB_geometry_shader4 */
9908
#ifdef GL_ARB_get_program_binary
9909
  CONST_CAST(GLEW_ARB_get_program_binary) = _glewSearchExtension("GL_ARB_get_program_binary", extStart, extEnd);
9910
  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);
9911
#endif /* GL_ARB_get_program_binary */
9912
#ifdef GL_ARB_gpu_shader5
9913
  CONST_CAST(GLEW_ARB_gpu_shader5) = _glewSearchExtension("GL_ARB_gpu_shader5", extStart, extEnd);
9914
#endif /* GL_ARB_gpu_shader5 */
9915
#ifdef GL_ARB_gpu_shader_fp64
9916
  CONST_CAST(GLEW_ARB_gpu_shader_fp64) = _glewSearchExtension("GL_ARB_gpu_shader_fp64", extStart, extEnd);
9917
  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);
9918
#endif /* GL_ARB_gpu_shader_fp64 */
9919
#ifdef GL_ARB_half_float_pixel
9920
  CONST_CAST(GLEW_ARB_half_float_pixel) = _glewSearchExtension("GL_ARB_half_float_pixel", extStart, extEnd);
9921
#endif /* GL_ARB_half_float_pixel */
9922
#ifdef GL_ARB_half_float_vertex
9923
  CONST_CAST(GLEW_ARB_half_float_vertex) = _glewSearchExtension("GL_ARB_half_float_vertex", extStart, extEnd);
9924
#endif /* GL_ARB_half_float_vertex */
9925
#ifdef GL_ARB_imaging
9926
  CONST_CAST(GLEW_ARB_imaging) = _glewSearchExtension("GL_ARB_imaging", extStart, extEnd);
9927
  if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT);
9928
#endif /* GL_ARB_imaging */
677 janba 9929
#ifdef GL_ARB_indirect_parameters
9930
  CONST_CAST(GLEW_ARB_indirect_parameters) = _glewSearchExtension("GL_ARB_indirect_parameters", extStart, extEnd);
9931
  if (glewExperimental || GLEW_ARB_indirect_parameters) CONST_CAST(GLEW_ARB_indirect_parameters) = !_glewInit_GL_ARB_indirect_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
9932
#endif /* GL_ARB_indirect_parameters */
667 khor 9933
#ifdef GL_ARB_instanced_arrays
9934
  CONST_CAST(GLEW_ARB_instanced_arrays) = _glewSearchExtension("GL_ARB_instanced_arrays", extStart, extEnd);
9935
  if (glewExperimental || GLEW_ARB_instanced_arrays) CONST_CAST(GLEW_ARB_instanced_arrays) = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
9936
#endif /* GL_ARB_instanced_arrays */
9937
#ifdef GL_ARB_internalformat_query
9938
  CONST_CAST(GLEW_ARB_internalformat_query) = _glewSearchExtension("GL_ARB_internalformat_query", extStart, extEnd);
9939
  if (glewExperimental || GLEW_ARB_internalformat_query) CONST_CAST(GLEW_ARB_internalformat_query) = !_glewInit_GL_ARB_internalformat_query(GLEW_CONTEXT_ARG_VAR_INIT);
9940
#endif /* GL_ARB_internalformat_query */
9941
#ifdef GL_ARB_internalformat_query2
9942
  CONST_CAST(GLEW_ARB_internalformat_query2) = _glewSearchExtension("GL_ARB_internalformat_query2", extStart, extEnd);
9943
  if (glewExperimental || GLEW_ARB_internalformat_query2) CONST_CAST(GLEW_ARB_internalformat_query2) = !_glewInit_GL_ARB_internalformat_query2(GLEW_CONTEXT_ARG_VAR_INIT);
9944
#endif /* GL_ARB_internalformat_query2 */
9945
#ifdef GL_ARB_invalidate_subdata
9946
  CONST_CAST(GLEW_ARB_invalidate_subdata) = _glewSearchExtension("GL_ARB_invalidate_subdata", extStart, extEnd);
9947
  if (glewExperimental || GLEW_ARB_invalidate_subdata) CONST_CAST(GLEW_ARB_invalidate_subdata) = !_glewInit_GL_ARB_invalidate_subdata(GLEW_CONTEXT_ARG_VAR_INIT);
9948
#endif /* GL_ARB_invalidate_subdata */
9949
#ifdef GL_ARB_map_buffer_alignment
9950
  CONST_CAST(GLEW_ARB_map_buffer_alignment) = _glewSearchExtension("GL_ARB_map_buffer_alignment", extStart, extEnd);
9951
#endif /* GL_ARB_map_buffer_alignment */
9952
#ifdef GL_ARB_map_buffer_range
9953
  CONST_CAST(GLEW_ARB_map_buffer_range) = _glewSearchExtension("GL_ARB_map_buffer_range", extStart, extEnd);
9954
  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);
9955
#endif /* GL_ARB_map_buffer_range */
9956
#ifdef GL_ARB_matrix_palette
9957
  CONST_CAST(GLEW_ARB_matrix_palette) = _glewSearchExtension("GL_ARB_matrix_palette", extStart, extEnd);
9958
  if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT);
9959
#endif /* GL_ARB_matrix_palette */
677 janba 9960
#ifdef GL_ARB_multi_bind
9961
  CONST_CAST(GLEW_ARB_multi_bind) = _glewSearchExtension("GL_ARB_multi_bind", extStart, extEnd);
9962
  if (glewExperimental || GLEW_ARB_multi_bind) CONST_CAST(GLEW_ARB_multi_bind) = !_glewInit_GL_ARB_multi_bind(GLEW_CONTEXT_ARG_VAR_INIT);
9963
#endif /* GL_ARB_multi_bind */
667 khor 9964
#ifdef GL_ARB_multi_draw_indirect
9965
  CONST_CAST(GLEW_ARB_multi_draw_indirect) = _glewSearchExtension("GL_ARB_multi_draw_indirect", extStart, extEnd);
9966
  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);
9967
#endif /* GL_ARB_multi_draw_indirect */
9968
#ifdef GL_ARB_multisample
9969
  CONST_CAST(GLEW_ARB_multisample) = _glewSearchExtension("GL_ARB_multisample", extStart, extEnd);
9970
  if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
9971
#endif /* GL_ARB_multisample */
9972
#ifdef GL_ARB_multitexture
9973
  CONST_CAST(GLEW_ARB_multitexture) = _glewSearchExtension("GL_ARB_multitexture", extStart, extEnd);
9974
  if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);
9975
#endif /* GL_ARB_multitexture */
9976
#ifdef GL_ARB_occlusion_query
9977
  CONST_CAST(GLEW_ARB_occlusion_query) = _glewSearchExtension("GL_ARB_occlusion_query", extStart, extEnd);
9978
  if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
9979
#endif /* GL_ARB_occlusion_query */
9980
#ifdef GL_ARB_occlusion_query2
9981
  CONST_CAST(GLEW_ARB_occlusion_query2) = _glewSearchExtension("GL_ARB_occlusion_query2", extStart, extEnd);
9982
#endif /* GL_ARB_occlusion_query2 */
9983
#ifdef GL_ARB_pixel_buffer_object
9984
  CONST_CAST(GLEW_ARB_pixel_buffer_object) = _glewSearchExtension("GL_ARB_pixel_buffer_object", extStart, extEnd);
9985
#endif /* GL_ARB_pixel_buffer_object */
9986
#ifdef GL_ARB_point_parameters
9987
  CONST_CAST(GLEW_ARB_point_parameters) = _glewSearchExtension("GL_ARB_point_parameters", extStart, extEnd);
9988
  if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
9989
#endif /* GL_ARB_point_parameters */
9990
#ifdef GL_ARB_point_sprite
9991
  CONST_CAST(GLEW_ARB_point_sprite) = _glewSearchExtension("GL_ARB_point_sprite", extStart, extEnd);
9992
#endif /* GL_ARB_point_sprite */
9993
#ifdef GL_ARB_program_interface_query
9994
  CONST_CAST(GLEW_ARB_program_interface_query) = _glewSearchExtension("GL_ARB_program_interface_query", extStart, extEnd);
9995
  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);
9996
#endif /* GL_ARB_program_interface_query */
9997
#ifdef GL_ARB_provoking_vertex
9998
  CONST_CAST(GLEW_ARB_provoking_vertex) = _glewSearchExtension("GL_ARB_provoking_vertex", extStart, extEnd);
9999
  if (glewExperimental || GLEW_ARB_provoking_vertex) CONST_CAST(GLEW_ARB_provoking_vertex) = !_glewInit_GL_ARB_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
10000
#endif /* GL_ARB_provoking_vertex */
677 janba 10001
#ifdef GL_ARB_query_buffer_object
10002
  CONST_CAST(GLEW_ARB_query_buffer_object) = _glewSearchExtension("GL_ARB_query_buffer_object", extStart, extEnd);
10003
#endif /* GL_ARB_query_buffer_object */
667 khor 10004
#ifdef GL_ARB_robust_buffer_access_behavior
10005
  CONST_CAST(GLEW_ARB_robust_buffer_access_behavior) = _glewSearchExtension("GL_ARB_robust_buffer_access_behavior", extStart, extEnd);
10006
#endif /* GL_ARB_robust_buffer_access_behavior */
10007
#ifdef GL_ARB_robustness
10008
  CONST_CAST(GLEW_ARB_robustness) = _glewSearchExtension("GL_ARB_robustness", extStart, extEnd);
10009
  if (glewExperimental || GLEW_ARB_robustness) CONST_CAST(GLEW_ARB_robustness) = !_glewInit_GL_ARB_robustness(GLEW_CONTEXT_ARG_VAR_INIT);
10010
#endif /* GL_ARB_robustness */
10011
#ifdef GL_ARB_robustness_application_isolation
10012
  CONST_CAST(GLEW_ARB_robustness_application_isolation) = _glewSearchExtension("GL_ARB_robustness_application_isolation", extStart, extEnd);
10013
#endif /* GL_ARB_robustness_application_isolation */
10014
#ifdef GL_ARB_robustness_share_group_isolation
10015
  CONST_CAST(GLEW_ARB_robustness_share_group_isolation) = _glewSearchExtension("GL_ARB_robustness_share_group_isolation", extStart, extEnd);
10016
#endif /* GL_ARB_robustness_share_group_isolation */
10017
#ifdef GL_ARB_sample_shading
10018
  CONST_CAST(GLEW_ARB_sample_shading) = _glewSearchExtension("GL_ARB_sample_shading", extStart, extEnd);
10019
  if (glewExperimental || GLEW_ARB_sample_shading) CONST_CAST(GLEW_ARB_sample_shading) = !_glewInit_GL_ARB_sample_shading(GLEW_CONTEXT_ARG_VAR_INIT);
10020
#endif /* GL_ARB_sample_shading */
10021
#ifdef GL_ARB_sampler_objects
10022
  CONST_CAST(GLEW_ARB_sampler_objects) = _glewSearchExtension("GL_ARB_sampler_objects", extStart, extEnd);
10023
  if (glewExperimental || GLEW_ARB_sampler_objects) CONST_CAST(GLEW_ARB_sampler_objects) = !_glewInit_GL_ARB_sampler_objects(GLEW_CONTEXT_ARG_VAR_INIT);
10024
#endif /* GL_ARB_sampler_objects */
10025
#ifdef GL_ARB_seamless_cube_map
10026
  CONST_CAST(GLEW_ARB_seamless_cube_map) = _glewSearchExtension("GL_ARB_seamless_cube_map", extStart, extEnd);
10027
#endif /* GL_ARB_seamless_cube_map */
677 janba 10028
#ifdef GL_ARB_seamless_cubemap_per_texture
10029
  CONST_CAST(GLEW_ARB_seamless_cubemap_per_texture) = _glewSearchExtension("GL_ARB_seamless_cubemap_per_texture", extStart, extEnd);
10030
#endif /* GL_ARB_seamless_cubemap_per_texture */
667 khor 10031
#ifdef GL_ARB_separate_shader_objects
10032
  CONST_CAST(GLEW_ARB_separate_shader_objects) = _glewSearchExtension("GL_ARB_separate_shader_objects", extStart, extEnd);
10033
  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);
10034
#endif /* GL_ARB_separate_shader_objects */
10035
#ifdef GL_ARB_shader_atomic_counters
10036
  CONST_CAST(GLEW_ARB_shader_atomic_counters) = _glewSearchExtension("GL_ARB_shader_atomic_counters", extStart, extEnd);
10037
  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);
10038
#endif /* GL_ARB_shader_atomic_counters */
10039
#ifdef GL_ARB_shader_bit_encoding
10040
  CONST_CAST(GLEW_ARB_shader_bit_encoding) = _glewSearchExtension("GL_ARB_shader_bit_encoding", extStart, extEnd);
10041
#endif /* GL_ARB_shader_bit_encoding */
677 janba 10042
#ifdef GL_ARB_shader_draw_parameters
10043
  CONST_CAST(GLEW_ARB_shader_draw_parameters) = _glewSearchExtension("GL_ARB_shader_draw_parameters", extStart, extEnd);
10044
#endif /* GL_ARB_shader_draw_parameters */
10045
#ifdef GL_ARB_shader_group_vote
10046
  CONST_CAST(GLEW_ARB_shader_group_vote) = _glewSearchExtension("GL_ARB_shader_group_vote", extStart, extEnd);
10047
#endif /* GL_ARB_shader_group_vote */
667 khor 10048
#ifdef GL_ARB_shader_image_load_store
10049
  CONST_CAST(GLEW_ARB_shader_image_load_store) = _glewSearchExtension("GL_ARB_shader_image_load_store", extStart, extEnd);
10050
  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);
10051
#endif /* GL_ARB_shader_image_load_store */
10052
#ifdef GL_ARB_shader_image_size
10053
  CONST_CAST(GLEW_ARB_shader_image_size) = _glewSearchExtension("GL_ARB_shader_image_size", extStart, extEnd);
10054
#endif /* GL_ARB_shader_image_size */
10055
#ifdef GL_ARB_shader_objects
10056
  CONST_CAST(GLEW_ARB_shader_objects) = _glewSearchExtension("GL_ARB_shader_objects", extStart, extEnd);
10057
  if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
10058
#endif /* GL_ARB_shader_objects */
10059
#ifdef GL_ARB_shader_precision
10060
  CONST_CAST(GLEW_ARB_shader_precision) = _glewSearchExtension("GL_ARB_shader_precision", extStart, extEnd);
10061
#endif /* GL_ARB_shader_precision */
10062
#ifdef GL_ARB_shader_stencil_export
10063
  CONST_CAST(GLEW_ARB_shader_stencil_export) = _glewSearchExtension("GL_ARB_shader_stencil_export", extStart, extEnd);
10064
#endif /* GL_ARB_shader_stencil_export */
10065
#ifdef GL_ARB_shader_storage_buffer_object
10066
  CONST_CAST(GLEW_ARB_shader_storage_buffer_object) = _glewSearchExtension("GL_ARB_shader_storage_buffer_object", extStart, extEnd);
10067
  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);
10068
#endif /* GL_ARB_shader_storage_buffer_object */
10069
#ifdef GL_ARB_shader_subroutine
10070
  CONST_CAST(GLEW_ARB_shader_subroutine) = _glewSearchExtension("GL_ARB_shader_subroutine", extStart, extEnd);
10071
  if (glewExperimental || GLEW_ARB_shader_subroutine) CONST_CAST(GLEW_ARB_shader_subroutine) = !_glewInit_GL_ARB_shader_subroutine(GLEW_CONTEXT_ARG_VAR_INIT);
10072
#endif /* GL_ARB_shader_subroutine */
10073
#ifdef GL_ARB_shader_texture_lod
10074
  CONST_CAST(GLEW_ARB_shader_texture_lod) = _glewSearchExtension("GL_ARB_shader_texture_lod", extStart, extEnd);
10075
#endif /* GL_ARB_shader_texture_lod */
10076
#ifdef GL_ARB_shading_language_100
10077
  CONST_CAST(GLEW_ARB_shading_language_100) = _glewSearchExtension("GL_ARB_shading_language_100", extStart, extEnd);
10078
#endif /* GL_ARB_shading_language_100 */
10079
#ifdef GL_ARB_shading_language_420pack
10080
  CONST_CAST(GLEW_ARB_shading_language_420pack) = _glewSearchExtension("GL_ARB_shading_language_420pack", extStart, extEnd);
10081
#endif /* GL_ARB_shading_language_420pack */
10082
#ifdef GL_ARB_shading_language_include
10083
  CONST_CAST(GLEW_ARB_shading_language_include) = _glewSearchExtension("GL_ARB_shading_language_include", extStart, extEnd);
10084
  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);
10085
#endif /* GL_ARB_shading_language_include */
10086
#ifdef GL_ARB_shading_language_packing
10087
  CONST_CAST(GLEW_ARB_shading_language_packing) = _glewSearchExtension("GL_ARB_shading_language_packing", extStart, extEnd);
10088
#endif /* GL_ARB_shading_language_packing */
10089
#ifdef GL_ARB_shadow
10090
  CONST_CAST(GLEW_ARB_shadow) = _glewSearchExtension("GL_ARB_shadow", extStart, extEnd);
10091
#endif /* GL_ARB_shadow */
10092
#ifdef GL_ARB_shadow_ambient
10093
  CONST_CAST(GLEW_ARB_shadow_ambient) = _glewSearchExtension("GL_ARB_shadow_ambient", extStart, extEnd);
10094
#endif /* GL_ARB_shadow_ambient */
677 janba 10095
#ifdef GL_ARB_sparse_texture
10096
  CONST_CAST(GLEW_ARB_sparse_texture) = _glewSearchExtension("GL_ARB_sparse_texture", extStart, extEnd);
10097
  if (glewExperimental || GLEW_ARB_sparse_texture) CONST_CAST(GLEW_ARB_sparse_texture) = !_glewInit_GL_ARB_sparse_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10098
#endif /* GL_ARB_sparse_texture */
667 khor 10099
#ifdef GL_ARB_stencil_texturing
10100
  CONST_CAST(GLEW_ARB_stencil_texturing) = _glewSearchExtension("GL_ARB_stencil_texturing", extStart, extEnd);
10101
#endif /* GL_ARB_stencil_texturing */
10102
#ifdef GL_ARB_sync
10103
  CONST_CAST(GLEW_ARB_sync) = _glewSearchExtension("GL_ARB_sync", extStart, extEnd);
10104
  if (glewExperimental || GLEW_ARB_sync) CONST_CAST(GLEW_ARB_sync) = !_glewInit_GL_ARB_sync(GLEW_CONTEXT_ARG_VAR_INIT);
10105
#endif /* GL_ARB_sync */
10106
#ifdef GL_ARB_tessellation_shader
10107
  CONST_CAST(GLEW_ARB_tessellation_shader) = _glewSearchExtension("GL_ARB_tessellation_shader", extStart, extEnd);
10108
  if (glewExperimental || GLEW_ARB_tessellation_shader) CONST_CAST(GLEW_ARB_tessellation_shader) = !_glewInit_GL_ARB_tessellation_shader(GLEW_CONTEXT_ARG_VAR_INIT);
10109
#endif /* GL_ARB_tessellation_shader */
10110
#ifdef GL_ARB_texture_border_clamp
10111
  CONST_CAST(GLEW_ARB_texture_border_clamp) = _glewSearchExtension("GL_ARB_texture_border_clamp", extStart, extEnd);
10112
#endif /* GL_ARB_texture_border_clamp */
10113
#ifdef GL_ARB_texture_buffer_object
10114
  CONST_CAST(GLEW_ARB_texture_buffer_object) = _glewSearchExtension("GL_ARB_texture_buffer_object", extStart, extEnd);
10115
  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);
10116
#endif /* GL_ARB_texture_buffer_object */
10117
#ifdef GL_ARB_texture_buffer_object_rgb32
10118
  CONST_CAST(GLEW_ARB_texture_buffer_object_rgb32) = _glewSearchExtension("GL_ARB_texture_buffer_object_rgb32", extStart, extEnd);
10119
#endif /* GL_ARB_texture_buffer_object_rgb32 */
10120
#ifdef GL_ARB_texture_buffer_range
10121
  CONST_CAST(GLEW_ARB_texture_buffer_range) = _glewSearchExtension("GL_ARB_texture_buffer_range", extStart, extEnd);
10122
  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);
10123
#endif /* GL_ARB_texture_buffer_range */
10124
#ifdef GL_ARB_texture_compression
10125
  CONST_CAST(GLEW_ARB_texture_compression) = _glewSearchExtension("GL_ARB_texture_compression", extStart, extEnd);
10126
  if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);
10127
#endif /* GL_ARB_texture_compression */
10128
#ifdef GL_ARB_texture_compression_bptc
10129
  CONST_CAST(GLEW_ARB_texture_compression_bptc) = _glewSearchExtension("GL_ARB_texture_compression_bptc", extStart, extEnd);
10130
#endif /* GL_ARB_texture_compression_bptc */
10131
#ifdef GL_ARB_texture_compression_rgtc
10132
  CONST_CAST(GLEW_ARB_texture_compression_rgtc) = _glewSearchExtension("GL_ARB_texture_compression_rgtc", extStart, extEnd);
10133
#endif /* GL_ARB_texture_compression_rgtc */
10134
#ifdef GL_ARB_texture_cube_map
10135
  CONST_CAST(GLEW_ARB_texture_cube_map) = _glewSearchExtension("GL_ARB_texture_cube_map", extStart, extEnd);
10136
#endif /* GL_ARB_texture_cube_map */
10137
#ifdef GL_ARB_texture_cube_map_array
10138
  CONST_CAST(GLEW_ARB_texture_cube_map_array) = _glewSearchExtension("GL_ARB_texture_cube_map_array", extStart, extEnd);
10139
#endif /* GL_ARB_texture_cube_map_array */
10140
#ifdef GL_ARB_texture_env_add
10141
  CONST_CAST(GLEW_ARB_texture_env_add) = _glewSearchExtension("GL_ARB_texture_env_add", extStart, extEnd);
10142
#endif /* GL_ARB_texture_env_add */
10143
#ifdef GL_ARB_texture_env_combine
10144
  CONST_CAST(GLEW_ARB_texture_env_combine) = _glewSearchExtension("GL_ARB_texture_env_combine", extStart, extEnd);
10145
#endif /* GL_ARB_texture_env_combine */
10146
#ifdef GL_ARB_texture_env_crossbar
10147
  CONST_CAST(GLEW_ARB_texture_env_crossbar) = _glewSearchExtension("GL_ARB_texture_env_crossbar", extStart, extEnd);
10148
#endif /* GL_ARB_texture_env_crossbar */
10149
#ifdef GL_ARB_texture_env_dot3
10150
  CONST_CAST(GLEW_ARB_texture_env_dot3) = _glewSearchExtension("GL_ARB_texture_env_dot3", extStart, extEnd);
10151
#endif /* GL_ARB_texture_env_dot3 */
10152
#ifdef GL_ARB_texture_float
10153
  CONST_CAST(GLEW_ARB_texture_float) = _glewSearchExtension("GL_ARB_texture_float", extStart, extEnd);
10154
#endif /* GL_ARB_texture_float */
10155
#ifdef GL_ARB_texture_gather
10156
  CONST_CAST(GLEW_ARB_texture_gather) = _glewSearchExtension("GL_ARB_texture_gather", extStart, extEnd);
10157
#endif /* GL_ARB_texture_gather */
677 janba 10158
#ifdef GL_ARB_texture_mirror_clamp_to_edge
10159
  CONST_CAST(GLEW_ARB_texture_mirror_clamp_to_edge) = _glewSearchExtension("GL_ARB_texture_mirror_clamp_to_edge", extStart, extEnd);
10160
#endif /* GL_ARB_texture_mirror_clamp_to_edge */
667 khor 10161
#ifdef GL_ARB_texture_mirrored_repeat
10162
  CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = _glewSearchExtension("GL_ARB_texture_mirrored_repeat", extStart, extEnd);
10163
#endif /* GL_ARB_texture_mirrored_repeat */
10164
#ifdef GL_ARB_texture_multisample
10165
  CONST_CAST(GLEW_ARB_texture_multisample) = _glewSearchExtension("GL_ARB_texture_multisample", extStart, extEnd);
10166
  if (glewExperimental || GLEW_ARB_texture_multisample) CONST_CAST(GLEW_ARB_texture_multisample) = !_glewInit_GL_ARB_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10167
#endif /* GL_ARB_texture_multisample */
10168
#ifdef GL_ARB_texture_non_power_of_two
10169
  CONST_CAST(GLEW_ARB_texture_non_power_of_two) = _glewSearchExtension("GL_ARB_texture_non_power_of_two", extStart, extEnd);
10170
#endif /* GL_ARB_texture_non_power_of_two */
10171
#ifdef GL_ARB_texture_query_levels
10172
  CONST_CAST(GLEW_ARB_texture_query_levels) = _glewSearchExtension("GL_ARB_texture_query_levels", extStart, extEnd);
10173
#endif /* GL_ARB_texture_query_levels */
10174
#ifdef GL_ARB_texture_query_lod
10175
  CONST_CAST(GLEW_ARB_texture_query_lod) = _glewSearchExtension("GL_ARB_texture_query_lod", extStart, extEnd);
10176
#endif /* GL_ARB_texture_query_lod */
10177
#ifdef GL_ARB_texture_rectangle
10178
  CONST_CAST(GLEW_ARB_texture_rectangle) = _glewSearchExtension("GL_ARB_texture_rectangle", extStart, extEnd);
10179
#endif /* GL_ARB_texture_rectangle */
10180
#ifdef GL_ARB_texture_rg
10181
  CONST_CAST(GLEW_ARB_texture_rg) = _glewSearchExtension("GL_ARB_texture_rg", extStart, extEnd);
10182
#endif /* GL_ARB_texture_rg */
10183
#ifdef GL_ARB_texture_rgb10_a2ui
10184
  CONST_CAST(GLEW_ARB_texture_rgb10_a2ui) = _glewSearchExtension("GL_ARB_texture_rgb10_a2ui", extStart, extEnd);
10185
#endif /* GL_ARB_texture_rgb10_a2ui */
677 janba 10186
#ifdef GL_ARB_texture_stencil8
10187
  CONST_CAST(GLEW_ARB_texture_stencil8) = _glewSearchExtension("GL_ARB_texture_stencil8", extStart, extEnd);
10188
#endif /* GL_ARB_texture_stencil8 */
667 khor 10189
#ifdef GL_ARB_texture_storage
10190
  CONST_CAST(GLEW_ARB_texture_storage) = _glewSearchExtension("GL_ARB_texture_storage", extStart, extEnd);
10191
  if (glewExperimental || GLEW_ARB_texture_storage) CONST_CAST(GLEW_ARB_texture_storage) = !_glewInit_GL_ARB_texture_storage(GLEW_CONTEXT_ARG_VAR_INIT);
10192
#endif /* GL_ARB_texture_storage */
10193
#ifdef GL_ARB_texture_storage_multisample
10194
  CONST_CAST(GLEW_ARB_texture_storage_multisample) = _glewSearchExtension("GL_ARB_texture_storage_multisample", extStart, extEnd);
10195
  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);
10196
#endif /* GL_ARB_texture_storage_multisample */
10197
#ifdef GL_ARB_texture_swizzle
10198
  CONST_CAST(GLEW_ARB_texture_swizzle) = _glewSearchExtension("GL_ARB_texture_swizzle", extStart, extEnd);
10199
#endif /* GL_ARB_texture_swizzle */
10200
#ifdef GL_ARB_texture_view
10201
  CONST_CAST(GLEW_ARB_texture_view) = _glewSearchExtension("GL_ARB_texture_view", extStart, extEnd);
10202
  if (glewExperimental || GLEW_ARB_texture_view) CONST_CAST(GLEW_ARB_texture_view) = !_glewInit_GL_ARB_texture_view(GLEW_CONTEXT_ARG_VAR_INIT);
10203
#endif /* GL_ARB_texture_view */
10204
#ifdef GL_ARB_timer_query
10205
  CONST_CAST(GLEW_ARB_timer_query) = _glewSearchExtension("GL_ARB_timer_query", extStart, extEnd);
10206
  if (glewExperimental || GLEW_ARB_timer_query) CONST_CAST(GLEW_ARB_timer_query) = !_glewInit_GL_ARB_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
10207
#endif /* GL_ARB_timer_query */
10208
#ifdef GL_ARB_transform_feedback2
10209
  CONST_CAST(GLEW_ARB_transform_feedback2) = _glewSearchExtension("GL_ARB_transform_feedback2", extStart, extEnd);
10210
  if (glewExperimental || GLEW_ARB_transform_feedback2) CONST_CAST(GLEW_ARB_transform_feedback2) = !_glewInit_GL_ARB_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
10211
#endif /* GL_ARB_transform_feedback2 */
10212
#ifdef GL_ARB_transform_feedback3
10213
  CONST_CAST(GLEW_ARB_transform_feedback3) = _glewSearchExtension("GL_ARB_transform_feedback3", extStart, extEnd);
10214
  if (glewExperimental || GLEW_ARB_transform_feedback3) CONST_CAST(GLEW_ARB_transform_feedback3) = !_glewInit_GL_ARB_transform_feedback3(GLEW_CONTEXT_ARG_VAR_INIT);
10215
#endif /* GL_ARB_transform_feedback3 */
10216
#ifdef GL_ARB_transform_feedback_instanced
10217
  CONST_CAST(GLEW_ARB_transform_feedback_instanced) = _glewSearchExtension("GL_ARB_transform_feedback_instanced", extStart, extEnd);
10218
  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);
10219
#endif /* GL_ARB_transform_feedback_instanced */
10220
#ifdef GL_ARB_transpose_matrix
10221
  CONST_CAST(GLEW_ARB_transpose_matrix) = _glewSearchExtension("GL_ARB_transpose_matrix", extStart, extEnd);
10222
  if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT);
10223
#endif /* GL_ARB_transpose_matrix */
10224
#ifdef GL_ARB_uniform_buffer_object
10225
  CONST_CAST(GLEW_ARB_uniform_buffer_object) = _glewSearchExtension("GL_ARB_uniform_buffer_object", extStart, extEnd);
10226
  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);
10227
#endif /* GL_ARB_uniform_buffer_object */
10228
#ifdef GL_ARB_vertex_array_bgra
10229
  CONST_CAST(GLEW_ARB_vertex_array_bgra) = _glewSearchExtension("GL_ARB_vertex_array_bgra", extStart, extEnd);
10230
#endif /* GL_ARB_vertex_array_bgra */
10231
#ifdef GL_ARB_vertex_array_object
10232
  CONST_CAST(GLEW_ARB_vertex_array_object) = _glewSearchExtension("GL_ARB_vertex_array_object", extStart, extEnd);
10233
  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);
10234
#endif /* GL_ARB_vertex_array_object */
10235
#ifdef GL_ARB_vertex_attrib_64bit
10236
  CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = _glewSearchExtension("GL_ARB_vertex_attrib_64bit", extStart, extEnd);
10237
  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);
10238
#endif /* GL_ARB_vertex_attrib_64bit */
10239
#ifdef GL_ARB_vertex_attrib_binding
10240
  CONST_CAST(GLEW_ARB_vertex_attrib_binding) = _glewSearchExtension("GL_ARB_vertex_attrib_binding", extStart, extEnd);
10241
  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);
10242
#endif /* GL_ARB_vertex_attrib_binding */
10243
#ifdef GL_ARB_vertex_blend
10244
  CONST_CAST(GLEW_ARB_vertex_blend) = _glewSearchExtension("GL_ARB_vertex_blend", extStart, extEnd);
10245
  if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT);
10246
#endif /* GL_ARB_vertex_blend */
10247
#ifdef GL_ARB_vertex_buffer_object
10248
  CONST_CAST(GLEW_ARB_vertex_buffer_object) = _glewSearchExtension("GL_ARB_vertex_buffer_object", extStart, extEnd);
10249
  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);
10250
#endif /* GL_ARB_vertex_buffer_object */
10251
#ifdef GL_ARB_vertex_program
10252
  CONST_CAST(GLEW_ARB_vertex_program) = _glewSearchExtension("GL_ARB_vertex_program", extStart, extEnd);
10253
  if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
10254
#endif /* GL_ARB_vertex_program */
10255
#ifdef GL_ARB_vertex_shader
10256
  CONST_CAST(GLEW_ARB_vertex_shader) = _glewSearchExtension("GL_ARB_vertex_shader", extStart, extEnd);
10257
  if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
10258
#endif /* GL_ARB_vertex_shader */
677 janba 10259
#ifdef GL_ARB_vertex_type_10f_11f_11f_rev
10260
  CONST_CAST(GLEW_ARB_vertex_type_10f_11f_11f_rev) = _glewSearchExtension("GL_ARB_vertex_type_10f_11f_11f_rev", extStart, extEnd);
10261
#endif /* GL_ARB_vertex_type_10f_11f_11f_rev */
667 khor 10262
#ifdef GL_ARB_vertex_type_2_10_10_10_rev
10263
  CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = _glewSearchExtension("GL_ARB_vertex_type_2_10_10_10_rev", extStart, extEnd);
10264
  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);
10265
#endif /* GL_ARB_vertex_type_2_10_10_10_rev */
10266
#ifdef GL_ARB_viewport_array
10267
  CONST_CAST(GLEW_ARB_viewport_array) = _glewSearchExtension("GL_ARB_viewport_array", extStart, extEnd);
10268
  if (glewExperimental || GLEW_ARB_viewport_array) CONST_CAST(GLEW_ARB_viewport_array) = !_glewInit_GL_ARB_viewport_array(GLEW_CONTEXT_ARG_VAR_INIT);
10269
#endif /* GL_ARB_viewport_array */
10270
#ifdef GL_ARB_window_pos
10271
  CONST_CAST(GLEW_ARB_window_pos) = _glewSearchExtension("GL_ARB_window_pos", extStart, extEnd);
10272
  if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
10273
#endif /* GL_ARB_window_pos */
10274
#ifdef GL_ATIX_point_sprites
10275
  CONST_CAST(GLEW_ATIX_point_sprites) = _glewSearchExtension("GL_ATIX_point_sprites", extStart, extEnd);
10276
#endif /* GL_ATIX_point_sprites */
10277
#ifdef GL_ATIX_texture_env_combine3
10278
  CONST_CAST(GLEW_ATIX_texture_env_combine3) = _glewSearchExtension("GL_ATIX_texture_env_combine3", extStart, extEnd);
10279
#endif /* GL_ATIX_texture_env_combine3 */
10280
#ifdef GL_ATIX_texture_env_route
10281
  CONST_CAST(GLEW_ATIX_texture_env_route) = _glewSearchExtension("GL_ATIX_texture_env_route", extStart, extEnd);
10282
#endif /* GL_ATIX_texture_env_route */
10283
#ifdef GL_ATIX_vertex_shader_output_point_size
10284
  CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = _glewSearchExtension("GL_ATIX_vertex_shader_output_point_size", extStart, extEnd);
10285
#endif /* GL_ATIX_vertex_shader_output_point_size */
10286
#ifdef GL_ATI_draw_buffers
10287
  CONST_CAST(GLEW_ATI_draw_buffers) = _glewSearchExtension("GL_ATI_draw_buffers", extStart, extEnd);
10288
  if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
10289
#endif /* GL_ATI_draw_buffers */
10290
#ifdef GL_ATI_element_array
10291
  CONST_CAST(GLEW_ATI_element_array) = _glewSearchExtension("GL_ATI_element_array", extStart, extEnd);
10292
  if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT);
10293
#endif /* GL_ATI_element_array */
10294
#ifdef GL_ATI_envmap_bumpmap
10295
  CONST_CAST(GLEW_ATI_envmap_bumpmap) = _glewSearchExtension("GL_ATI_envmap_bumpmap", extStart, extEnd);
10296
  if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT);
10297
#endif /* GL_ATI_envmap_bumpmap */
10298
#ifdef GL_ATI_fragment_shader
10299
  CONST_CAST(GLEW_ATI_fragment_shader) = _glewSearchExtension("GL_ATI_fragment_shader", extStart, extEnd);
10300
  if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);
10301
#endif /* GL_ATI_fragment_shader */
10302
#ifdef GL_ATI_map_object_buffer
10303
  CONST_CAST(GLEW_ATI_map_object_buffer) = _glewSearchExtension("GL_ATI_map_object_buffer", extStart, extEnd);
10304
  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);
10305
#endif /* GL_ATI_map_object_buffer */
10306
#ifdef GL_ATI_meminfo
10307
  CONST_CAST(GLEW_ATI_meminfo) = _glewSearchExtension("GL_ATI_meminfo", extStart, extEnd);
10308
#endif /* GL_ATI_meminfo */
10309
#ifdef GL_ATI_pn_triangles
10310
  CONST_CAST(GLEW_ATI_pn_triangles) = _glewSearchExtension("GL_ATI_pn_triangles", extStart, extEnd);
10311
  if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);
10312
#endif /* GL_ATI_pn_triangles */
10313
#ifdef GL_ATI_separate_stencil
10314
  CONST_CAST(GLEW_ATI_separate_stencil) = _glewSearchExtension("GL_ATI_separate_stencil", extStart, extEnd);
10315
  if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT);
10316
#endif /* GL_ATI_separate_stencil */
10317
#ifdef GL_ATI_shader_texture_lod
10318
  CONST_CAST(GLEW_ATI_shader_texture_lod) = _glewSearchExtension("GL_ATI_shader_texture_lod", extStart, extEnd);
10319
#endif /* GL_ATI_shader_texture_lod */
10320
#ifdef GL_ATI_text_fragment_shader
10321
  CONST_CAST(GLEW_ATI_text_fragment_shader) = _glewSearchExtension("GL_ATI_text_fragment_shader", extStart, extEnd);
10322
#endif /* GL_ATI_text_fragment_shader */
10323
#ifdef GL_ATI_texture_compression_3dc
10324
  CONST_CAST(GLEW_ATI_texture_compression_3dc) = _glewSearchExtension("GL_ATI_texture_compression_3dc", extStart, extEnd);
10325
#endif /* GL_ATI_texture_compression_3dc */
10326
#ifdef GL_ATI_texture_env_combine3
10327
  CONST_CAST(GLEW_ATI_texture_env_combine3) = _glewSearchExtension("GL_ATI_texture_env_combine3", extStart, extEnd);
10328
#endif /* GL_ATI_texture_env_combine3 */
10329
#ifdef GL_ATI_texture_float
10330
  CONST_CAST(GLEW_ATI_texture_float) = _glewSearchExtension("GL_ATI_texture_float", extStart, extEnd);
10331
#endif /* GL_ATI_texture_float */
10332
#ifdef GL_ATI_texture_mirror_once
10333
  CONST_CAST(GLEW_ATI_texture_mirror_once) = _glewSearchExtension("GL_ATI_texture_mirror_once", extStart, extEnd);
10334
#endif /* GL_ATI_texture_mirror_once */
10335
#ifdef GL_ATI_vertex_array_object
10336
  CONST_CAST(GLEW_ATI_vertex_array_object) = _glewSearchExtension("GL_ATI_vertex_array_object", extStart, extEnd);
10337
  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);
10338
#endif /* GL_ATI_vertex_array_object */
10339
#ifdef GL_ATI_vertex_attrib_array_object
10340
  CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = _glewSearchExtension("GL_ATI_vertex_attrib_array_object", extStart, extEnd);
10341
  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);
10342
#endif /* GL_ATI_vertex_attrib_array_object */
10343
#ifdef GL_ATI_vertex_streams
10344
  CONST_CAST(GLEW_ATI_vertex_streams) = _glewSearchExtension("GL_ATI_vertex_streams", extStart, extEnd);
10345
  if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT);
10346
#endif /* GL_ATI_vertex_streams */
10347
#ifdef GL_EXT_422_pixels
10348
  CONST_CAST(GLEW_EXT_422_pixels) = _glewSearchExtension("GL_EXT_422_pixels", extStart, extEnd);
10349
#endif /* GL_EXT_422_pixels */
10350
#ifdef GL_EXT_Cg_shader
10351
  CONST_CAST(GLEW_EXT_Cg_shader) = _glewSearchExtension("GL_EXT_Cg_shader", extStart, extEnd);
10352
#endif /* GL_EXT_Cg_shader */
10353
#ifdef GL_EXT_abgr
10354
  CONST_CAST(GLEW_EXT_abgr) = _glewSearchExtension("GL_EXT_abgr", extStart, extEnd);
10355
#endif /* GL_EXT_abgr */
10356
#ifdef GL_EXT_bgra
10357
  CONST_CAST(GLEW_EXT_bgra) = _glewSearchExtension("GL_EXT_bgra", extStart, extEnd);
10358
#endif /* GL_EXT_bgra */
10359
#ifdef GL_EXT_bindable_uniform
10360
  CONST_CAST(GLEW_EXT_bindable_uniform) = _glewSearchExtension("GL_EXT_bindable_uniform", extStart, extEnd);
10361
  if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT);
10362
#endif /* GL_EXT_bindable_uniform */
10363
#ifdef GL_EXT_blend_color
10364
  CONST_CAST(GLEW_EXT_blend_color) = _glewSearchExtension("GL_EXT_blend_color", extStart, extEnd);
10365
  if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT);
10366
#endif /* GL_EXT_blend_color */
10367
#ifdef GL_EXT_blend_equation_separate
10368
  CONST_CAST(GLEW_EXT_blend_equation_separate) = _glewSearchExtension("GL_EXT_blend_equation_separate", extStart, extEnd);
10369
  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);
10370
#endif /* GL_EXT_blend_equation_separate */
10371
#ifdef GL_EXT_blend_func_separate
10372
  CONST_CAST(GLEW_EXT_blend_func_separate) = _glewSearchExtension("GL_EXT_blend_func_separate", extStart, extEnd);
10373
  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);
10374
#endif /* GL_EXT_blend_func_separate */
10375
#ifdef GL_EXT_blend_logic_op
10376
  CONST_CAST(GLEW_EXT_blend_logic_op) = _glewSearchExtension("GL_EXT_blend_logic_op", extStart, extEnd);
10377
#endif /* GL_EXT_blend_logic_op */
10378
#ifdef GL_EXT_blend_minmax
10379
  CONST_CAST(GLEW_EXT_blend_minmax) = _glewSearchExtension("GL_EXT_blend_minmax", extStart, extEnd);
10380
  if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT);
10381
#endif /* GL_EXT_blend_minmax */
10382
#ifdef GL_EXT_blend_subtract
10383
  CONST_CAST(GLEW_EXT_blend_subtract) = _glewSearchExtension("GL_EXT_blend_subtract", extStart, extEnd);
10384
#endif /* GL_EXT_blend_subtract */
10385
#ifdef GL_EXT_clip_volume_hint
10386
  CONST_CAST(GLEW_EXT_clip_volume_hint) = _glewSearchExtension("GL_EXT_clip_volume_hint", extStart, extEnd);
10387
#endif /* GL_EXT_clip_volume_hint */
10388
#ifdef GL_EXT_cmyka
10389
  CONST_CAST(GLEW_EXT_cmyka) = _glewSearchExtension("GL_EXT_cmyka", extStart, extEnd);
10390
#endif /* GL_EXT_cmyka */
10391
#ifdef GL_EXT_color_subtable
10392
  CONST_CAST(GLEW_EXT_color_subtable) = _glewSearchExtension("GL_EXT_color_subtable", extStart, extEnd);
10393
  if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT);
10394
#endif /* GL_EXT_color_subtable */
10395
#ifdef GL_EXT_compiled_vertex_array
10396
  CONST_CAST(GLEW_EXT_compiled_vertex_array) = _glewSearchExtension("GL_EXT_compiled_vertex_array", extStart, extEnd);
10397
  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);
10398
#endif /* GL_EXT_compiled_vertex_array */
10399
#ifdef GL_EXT_convolution
10400
  CONST_CAST(GLEW_EXT_convolution) = _glewSearchExtension("GL_EXT_convolution", extStart, extEnd);
10401
  if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT);
10402
#endif /* GL_EXT_convolution */
10403
#ifdef GL_EXT_coordinate_frame
10404
  CONST_CAST(GLEW_EXT_coordinate_frame) = _glewSearchExtension("GL_EXT_coordinate_frame", extStart, extEnd);
10405
  if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT);
10406
#endif /* GL_EXT_coordinate_frame */
10407
#ifdef GL_EXT_copy_texture
10408
  CONST_CAST(GLEW_EXT_copy_texture) = _glewSearchExtension("GL_EXT_copy_texture", extStart, extEnd);
10409
  if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10410
#endif /* GL_EXT_copy_texture */
10411
#ifdef GL_EXT_cull_vertex
10412
  CONST_CAST(GLEW_EXT_cull_vertex) = _glewSearchExtension("GL_EXT_cull_vertex", extStart, extEnd);
10413
  if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
10414
#endif /* GL_EXT_cull_vertex */
10415
#ifdef GL_EXT_debug_marker
10416
  CONST_CAST(GLEW_EXT_debug_marker) = _glewSearchExtension("GL_EXT_debug_marker", extStart, extEnd);
10417
  if (glewExperimental || GLEW_EXT_debug_marker) CONST_CAST(GLEW_EXT_debug_marker) = !_glewInit_GL_EXT_debug_marker(GLEW_CONTEXT_ARG_VAR_INIT);
10418
#endif /* GL_EXT_debug_marker */
10419
#ifdef GL_EXT_depth_bounds_test
10420
  CONST_CAST(GLEW_EXT_depth_bounds_test) = _glewSearchExtension("GL_EXT_depth_bounds_test", extStart, extEnd);
10421
  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);
10422
#endif /* GL_EXT_depth_bounds_test */
10423
#ifdef GL_EXT_direct_state_access
10424
  CONST_CAST(GLEW_EXT_direct_state_access) = _glewSearchExtension("GL_EXT_direct_state_access", extStart, extEnd);
10425
  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);
10426
#endif /* GL_EXT_direct_state_access */
10427
#ifdef GL_EXT_draw_buffers2
10428
  CONST_CAST(GLEW_EXT_draw_buffers2) = _glewSearchExtension("GL_EXT_draw_buffers2", extStart, extEnd);
10429
  if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT);
10430
#endif /* GL_EXT_draw_buffers2 */
10431
#ifdef GL_EXT_draw_instanced
10432
  CONST_CAST(GLEW_EXT_draw_instanced) = _glewSearchExtension("GL_EXT_draw_instanced", extStart, extEnd);
10433
  if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);
10434
#endif /* GL_EXT_draw_instanced */
10435
#ifdef GL_EXT_draw_range_elements
10436
  CONST_CAST(GLEW_EXT_draw_range_elements) = _glewSearchExtension("GL_EXT_draw_range_elements", extStart, extEnd);
10437
  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);
10438
#endif /* GL_EXT_draw_range_elements */
10439
#ifdef GL_EXT_fog_coord
10440
  CONST_CAST(GLEW_EXT_fog_coord) = _glewSearchExtension("GL_EXT_fog_coord", extStart, extEnd);
10441
  if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT);
10442
#endif /* GL_EXT_fog_coord */
10443
#ifdef GL_EXT_fragment_lighting
10444
  CONST_CAST(GLEW_EXT_fragment_lighting) = _glewSearchExtension("GL_EXT_fragment_lighting", extStart, extEnd);
10445
  if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT);
10446
#endif /* GL_EXT_fragment_lighting */
10447
#ifdef GL_EXT_framebuffer_blit
10448
  CONST_CAST(GLEW_EXT_framebuffer_blit) = _glewSearchExtension("GL_EXT_framebuffer_blit", extStart, extEnd);
10449
  if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT);
10450
#endif /* GL_EXT_framebuffer_blit */
10451
#ifdef GL_EXT_framebuffer_multisample
10452
  CONST_CAST(GLEW_EXT_framebuffer_multisample) = _glewSearchExtension("GL_EXT_framebuffer_multisample", extStart, extEnd);
10453
  if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10454
#endif /* GL_EXT_framebuffer_multisample */
10455
#ifdef GL_EXT_framebuffer_multisample_blit_scaled
10456
  CONST_CAST(GLEW_EXT_framebuffer_multisample_blit_scaled) = _glewSearchExtension("GL_EXT_framebuffer_multisample_blit_scaled", extStart, extEnd);
10457
#endif /* GL_EXT_framebuffer_multisample_blit_scaled */
10458
#ifdef GL_EXT_framebuffer_object
10459
  CONST_CAST(GLEW_EXT_framebuffer_object) = _glewSearchExtension("GL_EXT_framebuffer_object", extStart, extEnd);
10460
  if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
10461
#endif /* GL_EXT_framebuffer_object */
10462
#ifdef GL_EXT_framebuffer_sRGB
10463
  CONST_CAST(GLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GL_EXT_framebuffer_sRGB", extStart, extEnd);
10464
#endif /* GL_EXT_framebuffer_sRGB */
10465
#ifdef GL_EXT_geometry_shader4
10466
  CONST_CAST(GLEW_EXT_geometry_shader4) = _glewSearchExtension("GL_EXT_geometry_shader4", extStart, extEnd);
10467
  if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
10468
#endif /* GL_EXT_geometry_shader4 */
10469
#ifdef GL_EXT_gpu_program_parameters
10470
  CONST_CAST(GLEW_EXT_gpu_program_parameters) = _glewSearchExtension("GL_EXT_gpu_program_parameters", extStart, extEnd);
10471
  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);
10472
#endif /* GL_EXT_gpu_program_parameters */
10473
#ifdef GL_EXT_gpu_shader4
10474
  CONST_CAST(GLEW_EXT_gpu_shader4) = _glewSearchExtension("GL_EXT_gpu_shader4", extStart, extEnd);
10475
  if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
10476
#endif /* GL_EXT_gpu_shader4 */
10477
#ifdef GL_EXT_histogram
10478
  CONST_CAST(GLEW_EXT_histogram) = _glewSearchExtension("GL_EXT_histogram", extStart, extEnd);
10479
  if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT);
10480
#endif /* GL_EXT_histogram */
10481
#ifdef GL_EXT_index_array_formats
10482
  CONST_CAST(GLEW_EXT_index_array_formats) = _glewSearchExtension("GL_EXT_index_array_formats", extStart, extEnd);
10483
#endif /* GL_EXT_index_array_formats */
10484
#ifdef GL_EXT_index_func
10485
  CONST_CAST(GLEW_EXT_index_func) = _glewSearchExtension("GL_EXT_index_func", extStart, extEnd);
10486
  if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT);
10487
#endif /* GL_EXT_index_func */
10488
#ifdef GL_EXT_index_material
10489
  CONST_CAST(GLEW_EXT_index_material) = _glewSearchExtension("GL_EXT_index_material", extStart, extEnd);
10490
  if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT);
10491
#endif /* GL_EXT_index_material */
10492
#ifdef GL_EXT_index_texture
10493
  CONST_CAST(GLEW_EXT_index_texture) = _glewSearchExtension("GL_EXT_index_texture", extStart, extEnd);
10494
#endif /* GL_EXT_index_texture */
10495
#ifdef GL_EXT_light_texture
10496
  CONST_CAST(GLEW_EXT_light_texture) = _glewSearchExtension("GL_EXT_light_texture", extStart, extEnd);
10497
  if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10498
#endif /* GL_EXT_light_texture */
10499
#ifdef GL_EXT_misc_attribute
10500
  CONST_CAST(GLEW_EXT_misc_attribute) = _glewSearchExtension("GL_EXT_misc_attribute", extStart, extEnd);
10501
#endif /* GL_EXT_misc_attribute */
10502
#ifdef GL_EXT_multi_draw_arrays
10503
  CONST_CAST(GLEW_EXT_multi_draw_arrays) = _glewSearchExtension("GL_EXT_multi_draw_arrays", extStart, extEnd);
10504
  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);
10505
#endif /* GL_EXT_multi_draw_arrays */
10506
#ifdef GL_EXT_multisample
10507
  CONST_CAST(GLEW_EXT_multisample) = _glewSearchExtension("GL_EXT_multisample", extStart, extEnd);
10508
  if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10509
#endif /* GL_EXT_multisample */
10510
#ifdef GL_EXT_packed_depth_stencil
10511
  CONST_CAST(GLEW_EXT_packed_depth_stencil) = _glewSearchExtension("GL_EXT_packed_depth_stencil", extStart, extEnd);
10512
#endif /* GL_EXT_packed_depth_stencil */
10513
#ifdef GL_EXT_packed_float
10514
  CONST_CAST(GLEW_EXT_packed_float) = _glewSearchExtension("GL_EXT_packed_float", extStart, extEnd);
10515
#endif /* GL_EXT_packed_float */
10516
#ifdef GL_EXT_packed_pixels
10517
  CONST_CAST(GLEW_EXT_packed_pixels) = _glewSearchExtension("GL_EXT_packed_pixels", extStart, extEnd);
10518
#endif /* GL_EXT_packed_pixels */
10519
#ifdef GL_EXT_paletted_texture
10520
  CONST_CAST(GLEW_EXT_paletted_texture) = _glewSearchExtension("GL_EXT_paletted_texture", extStart, extEnd);
10521
  if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10522
#endif /* GL_EXT_paletted_texture */
10523
#ifdef GL_EXT_pixel_buffer_object
10524
  CONST_CAST(GLEW_EXT_pixel_buffer_object) = _glewSearchExtension("GL_EXT_pixel_buffer_object", extStart, extEnd);
10525
#endif /* GL_EXT_pixel_buffer_object */
10526
#ifdef GL_EXT_pixel_transform
10527
  CONST_CAST(GLEW_EXT_pixel_transform) = _glewSearchExtension("GL_EXT_pixel_transform", extStart, extEnd);
10528
  if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT);
10529
#endif /* GL_EXT_pixel_transform */
10530
#ifdef GL_EXT_pixel_transform_color_table
10531
  CONST_CAST(GLEW_EXT_pixel_transform_color_table) = _glewSearchExtension("GL_EXT_pixel_transform_color_table", extStart, extEnd);
10532
#endif /* GL_EXT_pixel_transform_color_table */
10533
#ifdef GL_EXT_point_parameters
10534
  CONST_CAST(GLEW_EXT_point_parameters) = _glewSearchExtension("GL_EXT_point_parameters", extStart, extEnd);
10535
  if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
10536
#endif /* GL_EXT_point_parameters */
10537
#ifdef GL_EXT_polygon_offset
10538
  CONST_CAST(GLEW_EXT_polygon_offset) = _glewSearchExtension("GL_EXT_polygon_offset", extStart, extEnd);
10539
  if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);
10540
#endif /* GL_EXT_polygon_offset */
10541
#ifdef GL_EXT_provoking_vertex
10542
  CONST_CAST(GLEW_EXT_provoking_vertex) = _glewSearchExtension("GL_EXT_provoking_vertex", extStart, extEnd);
10543
  if (glewExperimental || GLEW_EXT_provoking_vertex) CONST_CAST(GLEW_EXT_provoking_vertex) = !_glewInit_GL_EXT_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
10544
#endif /* GL_EXT_provoking_vertex */
10545
#ifdef GL_EXT_rescale_normal
10546
  CONST_CAST(GLEW_EXT_rescale_normal) = _glewSearchExtension("GL_EXT_rescale_normal", extStart, extEnd);
10547
#endif /* GL_EXT_rescale_normal */
10548
#ifdef GL_EXT_scene_marker
10549
  CONST_CAST(GLEW_EXT_scene_marker) = _glewSearchExtension("GL_EXT_scene_marker", extStart, extEnd);
10550
  if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT);
10551
#endif /* GL_EXT_scene_marker */
10552
#ifdef GL_EXT_secondary_color
10553
  CONST_CAST(GLEW_EXT_secondary_color) = _glewSearchExtension("GL_EXT_secondary_color", extStart, extEnd);
10554
  if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);
10555
#endif /* GL_EXT_secondary_color */
10556
#ifdef GL_EXT_separate_shader_objects
10557
  CONST_CAST(GLEW_EXT_separate_shader_objects) = _glewSearchExtension("GL_EXT_separate_shader_objects", extStart, extEnd);
10558
  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);
10559
#endif /* GL_EXT_separate_shader_objects */
10560
#ifdef GL_EXT_separate_specular_color
10561
  CONST_CAST(GLEW_EXT_separate_specular_color) = _glewSearchExtension("GL_EXT_separate_specular_color", extStart, extEnd);
10562
#endif /* GL_EXT_separate_specular_color */
10563
#ifdef GL_EXT_shader_image_load_store
10564
  CONST_CAST(GLEW_EXT_shader_image_load_store) = _glewSearchExtension("GL_EXT_shader_image_load_store", extStart, extEnd);
10565
  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);
10566
#endif /* GL_EXT_shader_image_load_store */
10567
#ifdef GL_EXT_shadow_funcs
10568
  CONST_CAST(GLEW_EXT_shadow_funcs) = _glewSearchExtension("GL_EXT_shadow_funcs", extStart, extEnd);
10569
#endif /* GL_EXT_shadow_funcs */
10570
#ifdef GL_EXT_shared_texture_palette
10571
  CONST_CAST(GLEW_EXT_shared_texture_palette) = _glewSearchExtension("GL_EXT_shared_texture_palette", extStart, extEnd);
10572
#endif /* GL_EXT_shared_texture_palette */
10573
#ifdef GL_EXT_stencil_clear_tag
10574
  CONST_CAST(GLEW_EXT_stencil_clear_tag) = _glewSearchExtension("GL_EXT_stencil_clear_tag", extStart, extEnd);
10575
#endif /* GL_EXT_stencil_clear_tag */
10576
#ifdef GL_EXT_stencil_two_side
10577
  CONST_CAST(GLEW_EXT_stencil_two_side) = _glewSearchExtension("GL_EXT_stencil_two_side", extStart, extEnd);
10578
  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);
10579
#endif /* GL_EXT_stencil_two_side */
10580
#ifdef GL_EXT_stencil_wrap
10581
  CONST_CAST(GLEW_EXT_stencil_wrap) = _glewSearchExtension("GL_EXT_stencil_wrap", extStart, extEnd);
10582
#endif /* GL_EXT_stencil_wrap */
10583
#ifdef GL_EXT_subtexture
10584
  CONST_CAST(GLEW_EXT_subtexture) = _glewSearchExtension("GL_EXT_subtexture", extStart, extEnd);
10585
  if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT);
10586
#endif /* GL_EXT_subtexture */
10587
#ifdef GL_EXT_texture
10588
  CONST_CAST(GLEW_EXT_texture) = _glewSearchExtension("GL_EXT_texture", extStart, extEnd);
10589
#endif /* GL_EXT_texture */
10590
#ifdef GL_EXT_texture3D
10591
  CONST_CAST(GLEW_EXT_texture3D) = _glewSearchExtension("GL_EXT_texture3D", extStart, extEnd);
10592
  if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT);
10593
#endif /* GL_EXT_texture3D */
10594
#ifdef GL_EXT_texture_array
10595
  CONST_CAST(GLEW_EXT_texture_array) = _glewSearchExtension("GL_EXT_texture_array", extStart, extEnd);
10596
  if (glewExperimental || GLEW_EXT_texture_array) CONST_CAST(GLEW_EXT_texture_array) = !_glewInit_GL_EXT_texture_array(GLEW_CONTEXT_ARG_VAR_INIT);
10597
#endif /* GL_EXT_texture_array */
10598
#ifdef GL_EXT_texture_buffer_object
10599
  CONST_CAST(GLEW_EXT_texture_buffer_object) = _glewSearchExtension("GL_EXT_texture_buffer_object", extStart, extEnd);
10600
  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);
10601
#endif /* GL_EXT_texture_buffer_object */
10602
#ifdef GL_EXT_texture_compression_dxt1
10603
  CONST_CAST(GLEW_EXT_texture_compression_dxt1) = _glewSearchExtension("GL_EXT_texture_compression_dxt1", extStart, extEnd);
10604
#endif /* GL_EXT_texture_compression_dxt1 */
10605
#ifdef GL_EXT_texture_compression_latc
10606
  CONST_CAST(GLEW_EXT_texture_compression_latc) = _glewSearchExtension("GL_EXT_texture_compression_latc", extStart, extEnd);
10607
#endif /* GL_EXT_texture_compression_latc */
10608
#ifdef GL_EXT_texture_compression_rgtc
10609
  CONST_CAST(GLEW_EXT_texture_compression_rgtc) = _glewSearchExtension("GL_EXT_texture_compression_rgtc", extStart, extEnd);
10610
#endif /* GL_EXT_texture_compression_rgtc */
10611
#ifdef GL_EXT_texture_compression_s3tc
10612
  CONST_CAST(GLEW_EXT_texture_compression_s3tc) = _glewSearchExtension("GL_EXT_texture_compression_s3tc", extStart, extEnd);
10613
#endif /* GL_EXT_texture_compression_s3tc */
10614
#ifdef GL_EXT_texture_cube_map
10615
  CONST_CAST(GLEW_EXT_texture_cube_map) = _glewSearchExtension("GL_EXT_texture_cube_map", extStart, extEnd);
10616
#endif /* GL_EXT_texture_cube_map */
10617
#ifdef GL_EXT_texture_edge_clamp
10618
  CONST_CAST(GLEW_EXT_texture_edge_clamp) = _glewSearchExtension("GL_EXT_texture_edge_clamp", extStart, extEnd);
10619
#endif /* GL_EXT_texture_edge_clamp */
10620
#ifdef GL_EXT_texture_env
10621
  CONST_CAST(GLEW_EXT_texture_env) = _glewSearchExtension("GL_EXT_texture_env", extStart, extEnd);
10622
#endif /* GL_EXT_texture_env */
10623
#ifdef GL_EXT_texture_env_add
10624
  CONST_CAST(GLEW_EXT_texture_env_add) = _glewSearchExtension("GL_EXT_texture_env_add", extStart, extEnd);
10625
#endif /* GL_EXT_texture_env_add */
10626
#ifdef GL_EXT_texture_env_combine
10627
  CONST_CAST(GLEW_EXT_texture_env_combine) = _glewSearchExtension("GL_EXT_texture_env_combine", extStart, extEnd);
10628
#endif /* GL_EXT_texture_env_combine */
10629
#ifdef GL_EXT_texture_env_dot3
10630
  CONST_CAST(GLEW_EXT_texture_env_dot3) = _glewSearchExtension("GL_EXT_texture_env_dot3", extStart, extEnd);
10631
#endif /* GL_EXT_texture_env_dot3 */
10632
#ifdef GL_EXT_texture_filter_anisotropic
10633
  CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = _glewSearchExtension("GL_EXT_texture_filter_anisotropic", extStart, extEnd);
10634
#endif /* GL_EXT_texture_filter_anisotropic */
10635
#ifdef GL_EXT_texture_integer
10636
  CONST_CAST(GLEW_EXT_texture_integer) = _glewSearchExtension("GL_EXT_texture_integer", extStart, extEnd);
10637
  if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT);
10638
#endif /* GL_EXT_texture_integer */
10639
#ifdef GL_EXT_texture_lod_bias
10640
  CONST_CAST(GLEW_EXT_texture_lod_bias) = _glewSearchExtension("GL_EXT_texture_lod_bias", extStart, extEnd);
10641
#endif /* GL_EXT_texture_lod_bias */
10642
#ifdef GL_EXT_texture_mirror_clamp
10643
  CONST_CAST(GLEW_EXT_texture_mirror_clamp) = _glewSearchExtension("GL_EXT_texture_mirror_clamp", extStart, extEnd);
10644
#endif /* GL_EXT_texture_mirror_clamp */
10645
#ifdef GL_EXT_texture_object
10646
  CONST_CAST(GLEW_EXT_texture_object) = _glewSearchExtension("GL_EXT_texture_object", extStart, extEnd);
10647
  if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT);
10648
#endif /* GL_EXT_texture_object */
10649
#ifdef GL_EXT_texture_perturb_normal
10650
  CONST_CAST(GLEW_EXT_texture_perturb_normal) = _glewSearchExtension("GL_EXT_texture_perturb_normal", extStart, extEnd);
10651
  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);
10652
#endif /* GL_EXT_texture_perturb_normal */
10653
#ifdef GL_EXT_texture_rectangle
10654
  CONST_CAST(GLEW_EXT_texture_rectangle) = _glewSearchExtension("GL_EXT_texture_rectangle", extStart, extEnd);
10655
#endif /* GL_EXT_texture_rectangle */
10656
#ifdef GL_EXT_texture_sRGB
10657
  CONST_CAST(GLEW_EXT_texture_sRGB) = _glewSearchExtension("GL_EXT_texture_sRGB", extStart, extEnd);
10658
#endif /* GL_EXT_texture_sRGB */
10659
#ifdef GL_EXT_texture_sRGB_decode
10660
  CONST_CAST(GLEW_EXT_texture_sRGB_decode) = _glewSearchExtension("GL_EXT_texture_sRGB_decode", extStart, extEnd);
10661
#endif /* GL_EXT_texture_sRGB_decode */
10662
#ifdef GL_EXT_texture_shared_exponent
10663
  CONST_CAST(GLEW_EXT_texture_shared_exponent) = _glewSearchExtension("GL_EXT_texture_shared_exponent", extStart, extEnd);
10664
#endif /* GL_EXT_texture_shared_exponent */
10665
#ifdef GL_EXT_texture_snorm
10666
  CONST_CAST(GLEW_EXT_texture_snorm) = _glewSearchExtension("GL_EXT_texture_snorm", extStart, extEnd);
10667
#endif /* GL_EXT_texture_snorm */
10668
#ifdef GL_EXT_texture_swizzle
10669
  CONST_CAST(GLEW_EXT_texture_swizzle) = _glewSearchExtension("GL_EXT_texture_swizzle", extStart, extEnd);
10670
#endif /* GL_EXT_texture_swizzle */
10671
#ifdef GL_EXT_timer_query
10672
  CONST_CAST(GLEW_EXT_timer_query) = _glewSearchExtension("GL_EXT_timer_query", extStart, extEnd);
10673
  if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
10674
#endif /* GL_EXT_timer_query */
10675
#ifdef GL_EXT_transform_feedback
10676
  CONST_CAST(GLEW_EXT_transform_feedback) = _glewSearchExtension("GL_EXT_transform_feedback", extStart, extEnd);
10677
  if (glewExperimental || GLEW_EXT_transform_feedback) CONST_CAST(GLEW_EXT_transform_feedback) = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
10678
#endif /* GL_EXT_transform_feedback */
10679
#ifdef GL_EXT_vertex_array
10680
  CONST_CAST(GLEW_EXT_vertex_array) = _glewSearchExtension("GL_EXT_vertex_array", extStart, extEnd);
10681
  if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);
10682
#endif /* GL_EXT_vertex_array */
10683
#ifdef GL_EXT_vertex_array_bgra
10684
  CONST_CAST(GLEW_EXT_vertex_array_bgra) = _glewSearchExtension("GL_EXT_vertex_array_bgra", extStart, extEnd);
10685
#endif /* GL_EXT_vertex_array_bgra */
10686
#ifdef GL_EXT_vertex_attrib_64bit
10687
  CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = _glewSearchExtension("GL_EXT_vertex_attrib_64bit", extStart, extEnd);
10688
  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);
10689
#endif /* GL_EXT_vertex_attrib_64bit */
10690
#ifdef GL_EXT_vertex_shader
10691
  CONST_CAST(GLEW_EXT_vertex_shader) = _glewSearchExtension("GL_EXT_vertex_shader", extStart, extEnd);
10692
  if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
10693
#endif /* GL_EXT_vertex_shader */
10694
#ifdef GL_EXT_vertex_weighting
10695
  CONST_CAST(GLEW_EXT_vertex_weighting) = _glewSearchExtension("GL_EXT_vertex_weighting", extStart, extEnd);
10696
  if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT);
10697
#endif /* GL_EXT_vertex_weighting */
10698
#ifdef GL_EXT_x11_sync_object
10699
  CONST_CAST(GLEW_EXT_x11_sync_object) = _glewSearchExtension("GL_EXT_x11_sync_object", extStart, extEnd);
10700
  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);
10701
#endif /* GL_EXT_x11_sync_object */
10702
#ifdef GL_GREMEDY_frame_terminator
10703
  CONST_CAST(GLEW_GREMEDY_frame_terminator) = _glewSearchExtension("GL_GREMEDY_frame_terminator", extStart, extEnd);
10704
  if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT);
10705
#endif /* GL_GREMEDY_frame_terminator */
10706
#ifdef GL_GREMEDY_string_marker
10707
  CONST_CAST(GLEW_GREMEDY_string_marker) = _glewSearchExtension("GL_GREMEDY_string_marker", extStart, extEnd);
10708
  if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT);
10709
#endif /* GL_GREMEDY_string_marker */
10710
#ifdef GL_HP_convolution_border_modes
10711
  CONST_CAST(GLEW_HP_convolution_border_modes) = _glewSearchExtension("GL_HP_convolution_border_modes", extStart, extEnd);
10712
#endif /* GL_HP_convolution_border_modes */
10713
#ifdef GL_HP_image_transform
10714
  CONST_CAST(GLEW_HP_image_transform) = _glewSearchExtension("GL_HP_image_transform", extStart, extEnd);
10715
  if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT);
10716
#endif /* GL_HP_image_transform */
10717
#ifdef GL_HP_occlusion_test
10718
  CONST_CAST(GLEW_HP_occlusion_test) = _glewSearchExtension("GL_HP_occlusion_test", extStart, extEnd);
10719
#endif /* GL_HP_occlusion_test */
10720
#ifdef GL_HP_texture_lighting
10721
  CONST_CAST(GLEW_HP_texture_lighting) = _glewSearchExtension("GL_HP_texture_lighting", extStart, extEnd);
10722
#endif /* GL_HP_texture_lighting */
10723
#ifdef GL_IBM_cull_vertex
10724
  CONST_CAST(GLEW_IBM_cull_vertex) = _glewSearchExtension("GL_IBM_cull_vertex", extStart, extEnd);
10725
#endif /* GL_IBM_cull_vertex */
10726
#ifdef GL_IBM_multimode_draw_arrays
10727
  CONST_CAST(GLEW_IBM_multimode_draw_arrays) = _glewSearchExtension("GL_IBM_multimode_draw_arrays", extStart, extEnd);
10728
  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);
10729
#endif /* GL_IBM_multimode_draw_arrays */
10730
#ifdef GL_IBM_rasterpos_clip
10731
  CONST_CAST(GLEW_IBM_rasterpos_clip) = _glewSearchExtension("GL_IBM_rasterpos_clip", extStart, extEnd);
10732
#endif /* GL_IBM_rasterpos_clip */
10733
#ifdef GL_IBM_static_data
10734
  CONST_CAST(GLEW_IBM_static_data) = _glewSearchExtension("GL_IBM_static_data", extStart, extEnd);
10735
#endif /* GL_IBM_static_data */
10736
#ifdef GL_IBM_texture_mirrored_repeat
10737
  CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = _glewSearchExtension("GL_IBM_texture_mirrored_repeat", extStart, extEnd);
10738
#endif /* GL_IBM_texture_mirrored_repeat */
10739
#ifdef GL_IBM_vertex_array_lists
10740
  CONST_CAST(GLEW_IBM_vertex_array_lists) = _glewSearchExtension("GL_IBM_vertex_array_lists", extStart, extEnd);
10741
  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);
10742
#endif /* GL_IBM_vertex_array_lists */
10743
#ifdef GL_INGR_color_clamp
10744
  CONST_CAST(GLEW_INGR_color_clamp) = _glewSearchExtension("GL_INGR_color_clamp", extStart, extEnd);
10745
#endif /* GL_INGR_color_clamp */
10746
#ifdef GL_INGR_interlace_read
10747
  CONST_CAST(GLEW_INGR_interlace_read) = _glewSearchExtension("GL_INGR_interlace_read", extStart, extEnd);
10748
#endif /* GL_INGR_interlace_read */
677 janba 10749
#ifdef GL_INTEL_map_texture
10750
  CONST_CAST(GLEW_INTEL_map_texture) = _glewSearchExtension("GL_INTEL_map_texture", extStart, extEnd);
10751
  if (glewExperimental || GLEW_INTEL_map_texture) CONST_CAST(GLEW_INTEL_map_texture) = !_glewInit_GL_INTEL_map_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10752
#endif /* GL_INTEL_map_texture */
667 khor 10753
#ifdef GL_INTEL_parallel_arrays
10754
  CONST_CAST(GLEW_INTEL_parallel_arrays) = _glewSearchExtension("GL_INTEL_parallel_arrays", extStart, extEnd);
10755
  if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
10756
#endif /* GL_INTEL_parallel_arrays */
10757
#ifdef GL_INTEL_texture_scissor
10758
  CONST_CAST(GLEW_INTEL_texture_scissor) = _glewSearchExtension("GL_INTEL_texture_scissor", extStart, extEnd);
10759
  if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT);
10760
#endif /* GL_INTEL_texture_scissor */
10761
#ifdef GL_KHR_debug
10762
  CONST_CAST(GLEW_KHR_debug) = _glewSearchExtension("GL_KHR_debug", extStart, extEnd);
10763
  if (glewExperimental || GLEW_KHR_debug) CONST_CAST(GLEW_KHR_debug) = !_glewInit_GL_KHR_debug(GLEW_CONTEXT_ARG_VAR_INIT);
10764
#endif /* GL_KHR_debug */
10765
#ifdef GL_KHR_texture_compression_astc_ldr
10766
  CONST_CAST(GLEW_KHR_texture_compression_astc_ldr) = _glewSearchExtension("GL_KHR_texture_compression_astc_ldr", extStart, extEnd);
10767
#endif /* GL_KHR_texture_compression_astc_ldr */
10768
#ifdef GL_KTX_buffer_region
10769
  CONST_CAST(GLEW_KTX_buffer_region) = _glewSearchExtension("GL_KTX_buffer_region", extStart, extEnd);
10770
  if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
10771
#endif /* GL_KTX_buffer_region */
10772
#ifdef GL_MESAX_texture_stack
10773
  CONST_CAST(GLEW_MESAX_texture_stack) = _glewSearchExtension("GL_MESAX_texture_stack", extStart, extEnd);
10774
#endif /* GL_MESAX_texture_stack */
10775
#ifdef GL_MESA_pack_invert
10776
  CONST_CAST(GLEW_MESA_pack_invert) = _glewSearchExtension("GL_MESA_pack_invert", extStart, extEnd);
10777
#endif /* GL_MESA_pack_invert */
10778
#ifdef GL_MESA_resize_buffers
10779
  CONST_CAST(GLEW_MESA_resize_buffers) = _glewSearchExtension("GL_MESA_resize_buffers", extStart, extEnd);
10780
  if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
10781
#endif /* GL_MESA_resize_buffers */
10782
#ifdef GL_MESA_window_pos
10783
  CONST_CAST(GLEW_MESA_window_pos) = _glewSearchExtension("GL_MESA_window_pos", extStart, extEnd);
10784
  if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
10785
#endif /* GL_MESA_window_pos */
10786
#ifdef GL_MESA_ycbcr_texture
10787
  CONST_CAST(GLEW_MESA_ycbcr_texture) = _glewSearchExtension("GL_MESA_ycbcr_texture", extStart, extEnd);
10788
#endif /* GL_MESA_ycbcr_texture */
677 janba 10789
#ifdef GL_NVX_conditional_render
10790
  CONST_CAST(GLEW_NVX_conditional_render) = _glewSearchExtension("GL_NVX_conditional_render", extStart, extEnd);
10791
  if (glewExperimental || GLEW_NVX_conditional_render) CONST_CAST(GLEW_NVX_conditional_render) = !_glewInit_GL_NVX_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT);
10792
#endif /* GL_NVX_conditional_render */
667 khor 10793
#ifdef GL_NVX_gpu_memory_info
10794
  CONST_CAST(GLEW_NVX_gpu_memory_info) = _glewSearchExtension("GL_NVX_gpu_memory_info", extStart, extEnd);
10795
#endif /* GL_NVX_gpu_memory_info */
677 janba 10796
#ifdef GL_NV_bindless_multi_draw_indirect
10797
  CONST_CAST(GLEW_NV_bindless_multi_draw_indirect) = _glewSearchExtension("GL_NV_bindless_multi_draw_indirect", extStart, extEnd);
10798
  if (glewExperimental || GLEW_NV_bindless_multi_draw_indirect) CONST_CAST(GLEW_NV_bindless_multi_draw_indirect) = !_glewInit_GL_NV_bindless_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
10799
#endif /* GL_NV_bindless_multi_draw_indirect */
667 khor 10800
#ifdef GL_NV_bindless_texture
10801
  CONST_CAST(GLEW_NV_bindless_texture) = _glewSearchExtension("GL_NV_bindless_texture", extStart, extEnd);
10802
  if (glewExperimental || GLEW_NV_bindless_texture) CONST_CAST(GLEW_NV_bindless_texture) = !_glewInit_GL_NV_bindless_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10803
#endif /* GL_NV_bindless_texture */
677 janba 10804
#ifdef GL_NV_blend_equation_advanced
10805
  CONST_CAST(GLEW_NV_blend_equation_advanced) = _glewSearchExtension("GL_NV_blend_equation_advanced", extStart, extEnd);
10806
  if (glewExperimental || GLEW_NV_blend_equation_advanced) CONST_CAST(GLEW_NV_blend_equation_advanced) = !_glewInit_GL_NV_blend_equation_advanced(GLEW_CONTEXT_ARG_VAR_INIT);
10807
#endif /* GL_NV_blend_equation_advanced */
10808
#ifdef GL_NV_blend_equation_advanced_coherent
10809
  CONST_CAST(GLEW_NV_blend_equation_advanced_coherent) = _glewSearchExtension("GL_NV_blend_equation_advanced_coherent", extStart, extEnd);
10810
#endif /* GL_NV_blend_equation_advanced_coherent */
667 khor 10811
#ifdef GL_NV_blend_square
10812
  CONST_CAST(GLEW_NV_blend_square) = _glewSearchExtension("GL_NV_blend_square", extStart, extEnd);
10813
#endif /* GL_NV_blend_square */
677 janba 10814
#ifdef GL_NV_compute_program5
10815
  CONST_CAST(GLEW_NV_compute_program5) = _glewSearchExtension("GL_NV_compute_program5", extStart, extEnd);
10816
#endif /* GL_NV_compute_program5 */
667 khor 10817
#ifdef GL_NV_conditional_render
10818
  CONST_CAST(GLEW_NV_conditional_render) = _glewSearchExtension("GL_NV_conditional_render", extStart, extEnd);
10819
  if (glewExperimental || GLEW_NV_conditional_render) CONST_CAST(GLEW_NV_conditional_render) = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT);
10820
#endif /* GL_NV_conditional_render */
10821
#ifdef GL_NV_copy_depth_to_color
10822
  CONST_CAST(GLEW_NV_copy_depth_to_color) = _glewSearchExtension("GL_NV_copy_depth_to_color", extStart, extEnd);
10823
#endif /* GL_NV_copy_depth_to_color */
10824
#ifdef GL_NV_copy_image
10825
  CONST_CAST(GLEW_NV_copy_image) = _glewSearchExtension("GL_NV_copy_image", extStart, extEnd);
10826
  if (glewExperimental || GLEW_NV_copy_image) CONST_CAST(GLEW_NV_copy_image) = !_glewInit_GL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
10827
#endif /* GL_NV_copy_image */
677 janba 10828
#ifdef GL_NV_deep_texture3D
10829
  CONST_CAST(GLEW_NV_deep_texture3D) = _glewSearchExtension("GL_NV_deep_texture3D", extStart, extEnd);
10830
#endif /* GL_NV_deep_texture3D */
667 khor 10831
#ifdef GL_NV_depth_buffer_float
10832
  CONST_CAST(GLEW_NV_depth_buffer_float) = _glewSearchExtension("GL_NV_depth_buffer_float", extStart, extEnd);
10833
  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);
10834
#endif /* GL_NV_depth_buffer_float */
10835
#ifdef GL_NV_depth_clamp
10836
  CONST_CAST(GLEW_NV_depth_clamp) = _glewSearchExtension("GL_NV_depth_clamp", extStart, extEnd);
10837
#endif /* GL_NV_depth_clamp */
10838
#ifdef GL_NV_depth_range_unclamped
10839
  CONST_CAST(GLEW_NV_depth_range_unclamped) = _glewSearchExtension("GL_NV_depth_range_unclamped", extStart, extEnd);
10840
#endif /* GL_NV_depth_range_unclamped */
677 janba 10841
#ifdef GL_NV_draw_texture
10842
  CONST_CAST(GLEW_NV_draw_texture) = _glewSearchExtension("GL_NV_draw_texture", extStart, extEnd);
10843
  if (glewExperimental || GLEW_NV_draw_texture) CONST_CAST(GLEW_NV_draw_texture) = !_glewInit_GL_NV_draw_texture(GLEW_CONTEXT_ARG_VAR_INIT);
10844
#endif /* GL_NV_draw_texture */
667 khor 10845
#ifdef GL_NV_evaluators
10846
  CONST_CAST(GLEW_NV_evaluators) = _glewSearchExtension("GL_NV_evaluators", extStart, extEnd);
10847
  if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);
10848
#endif /* GL_NV_evaluators */
10849
#ifdef GL_NV_explicit_multisample
10850
  CONST_CAST(GLEW_NV_explicit_multisample) = _glewSearchExtension("GL_NV_explicit_multisample", extStart, extEnd);
10851
  if (glewExperimental || GLEW_NV_explicit_multisample) CONST_CAST(GLEW_NV_explicit_multisample) = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10852
#endif /* GL_NV_explicit_multisample */
10853
#ifdef GL_NV_fence
10854
  CONST_CAST(GLEW_NV_fence) = _glewSearchExtension("GL_NV_fence", extStart, extEnd);
10855
  if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT);
10856
#endif /* GL_NV_fence */
10857
#ifdef GL_NV_float_buffer
10858
  CONST_CAST(GLEW_NV_float_buffer) = _glewSearchExtension("GL_NV_float_buffer", extStart, extEnd);
10859
#endif /* GL_NV_float_buffer */
10860
#ifdef GL_NV_fog_distance
10861
  CONST_CAST(GLEW_NV_fog_distance) = _glewSearchExtension("GL_NV_fog_distance", extStart, extEnd);
10862
#endif /* GL_NV_fog_distance */
10863
#ifdef GL_NV_fragment_program
10864
  CONST_CAST(GLEW_NV_fragment_program) = _glewSearchExtension("GL_NV_fragment_program", extStart, extEnd);
10865
  if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);
10866
#endif /* GL_NV_fragment_program */
10867
#ifdef GL_NV_fragment_program2
10868
  CONST_CAST(GLEW_NV_fragment_program2) = _glewSearchExtension("GL_NV_fragment_program2", extStart, extEnd);
10869
#endif /* GL_NV_fragment_program2 */
10870
#ifdef GL_NV_fragment_program4
10871
  CONST_CAST(GLEW_NV_fragment_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10872
#endif /* GL_NV_fragment_program4 */
10873
#ifdef GL_NV_fragment_program_option
10874
  CONST_CAST(GLEW_NV_fragment_program_option) = _glewSearchExtension("GL_NV_fragment_program_option", extStart, extEnd);
10875
#endif /* GL_NV_fragment_program_option */
10876
#ifdef GL_NV_framebuffer_multisample_coverage
10877
  CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = _glewSearchExtension("GL_NV_framebuffer_multisample_coverage", extStart, extEnd);
10878
  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);
10879
#endif /* GL_NV_framebuffer_multisample_coverage */
10880
#ifdef GL_NV_geometry_program4
10881
  CONST_CAST(GLEW_NV_geometry_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10882
  if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT);
10883
#endif /* GL_NV_geometry_program4 */
10884
#ifdef GL_NV_geometry_shader4
10885
  CONST_CAST(GLEW_NV_geometry_shader4) = _glewSearchExtension("GL_NV_geometry_shader4", extStart, extEnd);
10886
#endif /* GL_NV_geometry_shader4 */
10887
#ifdef GL_NV_gpu_program4
10888
  CONST_CAST(GLEW_NV_gpu_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
10889
  if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT);
10890
#endif /* GL_NV_gpu_program4 */
10891
#ifdef GL_NV_gpu_program5
10892
  CONST_CAST(GLEW_NV_gpu_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd);
10893
#endif /* GL_NV_gpu_program5 */
677 janba 10894
#ifdef GL_NV_gpu_program5_mem_extended
10895
  CONST_CAST(GLEW_NV_gpu_program5_mem_extended) = _glewSearchExtension("GL_NV_gpu_program5_mem_extended", extStart, extEnd);
10896
#endif /* GL_NV_gpu_program5_mem_extended */
667 khor 10897
#ifdef GL_NV_gpu_program_fp64
10898
  CONST_CAST(GLEW_NV_gpu_program_fp64) = _glewSearchExtension("GL_NV_gpu_program_fp64", extStart, extEnd);
10899
#endif /* GL_NV_gpu_program_fp64 */
10900
#ifdef GL_NV_gpu_shader5
10901
  CONST_CAST(GLEW_NV_gpu_shader5) = _glewSearchExtension("GL_NV_gpu_shader5", extStart, extEnd);
10902
  if (glewExperimental || GLEW_NV_gpu_shader5) CONST_CAST(GLEW_NV_gpu_shader5) = !_glewInit_GL_NV_gpu_shader5(GLEW_CONTEXT_ARG_VAR_INIT);
10903
#endif /* GL_NV_gpu_shader5 */
10904
#ifdef GL_NV_half_float
10905
  CONST_CAST(GLEW_NV_half_float) = _glewSearchExtension("GL_NV_half_float", extStart, extEnd);
10906
  if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);
10907
#endif /* GL_NV_half_float */
10908
#ifdef GL_NV_light_max_exponent
10909
  CONST_CAST(GLEW_NV_light_max_exponent) = _glewSearchExtension("GL_NV_light_max_exponent", extStart, extEnd);
10910
#endif /* GL_NV_light_max_exponent */
10911
#ifdef GL_NV_multisample_coverage
10912
  CONST_CAST(GLEW_NV_multisample_coverage) = _glewSearchExtension("GL_NV_multisample_coverage", extStart, extEnd);
10913
#endif /* GL_NV_multisample_coverage */
10914
#ifdef GL_NV_multisample_filter_hint
10915
  CONST_CAST(GLEW_NV_multisample_filter_hint) = _glewSearchExtension("GL_NV_multisample_filter_hint", extStart, extEnd);
10916
#endif /* GL_NV_multisample_filter_hint */
10917
#ifdef GL_NV_occlusion_query
10918
  CONST_CAST(GLEW_NV_occlusion_query) = _glewSearchExtension("GL_NV_occlusion_query", extStart, extEnd);
10919
  if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
10920
#endif /* GL_NV_occlusion_query */
10921
#ifdef GL_NV_packed_depth_stencil
10922
  CONST_CAST(GLEW_NV_packed_depth_stencil) = _glewSearchExtension("GL_NV_packed_depth_stencil", extStart, extEnd);
10923
#endif /* GL_NV_packed_depth_stencil */
10924
#ifdef GL_NV_parameter_buffer_object
10925
  CONST_CAST(GLEW_NV_parameter_buffer_object) = _glewSearchExtension("GL_NV_parameter_buffer_object", extStart, extEnd);
10926
  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);
10927
#endif /* GL_NV_parameter_buffer_object */
10928
#ifdef GL_NV_parameter_buffer_object2
10929
  CONST_CAST(GLEW_NV_parameter_buffer_object2) = _glewSearchExtension("GL_NV_parameter_buffer_object2", extStart, extEnd);
10930
#endif /* GL_NV_parameter_buffer_object2 */
10931
#ifdef GL_NV_path_rendering
10932
  CONST_CAST(GLEW_NV_path_rendering) = _glewSearchExtension("GL_NV_path_rendering", extStart, extEnd);
10933
  if (glewExperimental || GLEW_NV_path_rendering) CONST_CAST(GLEW_NV_path_rendering) = !_glewInit_GL_NV_path_rendering(GLEW_CONTEXT_ARG_VAR_INIT);
10934
#endif /* GL_NV_path_rendering */
10935
#ifdef GL_NV_pixel_data_range
10936
  CONST_CAST(GLEW_NV_pixel_data_range) = _glewSearchExtension("GL_NV_pixel_data_range", extStart, extEnd);
10937
  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);
10938
#endif /* GL_NV_pixel_data_range */
10939
#ifdef GL_NV_point_sprite
10940
  CONST_CAST(GLEW_NV_point_sprite) = _glewSearchExtension("GL_NV_point_sprite", extStart, extEnd);
10941
  if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT);
10942
#endif /* GL_NV_point_sprite */
10943
#ifdef GL_NV_present_video
10944
  CONST_CAST(GLEW_NV_present_video) = _glewSearchExtension("GL_NV_present_video", extStart, extEnd);
10945
  if (glewExperimental || GLEW_NV_present_video) CONST_CAST(GLEW_NV_present_video) = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
10946
#endif /* GL_NV_present_video */
10947
#ifdef GL_NV_primitive_restart
10948
  CONST_CAST(GLEW_NV_primitive_restart) = _glewSearchExtension("GL_NV_primitive_restart", extStart, extEnd);
10949
  if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT);
10950
#endif /* GL_NV_primitive_restart */
10951
#ifdef GL_NV_register_combiners
10952
  CONST_CAST(GLEW_NV_register_combiners) = _glewSearchExtension("GL_NV_register_combiners", extStart, extEnd);
10953
  if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);
10954
#endif /* GL_NV_register_combiners */
10955
#ifdef GL_NV_register_combiners2
10956
  CONST_CAST(GLEW_NV_register_combiners2) = _glewSearchExtension("GL_NV_register_combiners2", extStart, extEnd);
10957
  if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);
10958
#endif /* GL_NV_register_combiners2 */
677 janba 10959
#ifdef GL_NV_shader_atomic_counters
10960
  CONST_CAST(GLEW_NV_shader_atomic_counters) = _glewSearchExtension("GL_NV_shader_atomic_counters", extStart, extEnd);
10961
#endif /* GL_NV_shader_atomic_counters */
667 khor 10962
#ifdef GL_NV_shader_atomic_float
10963
  CONST_CAST(GLEW_NV_shader_atomic_float) = _glewSearchExtension("GL_NV_shader_atomic_float", extStart, extEnd);
10964
#endif /* GL_NV_shader_atomic_float */
10965
#ifdef GL_NV_shader_buffer_load
10966
  CONST_CAST(GLEW_NV_shader_buffer_load) = _glewSearchExtension("GL_NV_shader_buffer_load", extStart, extEnd);
10967
  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);
10968
#endif /* GL_NV_shader_buffer_load */
677 janba 10969
#ifdef GL_NV_shader_storage_buffer_object
10970
  CONST_CAST(GLEW_NV_shader_storage_buffer_object) = _glewSearchExtension("GL_NV_shader_storage_buffer_object", extStart, extEnd);
10971
#endif /* GL_NV_shader_storage_buffer_object */
667 khor 10972
#ifdef GL_NV_tessellation_program5
10973
  CONST_CAST(GLEW_NV_tessellation_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd);
10974
#endif /* GL_NV_tessellation_program5 */
10975
#ifdef GL_NV_texgen_emboss
10976
  CONST_CAST(GLEW_NV_texgen_emboss) = _glewSearchExtension("GL_NV_texgen_emboss", extStart, extEnd);
10977
#endif /* GL_NV_texgen_emboss */
10978
#ifdef GL_NV_texgen_reflection
10979
  CONST_CAST(GLEW_NV_texgen_reflection) = _glewSearchExtension("GL_NV_texgen_reflection", extStart, extEnd);
10980
#endif /* GL_NV_texgen_reflection */
10981
#ifdef GL_NV_texture_barrier
10982
  CONST_CAST(GLEW_NV_texture_barrier) = _glewSearchExtension("GL_NV_texture_barrier", extStart, extEnd);
10983
  if (glewExperimental || GLEW_NV_texture_barrier) CONST_CAST(GLEW_NV_texture_barrier) = !_glewInit_GL_NV_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
10984
#endif /* GL_NV_texture_barrier */
10985
#ifdef GL_NV_texture_compression_vtc
10986
  CONST_CAST(GLEW_NV_texture_compression_vtc) = _glewSearchExtension("GL_NV_texture_compression_vtc", extStart, extEnd);
10987
#endif /* GL_NV_texture_compression_vtc */
10988
#ifdef GL_NV_texture_env_combine4
10989
  CONST_CAST(GLEW_NV_texture_env_combine4) = _glewSearchExtension("GL_NV_texture_env_combine4", extStart, extEnd);
10990
#endif /* GL_NV_texture_env_combine4 */
10991
#ifdef GL_NV_texture_expand_normal
10992
  CONST_CAST(GLEW_NV_texture_expand_normal) = _glewSearchExtension("GL_NV_texture_expand_normal", extStart, extEnd);
10993
#endif /* GL_NV_texture_expand_normal */
10994
#ifdef GL_NV_texture_multisample
10995
  CONST_CAST(GLEW_NV_texture_multisample) = _glewSearchExtension("GL_NV_texture_multisample", extStart, extEnd);
10996
  if (glewExperimental || GLEW_NV_texture_multisample) CONST_CAST(GLEW_NV_texture_multisample) = !_glewInit_GL_NV_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
10997
#endif /* GL_NV_texture_multisample */
10998
#ifdef GL_NV_texture_rectangle
10999
  CONST_CAST(GLEW_NV_texture_rectangle) = _glewSearchExtension("GL_NV_texture_rectangle", extStart, extEnd);
11000
#endif /* GL_NV_texture_rectangle */
11001
#ifdef GL_NV_texture_shader
11002
  CONST_CAST(GLEW_NV_texture_shader) = _glewSearchExtension("GL_NV_texture_shader", extStart, extEnd);
11003
#endif /* GL_NV_texture_shader */
11004
#ifdef GL_NV_texture_shader2
11005
  CONST_CAST(GLEW_NV_texture_shader2) = _glewSearchExtension("GL_NV_texture_shader2", extStart, extEnd);
11006
#endif /* GL_NV_texture_shader2 */
11007
#ifdef GL_NV_texture_shader3
11008
  CONST_CAST(GLEW_NV_texture_shader3) = _glewSearchExtension("GL_NV_texture_shader3", extStart, extEnd);
11009
#endif /* GL_NV_texture_shader3 */
11010
#ifdef GL_NV_transform_feedback
11011
  CONST_CAST(GLEW_NV_transform_feedback) = _glewSearchExtension("GL_NV_transform_feedback", extStart, extEnd);
11012
  if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
11013
#endif /* GL_NV_transform_feedback */
11014
#ifdef GL_NV_transform_feedback2
11015
  CONST_CAST(GLEW_NV_transform_feedback2) = _glewSearchExtension("GL_NV_transform_feedback2", extStart, extEnd);
11016
  if (glewExperimental || GLEW_NV_transform_feedback2) CONST_CAST(GLEW_NV_transform_feedback2) = !_glewInit_GL_NV_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
11017
#endif /* GL_NV_transform_feedback2 */
11018
#ifdef GL_NV_vdpau_interop
11019
  CONST_CAST(GLEW_NV_vdpau_interop) = _glewSearchExtension("GL_NV_vdpau_interop", extStart, extEnd);
11020
  if (glewExperimental || GLEW_NV_vdpau_interop) CONST_CAST(GLEW_NV_vdpau_interop) = !_glewInit_GL_NV_vdpau_interop(GLEW_CONTEXT_ARG_VAR_INIT);
11021
#endif /* GL_NV_vdpau_interop */
11022
#ifdef GL_NV_vertex_array_range
11023
  CONST_CAST(GLEW_NV_vertex_array_range) = _glewSearchExtension("GL_NV_vertex_array_range", extStart, extEnd);
11024
  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);
11025
#endif /* GL_NV_vertex_array_range */
11026
#ifdef GL_NV_vertex_array_range2
11027
  CONST_CAST(GLEW_NV_vertex_array_range2) = _glewSearchExtension("GL_NV_vertex_array_range2", extStart, extEnd);
11028
#endif /* GL_NV_vertex_array_range2 */
11029
#ifdef GL_NV_vertex_attrib_integer_64bit
11030
  CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = _glewSearchExtension("GL_NV_vertex_attrib_integer_64bit", extStart, extEnd);
11031
  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);
11032
#endif /* GL_NV_vertex_attrib_integer_64bit */
11033
#ifdef GL_NV_vertex_buffer_unified_memory
11034
  CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = _glewSearchExtension("GL_NV_vertex_buffer_unified_memory", extStart, extEnd);
11035
  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);
11036
#endif /* GL_NV_vertex_buffer_unified_memory */
11037
#ifdef GL_NV_vertex_program
11038
  CONST_CAST(GLEW_NV_vertex_program) = _glewSearchExtension("GL_NV_vertex_program", extStart, extEnd);
11039
  if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
11040
#endif /* GL_NV_vertex_program */
11041
#ifdef GL_NV_vertex_program1_1
11042
  CONST_CAST(GLEW_NV_vertex_program1_1) = _glewSearchExtension("GL_NV_vertex_program1_1", extStart, extEnd);
11043
#endif /* GL_NV_vertex_program1_1 */
11044
#ifdef GL_NV_vertex_program2
11045
  CONST_CAST(GLEW_NV_vertex_program2) = _glewSearchExtension("GL_NV_vertex_program2", extStart, extEnd);
11046
#endif /* GL_NV_vertex_program2 */
11047
#ifdef GL_NV_vertex_program2_option
11048
  CONST_CAST(GLEW_NV_vertex_program2_option) = _glewSearchExtension("GL_NV_vertex_program2_option", extStart, extEnd);
11049
#endif /* GL_NV_vertex_program2_option */
11050
#ifdef GL_NV_vertex_program3
11051
  CONST_CAST(GLEW_NV_vertex_program3) = _glewSearchExtension("GL_NV_vertex_program3", extStart, extEnd);
11052
#endif /* GL_NV_vertex_program3 */
11053
#ifdef GL_NV_vertex_program4
11054
  CONST_CAST(GLEW_NV_vertex_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
11055
#endif /* GL_NV_vertex_program4 */
11056
#ifdef GL_NV_video_capture
11057
  CONST_CAST(GLEW_NV_video_capture) = _glewSearchExtension("GL_NV_video_capture", extStart, extEnd);
11058
  if (glewExperimental || GLEW_NV_video_capture) CONST_CAST(GLEW_NV_video_capture) = !_glewInit_GL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
11059
#endif /* GL_NV_video_capture */
11060
#ifdef GL_OES_byte_coordinates
11061
  CONST_CAST(GLEW_OES_byte_coordinates) = _glewSearchExtension("GL_OES_byte_coordinates", extStart, extEnd);
11062
#endif /* GL_OES_byte_coordinates */
11063
#ifdef GL_OES_compressed_paletted_texture
11064
  CONST_CAST(GLEW_OES_compressed_paletted_texture) = _glewSearchExtension("GL_OES_compressed_paletted_texture", extStart, extEnd);
11065
#endif /* GL_OES_compressed_paletted_texture */
11066
#ifdef GL_OES_read_format
11067
  CONST_CAST(GLEW_OES_read_format) = _glewSearchExtension("GL_OES_read_format", extStart, extEnd);
11068
#endif /* GL_OES_read_format */
11069
#ifdef GL_OES_single_precision
11070
  CONST_CAST(GLEW_OES_single_precision) = _glewSearchExtension("GL_OES_single_precision", extStart, extEnd);
11071
  if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT);
11072
#endif /* GL_OES_single_precision */
11073
#ifdef GL_OML_interlace
11074
  CONST_CAST(GLEW_OML_interlace) = _glewSearchExtension("GL_OML_interlace", extStart, extEnd);
11075
#endif /* GL_OML_interlace */
11076
#ifdef GL_OML_resample
11077
  CONST_CAST(GLEW_OML_resample) = _glewSearchExtension("GL_OML_resample", extStart, extEnd);
11078
#endif /* GL_OML_resample */
11079
#ifdef GL_OML_subsample
11080
  CONST_CAST(GLEW_OML_subsample) = _glewSearchExtension("GL_OML_subsample", extStart, extEnd);
11081
#endif /* GL_OML_subsample */
11082
#ifdef GL_PGI_misc_hints
11083
  CONST_CAST(GLEW_PGI_misc_hints) = _glewSearchExtension("GL_PGI_misc_hints", extStart, extEnd);
11084
#endif /* GL_PGI_misc_hints */
11085
#ifdef GL_PGI_vertex_hints
11086
  CONST_CAST(GLEW_PGI_vertex_hints) = _glewSearchExtension("GL_PGI_vertex_hints", extStart, extEnd);
11087
#endif /* GL_PGI_vertex_hints */
677 janba 11088
#ifdef GL_REGAL_ES1_0_compatibility
11089
  CONST_CAST(GLEW_REGAL_ES1_0_compatibility) = _glewSearchExtension("GL_REGAL_ES1_0_compatibility", extStart, extEnd);
11090
  if (glewExperimental || GLEW_REGAL_ES1_0_compatibility) CONST_CAST(GLEW_REGAL_ES1_0_compatibility) = !_glewInit_GL_REGAL_ES1_0_compatibility(GLEW_CONTEXT_ARG_VAR_INIT);
11091
#endif /* GL_REGAL_ES1_0_compatibility */
11092
#ifdef GL_REGAL_ES1_1_compatibility
11093
  CONST_CAST(GLEW_REGAL_ES1_1_compatibility) = _glewSearchExtension("GL_REGAL_ES1_1_compatibility", extStart, extEnd);
11094
  if (glewExperimental || GLEW_REGAL_ES1_1_compatibility) CONST_CAST(GLEW_REGAL_ES1_1_compatibility) = !_glewInit_GL_REGAL_ES1_1_compatibility(GLEW_CONTEXT_ARG_VAR_INIT);
11095
#endif /* GL_REGAL_ES1_1_compatibility */
11096
#ifdef GL_REGAL_enable
11097
  CONST_CAST(GLEW_REGAL_enable) = _glewSearchExtension("GL_REGAL_enable", extStart, extEnd);
11098
#endif /* GL_REGAL_enable */
667 khor 11099
#ifdef GL_REGAL_error_string
11100
  CONST_CAST(GLEW_REGAL_error_string) = _glewSearchExtension("GL_REGAL_error_string", extStart, extEnd);
11101
  if (glewExperimental || GLEW_REGAL_error_string) CONST_CAST(GLEW_REGAL_error_string) = !_glewInit_GL_REGAL_error_string(GLEW_CONTEXT_ARG_VAR_INIT);
11102
#endif /* GL_REGAL_error_string */
11103
#ifdef GL_REGAL_extension_query
11104
  CONST_CAST(GLEW_REGAL_extension_query) = _glewSearchExtension("GL_REGAL_extension_query", extStart, extEnd);
11105
  if (glewExperimental || GLEW_REGAL_extension_query) CONST_CAST(GLEW_REGAL_extension_query) = !_glewInit_GL_REGAL_extension_query(GLEW_CONTEXT_ARG_VAR_INIT);
11106
#endif /* GL_REGAL_extension_query */
11107
#ifdef GL_REGAL_log
11108
  CONST_CAST(GLEW_REGAL_log) = _glewSearchExtension("GL_REGAL_log", extStart, extEnd);
677 janba 11109
  if (glewExperimental || GLEW_REGAL_log) CONST_CAST(GLEW_REGAL_log) = !_glewInit_GL_REGAL_log(GLEW_CONTEXT_ARG_VAR_INIT);
667 khor 11110
#endif /* GL_REGAL_log */
11111
#ifdef GL_REND_screen_coordinates
11112
  CONST_CAST(GLEW_REND_screen_coordinates) = _glewSearchExtension("GL_REND_screen_coordinates", extStart, extEnd);
11113
#endif /* GL_REND_screen_coordinates */
11114
#ifdef GL_S3_s3tc
11115
  CONST_CAST(GLEW_S3_s3tc) = _glewSearchExtension("GL_S3_s3tc", extStart, extEnd);
11116
#endif /* GL_S3_s3tc */
11117
#ifdef GL_SGIS_color_range
11118
  CONST_CAST(GLEW_SGIS_color_range) = _glewSearchExtension("GL_SGIS_color_range", extStart, extEnd);
11119
#endif /* GL_SGIS_color_range */
11120
#ifdef GL_SGIS_detail_texture
11121
  CONST_CAST(GLEW_SGIS_detail_texture) = _glewSearchExtension("GL_SGIS_detail_texture", extStart, extEnd);
11122
  if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT);
11123
#endif /* GL_SGIS_detail_texture */
11124
#ifdef GL_SGIS_fog_function
11125
  CONST_CAST(GLEW_SGIS_fog_function) = _glewSearchExtension("GL_SGIS_fog_function", extStart, extEnd);
11126
  if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT);
11127
#endif /* GL_SGIS_fog_function */
11128
#ifdef GL_SGIS_generate_mipmap
11129
  CONST_CAST(GLEW_SGIS_generate_mipmap) = _glewSearchExtension("GL_SGIS_generate_mipmap", extStart, extEnd);
11130
#endif /* GL_SGIS_generate_mipmap */
11131
#ifdef GL_SGIS_multisample
11132
  CONST_CAST(GLEW_SGIS_multisample) = _glewSearchExtension("GL_SGIS_multisample", extStart, extEnd);
11133
  if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
11134
#endif /* GL_SGIS_multisample */
11135
#ifdef GL_SGIS_pixel_texture
11136
  CONST_CAST(GLEW_SGIS_pixel_texture) = _glewSearchExtension("GL_SGIS_pixel_texture", extStart, extEnd);
11137
#endif /* GL_SGIS_pixel_texture */
11138
#ifdef GL_SGIS_point_line_texgen
11139
  CONST_CAST(GLEW_SGIS_point_line_texgen) = _glewSearchExtension("GL_SGIS_point_line_texgen", extStart, extEnd);
11140
#endif /* GL_SGIS_point_line_texgen */
11141
#ifdef GL_SGIS_sharpen_texture
11142
  CONST_CAST(GLEW_SGIS_sharpen_texture) = _glewSearchExtension("GL_SGIS_sharpen_texture", extStart, extEnd);
11143
  if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT);
11144
#endif /* GL_SGIS_sharpen_texture */
11145
#ifdef GL_SGIS_texture4D
11146
  CONST_CAST(GLEW_SGIS_texture4D) = _glewSearchExtension("GL_SGIS_texture4D", extStart, extEnd);
11147
  if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT);
11148
#endif /* GL_SGIS_texture4D */
11149
#ifdef GL_SGIS_texture_border_clamp
11150
  CONST_CAST(GLEW_SGIS_texture_border_clamp) = _glewSearchExtension("GL_SGIS_texture_border_clamp", extStart, extEnd);
11151
#endif /* GL_SGIS_texture_border_clamp */
11152
#ifdef GL_SGIS_texture_edge_clamp
11153
  CONST_CAST(GLEW_SGIS_texture_edge_clamp) = _glewSearchExtension("GL_SGIS_texture_edge_clamp", extStart, extEnd);
11154
#endif /* GL_SGIS_texture_edge_clamp */
11155
#ifdef GL_SGIS_texture_filter4
11156
  CONST_CAST(GLEW_SGIS_texture_filter4) = _glewSearchExtension("GL_SGIS_texture_filter4", extStart, extEnd);
11157
  if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT);
11158
#endif /* GL_SGIS_texture_filter4 */
11159
#ifdef GL_SGIS_texture_lod
11160
  CONST_CAST(GLEW_SGIS_texture_lod) = _glewSearchExtension("GL_SGIS_texture_lod", extStart, extEnd);
11161
#endif /* GL_SGIS_texture_lod */
11162
#ifdef GL_SGIS_texture_select
11163
  CONST_CAST(GLEW_SGIS_texture_select) = _glewSearchExtension("GL_SGIS_texture_select", extStart, extEnd);
11164
#endif /* GL_SGIS_texture_select */
11165
#ifdef GL_SGIX_async
11166
  CONST_CAST(GLEW_SGIX_async) = _glewSearchExtension("GL_SGIX_async", extStart, extEnd);
11167
  if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT);
11168
#endif /* GL_SGIX_async */
11169
#ifdef GL_SGIX_async_histogram
11170
  CONST_CAST(GLEW_SGIX_async_histogram) = _glewSearchExtension("GL_SGIX_async_histogram", extStart, extEnd);
11171
#endif /* GL_SGIX_async_histogram */
11172
#ifdef GL_SGIX_async_pixel
11173
  CONST_CAST(GLEW_SGIX_async_pixel) = _glewSearchExtension("GL_SGIX_async_pixel", extStart, extEnd);
11174
#endif /* GL_SGIX_async_pixel */
11175
#ifdef GL_SGIX_blend_alpha_minmax
11176
  CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = _glewSearchExtension("GL_SGIX_blend_alpha_minmax", extStart, extEnd);
11177
#endif /* GL_SGIX_blend_alpha_minmax */
11178
#ifdef GL_SGIX_clipmap
11179
  CONST_CAST(GLEW_SGIX_clipmap) = _glewSearchExtension("GL_SGIX_clipmap", extStart, extEnd);
11180
#endif /* GL_SGIX_clipmap */
11181
#ifdef GL_SGIX_convolution_accuracy
11182
  CONST_CAST(GLEW_SGIX_convolution_accuracy) = _glewSearchExtension("GL_SGIX_convolution_accuracy", extStart, extEnd);
11183
#endif /* GL_SGIX_convolution_accuracy */
11184
#ifdef GL_SGIX_depth_texture
11185
  CONST_CAST(GLEW_SGIX_depth_texture) = _glewSearchExtension("GL_SGIX_depth_texture", extStart, extEnd);
11186
#endif /* GL_SGIX_depth_texture */
11187
#ifdef GL_SGIX_flush_raster
11188
  CONST_CAST(GLEW_SGIX_flush_raster) = _glewSearchExtension("GL_SGIX_flush_raster", extStart, extEnd);
11189
  if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT);
11190
#endif /* GL_SGIX_flush_raster */
11191
#ifdef GL_SGIX_fog_offset
11192
  CONST_CAST(GLEW_SGIX_fog_offset) = _glewSearchExtension("GL_SGIX_fog_offset", extStart, extEnd);
11193
#endif /* GL_SGIX_fog_offset */
11194
#ifdef GL_SGIX_fog_texture
11195
  CONST_CAST(GLEW_SGIX_fog_texture) = _glewSearchExtension("GL_SGIX_fog_texture", extStart, extEnd);
11196
  if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT);
11197
#endif /* GL_SGIX_fog_texture */
11198
#ifdef GL_SGIX_fragment_specular_lighting
11199
  CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = _glewSearchExtension("GL_SGIX_fragment_specular_lighting", extStart, extEnd);
11200
  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);
11201
#endif /* GL_SGIX_fragment_specular_lighting */
11202
#ifdef GL_SGIX_framezoom
11203
  CONST_CAST(GLEW_SGIX_framezoom) = _glewSearchExtension("GL_SGIX_framezoom", extStart, extEnd);
11204
  if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT);
11205
#endif /* GL_SGIX_framezoom */
11206
#ifdef GL_SGIX_interlace
11207
  CONST_CAST(GLEW_SGIX_interlace) = _glewSearchExtension("GL_SGIX_interlace", extStart, extEnd);
11208
#endif /* GL_SGIX_interlace */
11209
#ifdef GL_SGIX_ir_instrument1
11210
  CONST_CAST(GLEW_SGIX_ir_instrument1) = _glewSearchExtension("GL_SGIX_ir_instrument1", extStart, extEnd);
11211
#endif /* GL_SGIX_ir_instrument1 */
11212
#ifdef GL_SGIX_list_priority
11213
  CONST_CAST(GLEW_SGIX_list_priority) = _glewSearchExtension("GL_SGIX_list_priority", extStart, extEnd);
11214
#endif /* GL_SGIX_list_priority */
11215
#ifdef GL_SGIX_pixel_texture
11216
  CONST_CAST(GLEW_SGIX_pixel_texture) = _glewSearchExtension("GL_SGIX_pixel_texture", extStart, extEnd);
11217
  if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT);
11218
#endif /* GL_SGIX_pixel_texture */
11219
#ifdef GL_SGIX_pixel_texture_bits
11220
  CONST_CAST(GLEW_SGIX_pixel_texture_bits) = _glewSearchExtension("GL_SGIX_pixel_texture_bits", extStart, extEnd);
11221
#endif /* GL_SGIX_pixel_texture_bits */
11222
#ifdef GL_SGIX_reference_plane
11223
  CONST_CAST(GLEW_SGIX_reference_plane) = _glewSearchExtension("GL_SGIX_reference_plane", extStart, extEnd);
11224
  if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT);
11225
#endif /* GL_SGIX_reference_plane */
11226
#ifdef GL_SGIX_resample
11227
  CONST_CAST(GLEW_SGIX_resample) = _glewSearchExtension("GL_SGIX_resample", extStart, extEnd);
11228
#endif /* GL_SGIX_resample */
11229
#ifdef GL_SGIX_shadow
11230
  CONST_CAST(GLEW_SGIX_shadow) = _glewSearchExtension("GL_SGIX_shadow", extStart, extEnd);
11231
#endif /* GL_SGIX_shadow */
11232
#ifdef GL_SGIX_shadow_ambient
11233
  CONST_CAST(GLEW_SGIX_shadow_ambient) = _glewSearchExtension("GL_SGIX_shadow_ambient", extStart, extEnd);
11234
#endif /* GL_SGIX_shadow_ambient */
11235
#ifdef GL_SGIX_sprite
11236
  CONST_CAST(GLEW_SGIX_sprite) = _glewSearchExtension("GL_SGIX_sprite", extStart, extEnd);
11237
  if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT);
11238
#endif /* GL_SGIX_sprite */
11239
#ifdef GL_SGIX_tag_sample_buffer
11240
  CONST_CAST(GLEW_SGIX_tag_sample_buffer) = _glewSearchExtension("GL_SGIX_tag_sample_buffer", extStart, extEnd);
11241
  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);
11242
#endif /* GL_SGIX_tag_sample_buffer */
11243
#ifdef GL_SGIX_texture_add_env
11244
  CONST_CAST(GLEW_SGIX_texture_add_env) = _glewSearchExtension("GL_SGIX_texture_add_env", extStart, extEnd);
11245
#endif /* GL_SGIX_texture_add_env */
11246
#ifdef GL_SGIX_texture_coordinate_clamp
11247
  CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = _glewSearchExtension("GL_SGIX_texture_coordinate_clamp", extStart, extEnd);
11248
#endif /* GL_SGIX_texture_coordinate_clamp */
11249
#ifdef GL_SGIX_texture_lod_bias
11250
  CONST_CAST(GLEW_SGIX_texture_lod_bias) = _glewSearchExtension("GL_SGIX_texture_lod_bias", extStart, extEnd);
11251
#endif /* GL_SGIX_texture_lod_bias */
11252
#ifdef GL_SGIX_texture_multi_buffer
11253
  CONST_CAST(GLEW_SGIX_texture_multi_buffer) = _glewSearchExtension("GL_SGIX_texture_multi_buffer", extStart, extEnd);
11254
#endif /* GL_SGIX_texture_multi_buffer */
11255
#ifdef GL_SGIX_texture_range
11256
  CONST_CAST(GLEW_SGIX_texture_range) = _glewSearchExtension("GL_SGIX_texture_range", extStart, extEnd);
11257
#endif /* GL_SGIX_texture_range */
11258
#ifdef GL_SGIX_texture_scale_bias
11259
  CONST_CAST(GLEW_SGIX_texture_scale_bias) = _glewSearchExtension("GL_SGIX_texture_scale_bias", extStart, extEnd);
11260
#endif /* GL_SGIX_texture_scale_bias */
11261
#ifdef GL_SGIX_vertex_preclip
11262
  CONST_CAST(GLEW_SGIX_vertex_preclip) = _glewSearchExtension("GL_SGIX_vertex_preclip", extStart, extEnd);
11263
#endif /* GL_SGIX_vertex_preclip */
11264
#ifdef GL_SGIX_vertex_preclip_hint
11265
  CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = _glewSearchExtension("GL_SGIX_vertex_preclip_hint", extStart, extEnd);
11266
#endif /* GL_SGIX_vertex_preclip_hint */
11267
#ifdef GL_SGIX_ycrcb
11268
  CONST_CAST(GLEW_SGIX_ycrcb) = _glewSearchExtension("GL_SGIX_ycrcb", extStart, extEnd);
11269
#endif /* GL_SGIX_ycrcb */
11270
#ifdef GL_SGI_color_matrix
11271
  CONST_CAST(GLEW_SGI_color_matrix) = _glewSearchExtension("GL_SGI_color_matrix", extStart, extEnd);
11272
#endif /* GL_SGI_color_matrix */
11273
#ifdef GL_SGI_color_table
11274
  CONST_CAST(GLEW_SGI_color_table) = _glewSearchExtension("GL_SGI_color_table", extStart, extEnd);
11275
  if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT);
11276
#endif /* GL_SGI_color_table */
11277
#ifdef GL_SGI_texture_color_table
11278
  CONST_CAST(GLEW_SGI_texture_color_table) = _glewSearchExtension("GL_SGI_texture_color_table", extStart, extEnd);
11279
#endif /* GL_SGI_texture_color_table */
11280
#ifdef GL_SUNX_constant_data
11281
  CONST_CAST(GLEW_SUNX_constant_data) = _glewSearchExtension("GL_SUNX_constant_data", extStart, extEnd);
11282
  if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT);
11283
#endif /* GL_SUNX_constant_data */
11284
#ifdef GL_SUN_convolution_border_modes
11285
  CONST_CAST(GLEW_SUN_convolution_border_modes) = _glewSearchExtension("GL_SUN_convolution_border_modes", extStart, extEnd);
11286
#endif /* GL_SUN_convolution_border_modes */
11287
#ifdef GL_SUN_global_alpha
11288
  CONST_CAST(GLEW_SUN_global_alpha) = _glewSearchExtension("GL_SUN_global_alpha", extStart, extEnd);
11289
  if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT);
11290
#endif /* GL_SUN_global_alpha */
11291
#ifdef GL_SUN_mesh_array
11292
  CONST_CAST(GLEW_SUN_mesh_array) = _glewSearchExtension("GL_SUN_mesh_array", extStart, extEnd);
11293
#endif /* GL_SUN_mesh_array */
11294
#ifdef GL_SUN_read_video_pixels
11295
  CONST_CAST(GLEW_SUN_read_video_pixels) = _glewSearchExtension("GL_SUN_read_video_pixels", extStart, extEnd);
11296
  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);
11297
#endif /* GL_SUN_read_video_pixels */
11298
#ifdef GL_SUN_slice_accum
11299
  CONST_CAST(GLEW_SUN_slice_accum) = _glewSearchExtension("GL_SUN_slice_accum", extStart, extEnd);
11300
#endif /* GL_SUN_slice_accum */
11301
#ifdef GL_SUN_triangle_list
11302
  CONST_CAST(GLEW_SUN_triangle_list) = _glewSearchExtension("GL_SUN_triangle_list", extStart, extEnd);
11303
  if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT);
11304
#endif /* GL_SUN_triangle_list */
11305
#ifdef GL_SUN_vertex
11306
  CONST_CAST(GLEW_SUN_vertex) = _glewSearchExtension("GL_SUN_vertex", extStart, extEnd);
11307
  if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
11308
#endif /* GL_SUN_vertex */
11309
#ifdef GL_WIN_phong_shading
11310
  CONST_CAST(GLEW_WIN_phong_shading) = _glewSearchExtension("GL_WIN_phong_shading", extStart, extEnd);
11311
#endif /* GL_WIN_phong_shading */
11312
#ifdef GL_WIN_specular_fog
11313
  CONST_CAST(GLEW_WIN_specular_fog) = _glewSearchExtension("GL_WIN_specular_fog", extStart, extEnd);
11314
#endif /* GL_WIN_specular_fog */
11315
#ifdef GL_WIN_swap_hint
11316
  CONST_CAST(GLEW_WIN_swap_hint) = _glewSearchExtension("GL_WIN_swap_hint", extStart, extEnd);
11317
  if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT);
11318
#endif /* GL_WIN_swap_hint */
11319
 
11320
  return GLEW_OK;
11321
}
11322
 
11323
 
11324
#if defined(_WIN32)
11325
 
11326
#if !defined(GLEW_MX)
11327
 
11328
PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;
11329
 
11330
PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL;
11331
PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL;
11332
PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL;
11333
PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL;
11334
PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL;
11335
PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL;
11336
PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL;
11337
PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL;
11338
PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL;
11339
 
11340
PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;
11341
PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;
11342
PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;
11343
PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;
11344
 
11345
PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL;
11346
 
11347
PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;
11348
 
11349
PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;
11350
PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;
11351
 
11352
PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;
11353
PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;
11354
PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;
11355
PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;
11356
PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;
11357
 
11358
PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;
11359
PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;
11360
PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;
11361
 
11362
PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;
11363
PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;
11364
PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;
11365
 
11366
PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;
11367
PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;
11368
PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;
11369
PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;
11370
 
11371
PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;
11372
 
11373
PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;
11374
PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;
11375
 
11376
PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;
11377
PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;
11378
PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;
11379
PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;
11380
PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;
11381
 
11382
PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;
11383
PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;
11384
PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;
11385
 
11386
PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;
11387
PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;
11388
 
11389
PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;
11390
PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;
11391
 
11392
PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;
11393
PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;
11394
PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;
11395
PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;
11396
 
11397
PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;
11398
PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;
11399
PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;
11400
PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;
11401
PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;
11402
PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;
11403
PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;
11404
PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;
11405
PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;
11406
PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;
11407
PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;
11408
PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;
11409
 
11410
PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;
11411
PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;
11412
PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;
11413
PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;
11414
 
11415
PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;
11416
PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;
11417
PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;
11418
PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;
11419
 
11420
PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;
11421
PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;
11422
PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;
11423
PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;
11424
 
11425
PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV = NULL;
11426
PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV = NULL;
11427
PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV = NULL;
11428
PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV = NULL;
11429
PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV = NULL;
11430
PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV = NULL;
11431
PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV = NULL;
11432
PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV = NULL;
11433
 
11434
PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL;
11435
 
11436
PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;
11437
PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;
11438
PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;
11439
PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL;
11440
PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL;
11441
 
11442
PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL;
11443
PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL;
11444
PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL;
11445
 
11446
PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL;
11447
PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL;
11448
PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL;
11449
PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL;
11450
PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL;
11451
PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL;
11452
 
11453
PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;
11454
PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;
11455
 
11456
PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV = NULL;
11457
PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV = NULL;
11458
PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV = NULL;
11459
PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV = NULL;
11460
PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV = NULL;
11461
 
11462
PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL;
11463
PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL;
11464
PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL;
11465
PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL;
11466
PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL;
11467
PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL;
11468
 
11469
PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;
11470
PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;
11471
PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;
11472
PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;
11473
PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;
11474
PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;
11475
GLboolean __WGLEW_3DFX_multisample = GL_FALSE;
11476
GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;
11477
GLboolean __WGLEW_AMD_gpu_association = GL_FALSE;
11478
GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;
11479
GLboolean __WGLEW_ARB_create_context = GL_FALSE;
11480
GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE;
11481
GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE;
11482
GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;
11483
GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE;
11484
GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;
11485
GLboolean __WGLEW_ARB_multisample = GL_FALSE;
11486
GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;
11487
GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;
11488
GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;
11489
GLboolean __WGLEW_ARB_render_texture = GL_FALSE;
677 janba 11490
GLboolean __WGLEW_ARB_robustness_application_isolation = GL_FALSE;
11491
GLboolean __WGLEW_ARB_robustness_share_group_isolation = GL_FALSE;
667 khor 11492
GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;
11493
GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;
11494
GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE;
11495
GLboolean __WGLEW_EXT_create_context_es_profile = GL_FALSE;
11496
GLboolean __WGLEW_EXT_depth_float = GL_FALSE;
11497
GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;
11498
GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;
11499
GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE;
11500
GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;
11501
GLboolean __WGLEW_EXT_multisample = GL_FALSE;
11502
GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;
11503
GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;
11504
GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE;
11505
GLboolean __WGLEW_EXT_swap_control = GL_FALSE;
11506
GLboolean __WGLEW_EXT_swap_control_tear = GL_FALSE;
11507
GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;
11508
GLboolean __WGLEW_I3D_gamma = GL_FALSE;
11509
GLboolean __WGLEW_I3D_genlock = GL_FALSE;
11510
GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;
11511
GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;
11512
GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;
11513
GLboolean __WGLEW_NV_DX_interop = GL_FALSE;
11514
GLboolean __WGLEW_NV_DX_interop2 = GL_FALSE;
11515
GLboolean __WGLEW_NV_copy_image = GL_FALSE;
11516
GLboolean __WGLEW_NV_float_buffer = GL_FALSE;
11517
GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;
11518
GLboolean __WGLEW_NV_multisample_coverage = GL_FALSE;
11519
GLboolean __WGLEW_NV_present_video = GL_FALSE;
11520
GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;
11521
GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;
11522
GLboolean __WGLEW_NV_swap_group = GL_FALSE;
11523
GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;
11524
GLboolean __WGLEW_NV_video_capture = GL_FALSE;
11525
GLboolean __WGLEW_NV_video_output = GL_FALSE;
11526
GLboolean __WGLEW_OML_sync_control = GL_FALSE;
11527
 
11528
#endif /* !GLEW_MX */
11529
 
11530
#ifdef WGL_3DFX_multisample
11531
 
11532
#endif /* WGL_3DFX_multisample */
11533
 
11534
#ifdef WGL_3DL_stereo_control
11535
 
11536
static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT)
11537
{
11538
  GLboolean r = GL_FALSE;
11539
 
11540
  r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r;
11541
 
11542
  return r;
11543
}
11544
 
11545
#endif /* WGL_3DL_stereo_control */
11546
 
11547
#ifdef WGL_AMD_gpu_association
11548
 
11549
static GLboolean _glewInit_WGL_AMD_gpu_association (WGLEW_CONTEXT_ARG_DEF_INIT)
11550
{
11551
  GLboolean r = GL_FALSE;
11552
 
11553
  r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r;
11554
  r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r;
11555
  r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r;
11556
  r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r;
11557
  r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r;
11558
  r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r;
11559
  r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r;
11560
  r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r;
11561
  r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r;
11562
 
11563
  return r;
11564
}
11565
 
11566
#endif /* WGL_AMD_gpu_association */
11567
 
11568
#ifdef WGL_ARB_buffer_region
11569
 
11570
static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)
11571
{
11572
  GLboolean r = GL_FALSE;
11573
 
11574
  r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;
11575
  r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;
11576
  r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;
11577
  r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;
11578
 
11579
  return r;
11580
}
11581
 
11582
#endif /* WGL_ARB_buffer_region */
11583
 
11584
#ifdef WGL_ARB_create_context
11585
 
11586
static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT)
11587
{
11588
  GLboolean r = GL_FALSE;
11589
 
11590
  r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r;
11591
 
11592
  return r;
11593
}
11594
 
11595
#endif /* WGL_ARB_create_context */
11596
 
11597
#ifdef WGL_ARB_create_context_profile
11598
 
11599
#endif /* WGL_ARB_create_context_profile */
11600
 
11601
#ifdef WGL_ARB_create_context_robustness
11602
 
11603
#endif /* WGL_ARB_create_context_robustness */
11604
 
11605
#ifdef WGL_ARB_extensions_string
11606
 
11607
static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
11608
{
11609
  GLboolean r = GL_FALSE;
11610
 
11611
  r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;
11612
 
11613
  return r;
11614
}
11615
 
11616
#endif /* WGL_ARB_extensions_string */
11617
 
11618
#ifdef WGL_ARB_framebuffer_sRGB
11619
 
11620
#endif /* WGL_ARB_framebuffer_sRGB */
11621
 
11622
#ifdef WGL_ARB_make_current_read
11623
 
11624
static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)
11625
{
11626
  GLboolean r = GL_FALSE;
11627
 
11628
  r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;
11629
  r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;
11630
 
11631
  return r;
11632
}
11633
 
11634
#endif /* WGL_ARB_make_current_read */
11635
 
11636
#ifdef WGL_ARB_multisample
11637
 
11638
#endif /* WGL_ARB_multisample */
11639
 
11640
#ifdef WGL_ARB_pbuffer
11641
 
11642
static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
11643
{
11644
  GLboolean r = GL_FALSE;
11645
 
11646
  r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;
11647
  r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;
11648
  r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;
11649
  r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;
11650
  r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;
11651
 
11652
  return r;
11653
}
11654
 
11655
#endif /* WGL_ARB_pbuffer */
11656
 
11657
#ifdef WGL_ARB_pixel_format
11658
 
11659
static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
11660
{
11661
  GLboolean r = GL_FALSE;
11662
 
11663
  r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;
11664
  r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;
11665
  r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;
11666
 
11667
  return r;
11668
}
11669
 
11670
#endif /* WGL_ARB_pixel_format */
11671
 
11672
#ifdef WGL_ARB_pixel_format_float
11673
 
11674
#endif /* WGL_ARB_pixel_format_float */
11675
 
11676
#ifdef WGL_ARB_render_texture
11677
 
11678
static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)
11679
{
11680
  GLboolean r = GL_FALSE;
11681
 
11682
  r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;
11683
  r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;
11684
  r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;
11685
 
11686
  return r;
11687
}
11688
 
11689
#endif /* WGL_ARB_render_texture */
11690
 
677 janba 11691
#ifdef WGL_ARB_robustness_application_isolation
11692
 
11693
#endif /* WGL_ARB_robustness_application_isolation */
11694
 
11695
#ifdef WGL_ARB_robustness_share_group_isolation
11696
 
11697
#endif /* WGL_ARB_robustness_share_group_isolation */
11698
 
667 khor 11699
#ifdef WGL_ATI_pixel_format_float
11700
 
11701
#endif /* WGL_ATI_pixel_format_float */
11702
 
11703
#ifdef WGL_ATI_render_texture_rectangle
11704
 
11705
#endif /* WGL_ATI_render_texture_rectangle */
11706
 
11707
#ifdef WGL_EXT_create_context_es2_profile
11708
 
11709
#endif /* WGL_EXT_create_context_es2_profile */
11710
 
11711
#ifdef WGL_EXT_create_context_es_profile
11712
 
11713
#endif /* WGL_EXT_create_context_es_profile */
11714
 
11715
#ifdef WGL_EXT_depth_float
11716
 
11717
#endif /* WGL_EXT_depth_float */
11718
 
11719
#ifdef WGL_EXT_display_color_table
11720
 
11721
static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT)
11722
{
11723
  GLboolean r = GL_FALSE;
11724
 
11725
  r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;
11726
  r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;
11727
  r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;
11728
  r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;
11729
 
11730
  return r;
11731
}
11732
 
11733
#endif /* WGL_EXT_display_color_table */
11734
 
11735
#ifdef WGL_EXT_extensions_string
11736
 
11737
static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
11738
{
11739
  GLboolean r = GL_FALSE;
11740
 
11741
  r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;
11742
 
11743
  return r;
11744
}
11745
 
11746
#endif /* WGL_EXT_extensions_string */
11747
 
11748
#ifdef WGL_EXT_framebuffer_sRGB
11749
 
11750
#endif /* WGL_EXT_framebuffer_sRGB */
11751
 
11752
#ifdef WGL_EXT_make_current_read
11753
 
11754
static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)
11755
{
11756
  GLboolean r = GL_FALSE;
11757
 
11758
  r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;
11759
  r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;
11760
 
11761
  return r;
11762
}
11763
 
11764
#endif /* WGL_EXT_make_current_read */
11765
 
11766
#ifdef WGL_EXT_multisample
11767
 
11768
#endif /* WGL_EXT_multisample */
11769
 
11770
#ifdef WGL_EXT_pbuffer
11771
 
11772
static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
11773
{
11774
  GLboolean r = GL_FALSE;
11775
 
11776
  r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;
11777
  r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;
11778
  r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;
11779
  r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;
11780
  r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;
11781
 
11782
  return r;
11783
}
11784
 
11785
#endif /* WGL_EXT_pbuffer */
11786
 
11787
#ifdef WGL_EXT_pixel_format
11788
 
11789
static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
11790
{
11791
  GLboolean r = GL_FALSE;
11792
 
11793
  r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;
11794
  r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;
11795
  r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;
11796
 
11797
  return r;
11798
}
11799
 
11800
#endif /* WGL_EXT_pixel_format */
11801
 
11802
#ifdef WGL_EXT_pixel_format_packed_float
11803
 
11804
#endif /* WGL_EXT_pixel_format_packed_float */
11805
 
11806
#ifdef WGL_EXT_swap_control
11807
 
11808
static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)
11809
{
11810
  GLboolean r = GL_FALSE;
11811
 
11812
  r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;
11813
  r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;
11814
 
11815
  return r;
11816
}
11817
 
11818
#endif /* WGL_EXT_swap_control */
11819
 
11820
#ifdef WGL_EXT_swap_control_tear
11821
 
11822
#endif /* WGL_EXT_swap_control_tear */
11823
 
11824
#ifdef WGL_I3D_digital_video_control
11825
 
11826
static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT)
11827
{
11828
  GLboolean r = GL_FALSE;
11829
 
11830
  r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;
11831
  r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;
11832
 
11833
  return r;
11834
}
11835
 
11836
#endif /* WGL_I3D_digital_video_control */
11837
 
11838
#ifdef WGL_I3D_gamma
11839
 
11840
static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT)
11841
{
11842
  GLboolean r = GL_FALSE;
11843
 
11844
  r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;
11845
  r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;
11846
  r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;
11847
  r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;
11848
 
11849
  return r;
11850
}
11851
 
11852
#endif /* WGL_I3D_gamma */
11853
 
11854
#ifdef WGL_I3D_genlock
11855
 
11856
static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT)
11857
{
11858
  GLboolean r = GL_FALSE;
11859
 
11860
  r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;
11861
  r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;
11862
  r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;
11863
  r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;
11864
  r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;
11865
  r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;
11866
  r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;
11867
  r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;
11868
  r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;
11869
  r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;
11870
  r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;
11871
  r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;
11872
 
11873
  return r;
11874
}
11875
 
11876
#endif /* WGL_I3D_genlock */
11877
 
11878
#ifdef WGL_I3D_image_buffer
11879
 
11880
static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT)
11881
{
11882
  GLboolean r = GL_FALSE;
11883
 
11884
  r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;
11885
  r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;
11886
  r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;
11887
  r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;
11888
 
11889
  return r;
11890
}
11891
 
11892
#endif /* WGL_I3D_image_buffer */
11893
 
11894
#ifdef WGL_I3D_swap_frame_lock
11895
 
11896
static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT)
11897
{
11898
  GLboolean r = GL_FALSE;
11899
 
11900
  r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;
11901
  r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;
11902
  r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;
11903
  r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;
11904
 
11905
  return r;
11906
}
11907
 
11908
#endif /* WGL_I3D_swap_frame_lock */
11909
 
11910
#ifdef WGL_I3D_swap_frame_usage
11911
 
11912
static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)
11913
{
11914
  GLboolean r = GL_FALSE;
11915
 
11916
  r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;
11917
  r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;
11918
  r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;
11919
  r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;
11920
 
11921
  return r;
11922
}
11923
 
11924
#endif /* WGL_I3D_swap_frame_usage */
11925
 
11926
#ifdef WGL_NV_DX_interop
11927
 
11928
static GLboolean _glewInit_WGL_NV_DX_interop (WGLEW_CONTEXT_ARG_DEF_INIT)
11929
{
11930
  GLboolean r = GL_FALSE;
11931
 
11932
  r = ((wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXCloseDeviceNV")) == NULL) || r;
11933
  r = ((wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXLockObjectsNV")) == NULL) || r;
11934
  r = ((wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXObjectAccessNV")) == NULL) || r;
11935
  r = ((wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXOpenDeviceNV")) == NULL) || r;
11936
  r = ((wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXRegisterObjectNV")) == NULL) || r;
11937
  r = ((wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"wglDXSetResourceShareHandleNV")) == NULL) || r;
11938
  r = ((wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnlockObjectsNV")) == NULL) || r;
11939
  r = ((wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnregisterObjectNV")) == NULL) || r;
11940
 
11941
  return r;
11942
}
11943
 
11944
#endif /* WGL_NV_DX_interop */
11945
 
11946
#ifdef WGL_NV_DX_interop2
11947
 
11948
#endif /* WGL_NV_DX_interop2 */
11949
 
11950
#ifdef WGL_NV_copy_image
11951
 
11952
static GLboolean _glewInit_WGL_NV_copy_image (WGLEW_CONTEXT_ARG_DEF_INIT)
11953
{
11954
  GLboolean r = GL_FALSE;
11955
 
11956
  r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r;
11957
 
11958
  return r;
11959
}
11960
 
11961
#endif /* WGL_NV_copy_image */
11962
 
11963
#ifdef WGL_NV_float_buffer
11964
 
11965
#endif /* WGL_NV_float_buffer */
11966
 
11967
#ifdef WGL_NV_gpu_affinity
11968
 
11969
static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT)
11970
{
11971
  GLboolean r = GL_FALSE;
11972
 
11973
  r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r;
11974
  r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r;
11975
  r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r;
11976
  r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r;
11977
  r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r;
11978
 
11979
  return r;
11980
}
11981
 
11982
#endif /* WGL_NV_gpu_affinity */
11983
 
11984
#ifdef WGL_NV_multisample_coverage
11985
 
11986
#endif /* WGL_NV_multisample_coverage */
11987
 
11988
#ifdef WGL_NV_present_video
11989
 
11990
static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT)
11991
{
11992
  GLboolean r = GL_FALSE;
11993
 
11994
  r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r;
11995
  r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r;
11996
  r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r;
11997
 
11998
  return r;
11999
}
12000
 
12001
#endif /* WGL_NV_present_video */
12002
 
12003
#ifdef WGL_NV_render_depth_texture
12004
 
12005
#endif /* WGL_NV_render_depth_texture */
12006
 
12007
#ifdef WGL_NV_render_texture_rectangle
12008
 
12009
#endif /* WGL_NV_render_texture_rectangle */
12010
 
12011
#ifdef WGL_NV_swap_group
12012
 
12013
static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT)
12014
{
12015
  GLboolean r = GL_FALSE;
12016
 
12017
  r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r;
12018
  r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r;
12019
  r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r;
12020
  r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r;
12021
  r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r;
12022
  r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r;
12023
 
12024
  return r;
12025
}
12026
 
12027
#endif /* WGL_NV_swap_group */
12028
 
12029
#ifdef WGL_NV_vertex_array_range
12030
 
12031
static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT)
12032
{
12033
  GLboolean r = GL_FALSE;
12034
 
12035
  r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;
12036
  r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;
12037
 
12038
  return r;
12039
}
12040
 
12041
#endif /* WGL_NV_vertex_array_range */
12042
 
12043
#ifdef WGL_NV_video_capture
12044
 
12045
static GLboolean _glewInit_WGL_NV_video_capture (WGLEW_CONTEXT_ARG_DEF_INIT)
12046
{
12047
  GLboolean r = GL_FALSE;
12048
 
12049
  r = ((wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoCaptureDeviceNV")) == NULL) || r;
12050
  r = ((wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoCaptureDevicesNV")) == NULL) || r;
12051
  r = ((wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglLockVideoCaptureDeviceNV")) == NULL) || r;
12052
  r = ((wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglQueryVideoCaptureDeviceNV")) == NULL) || r;
12053
  r = ((wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoCaptureDeviceNV")) == NULL) || r;
12054
 
12055
  return r;
12056
}
12057
 
12058
#endif /* WGL_NV_video_capture */
12059
 
12060
#ifdef WGL_NV_video_output
12061
 
12062
static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT)
12063
{
12064
  GLboolean r = GL_FALSE;
12065
 
12066
  r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r;
12067
  r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r;
12068
  r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r;
12069
  r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r;
12070
  r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r;
12071
  r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r;
12072
 
12073
  return r;
12074
}
12075
 
12076
#endif /* WGL_NV_video_output */
12077
 
12078
#ifdef WGL_OML_sync_control
12079
 
12080
static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT)
12081
{
12082
  GLboolean r = GL_FALSE;
12083
 
12084
  r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;
12085
  r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;
12086
  r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;
12087
  r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;
12088
  r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;
12089
  r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;
12090
 
12091
  return r;
12092
}
12093
 
12094
#endif /* WGL_OML_sync_control */
12095
 
12096
/* ------------------------------------------------------------------------- */
12097
 
12098
static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;
12099
static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;
12100
 
12101
GLboolean GLEWAPIENTRY wglewGetExtension (const char* name)
12102
{    
12103
  const GLubyte* start;
12104
  const GLubyte* end;
12105
  if (_wglewGetExtensionsStringARB == NULL)
12106
    if (_wglewGetExtensionsStringEXT == NULL)
12107
      return GL_FALSE;
12108
    else
12109
      start = (const GLubyte*)_wglewGetExtensionsStringEXT();
12110
  else
12111
    start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
12112
  if (start == 0)
12113
    return GL_FALSE;
12114
  end = start + _glewStrLen(start);
12115
  return _glewSearchExtension(name, start, end);
12116
}
12117
 
12118
GLenum GLEWAPIENTRY wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
12119
{
12120
  GLboolean crippled;
12121
  const GLubyte* extStart;
12122
  const GLubyte* extEnd;
12123
  /* find wgl extension string query functions */
12124
  _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");
12125
  _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");
12126
  /* query wgl extension string */
12127
  if (_wglewGetExtensionsStringARB == NULL)
12128
    if (_wglewGetExtensionsStringEXT == NULL)
12129
      extStart = (const GLubyte*)"";
12130
    else
12131
      extStart = (const GLubyte*)_wglewGetExtensionsStringEXT();
12132
  else
12133
    extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
12134
  extEnd = extStart + _glewStrLen(extStart);
12135
  /* initialize extensions */
12136
  crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;
12137
#ifdef WGL_3DFX_multisample
12138
  CONST_CAST(WGLEW_3DFX_multisample) = _glewSearchExtension("WGL_3DFX_multisample", extStart, extEnd);
12139
#endif /* WGL_3DFX_multisample */
12140
#ifdef WGL_3DL_stereo_control
12141
  CONST_CAST(WGLEW_3DL_stereo_control) = _glewSearchExtension("WGL_3DL_stereo_control", extStart, extEnd);
12142
  if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT);
12143
#endif /* WGL_3DL_stereo_control */
12144
#ifdef WGL_AMD_gpu_association
12145
  CONST_CAST(WGLEW_AMD_gpu_association) = _glewSearchExtension("WGL_AMD_gpu_association", extStart, extEnd);
12146
  if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) CONST_CAST(WGLEW_AMD_gpu_association)= !_glewInit_WGL_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT);
12147
#endif /* WGL_AMD_gpu_association */
12148
#ifdef WGL_ARB_buffer_region
12149
  CONST_CAST(WGLEW_ARB_buffer_region) = _glewSearchExtension("WGL_ARB_buffer_region", extStart, extEnd);
12150
  if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
12151
#endif /* WGL_ARB_buffer_region */
12152
#ifdef WGL_ARB_create_context
12153
  CONST_CAST(WGLEW_ARB_create_context) = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd);
12154
  if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
12155
#endif /* WGL_ARB_create_context */
12156
#ifdef WGL_ARB_create_context_profile
12157
  CONST_CAST(WGLEW_ARB_create_context_profile) = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd);
12158
#endif /* WGL_ARB_create_context_profile */
12159
#ifdef WGL_ARB_create_context_robustness
12160
  CONST_CAST(WGLEW_ARB_create_context_robustness) = _glewSearchExtension("WGL_ARB_create_context_robustness", extStart, extEnd);
12161
#endif /* WGL_ARB_create_context_robustness */
12162
#ifdef WGL_ARB_extensions_string
12163
  CONST_CAST(WGLEW_ARB_extensions_string) = _glewSearchExtension("WGL_ARB_extensions_string", extStart, extEnd);
12164
  if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
12165
#endif /* WGL_ARB_extensions_string */
12166
#ifdef WGL_ARB_framebuffer_sRGB
12167
  CONST_CAST(WGLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("WGL_ARB_framebuffer_sRGB", extStart, extEnd);
12168
#endif /* WGL_ARB_framebuffer_sRGB */
12169
#ifdef WGL_ARB_make_current_read
12170
  CONST_CAST(WGLEW_ARB_make_current_read) = _glewSearchExtension("WGL_ARB_make_current_read", extStart, extEnd);
12171
  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);
12172
#endif /* WGL_ARB_make_current_read */
12173
#ifdef WGL_ARB_multisample
12174
  CONST_CAST(WGLEW_ARB_multisample) = _glewSearchExtension("WGL_ARB_multisample", extStart, extEnd);
12175
#endif /* WGL_ARB_multisample */
12176
#ifdef WGL_ARB_pbuffer
12177
  CONST_CAST(WGLEW_ARB_pbuffer) = _glewSearchExtension("WGL_ARB_pbuffer", extStart, extEnd);
12178
  if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
12179
#endif /* WGL_ARB_pbuffer */
12180
#ifdef WGL_ARB_pixel_format
12181
  CONST_CAST(WGLEW_ARB_pixel_format) = _glewSearchExtension("WGL_ARB_pixel_format", extStart, extEnd);
12182
  if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
12183
#endif /* WGL_ARB_pixel_format */
12184
#ifdef WGL_ARB_pixel_format_float
12185
  CONST_CAST(WGLEW_ARB_pixel_format_float) = _glewSearchExtension("WGL_ARB_pixel_format_float", extStart, extEnd);
12186
#endif /* WGL_ARB_pixel_format_float */
12187
#ifdef WGL_ARB_render_texture
12188
  CONST_CAST(WGLEW_ARB_render_texture) = _glewSearchExtension("WGL_ARB_render_texture", extStart, extEnd);
12189
  if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
12190
#endif /* WGL_ARB_render_texture */
677 janba 12191
#ifdef WGL_ARB_robustness_application_isolation
12192
  CONST_CAST(WGLEW_ARB_robustness_application_isolation) = _glewSearchExtension("WGL_ARB_robustness_application_isolation", extStart, extEnd);
12193
#endif /* WGL_ARB_robustness_application_isolation */
12194
#ifdef WGL_ARB_robustness_share_group_isolation
12195
  CONST_CAST(WGLEW_ARB_robustness_share_group_isolation) = _glewSearchExtension("WGL_ARB_robustness_share_group_isolation", extStart, extEnd);
12196
#endif /* WGL_ARB_robustness_share_group_isolation */
667 khor 12197
#ifdef WGL_ATI_pixel_format_float
12198
  CONST_CAST(WGLEW_ATI_pixel_format_float) = _glewSearchExtension("WGL_ATI_pixel_format_float", extStart, extEnd);
12199
#endif /* WGL_ATI_pixel_format_float */
12200
#ifdef WGL_ATI_render_texture_rectangle
12201
  CONST_CAST(WGLEW_ATI_render_texture_rectangle) = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd);
12202
#endif /* WGL_ATI_render_texture_rectangle */
12203
#ifdef WGL_EXT_create_context_es2_profile
12204
  CONST_CAST(WGLEW_EXT_create_context_es2_profile) = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd);
12205
#endif /* WGL_EXT_create_context_es2_profile */
12206
#ifdef WGL_EXT_create_context_es_profile
12207
  CONST_CAST(WGLEW_EXT_create_context_es_profile) = _glewSearchExtension("WGL_EXT_create_context_es_profile", extStart, extEnd);
12208
#endif /* WGL_EXT_create_context_es_profile */
12209
#ifdef WGL_EXT_depth_float
12210
  CONST_CAST(WGLEW_EXT_depth_float) = _glewSearchExtension("WGL_EXT_depth_float", extStart, extEnd);
12211
#endif /* WGL_EXT_depth_float */
12212
#ifdef WGL_EXT_display_color_table
12213
  CONST_CAST(WGLEW_EXT_display_color_table) = _glewSearchExtension("WGL_EXT_display_color_table", extStart, extEnd);
12214
  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);
12215
#endif /* WGL_EXT_display_color_table */
12216
#ifdef WGL_EXT_extensions_string
12217
  CONST_CAST(WGLEW_EXT_extensions_string) = _glewSearchExtension("WGL_EXT_extensions_string", extStart, extEnd);
12218
  if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
12219
#endif /* WGL_EXT_extensions_string */
12220
#ifdef WGL_EXT_framebuffer_sRGB
12221
  CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("WGL_EXT_framebuffer_sRGB", extStart, extEnd);
12222
#endif /* WGL_EXT_framebuffer_sRGB */
12223
#ifdef WGL_EXT_make_current_read
12224
  CONST_CAST(WGLEW_EXT_make_current_read) = _glewSearchExtension("WGL_EXT_make_current_read", extStart, extEnd);
12225
  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);
12226
#endif /* WGL_EXT_make_current_read */
12227
#ifdef WGL_EXT_multisample
12228
  CONST_CAST(WGLEW_EXT_multisample) = _glewSearchExtension("WGL_EXT_multisample", extStart, extEnd);
12229
#endif /* WGL_EXT_multisample */
12230
#ifdef WGL_EXT_pbuffer
12231
  CONST_CAST(WGLEW_EXT_pbuffer) = _glewSearchExtension("WGL_EXT_pbuffer", extStart, extEnd);
12232
  if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
12233
#endif /* WGL_EXT_pbuffer */
12234
#ifdef WGL_EXT_pixel_format
12235
  CONST_CAST(WGLEW_EXT_pixel_format) = _glewSearchExtension("WGL_EXT_pixel_format", extStart, extEnd);
12236
  if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
12237
#endif /* WGL_EXT_pixel_format */
12238
#ifdef WGL_EXT_pixel_format_packed_float
12239
  CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = _glewSearchExtension("WGL_EXT_pixel_format_packed_float", extStart, extEnd);
12240
#endif /* WGL_EXT_pixel_format_packed_float */
12241
#ifdef WGL_EXT_swap_control
12242
  CONST_CAST(WGLEW_EXT_swap_control) = _glewSearchExtension("WGL_EXT_swap_control", extStart, extEnd);
12243
  if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
12244
#endif /* WGL_EXT_swap_control */
12245
#ifdef WGL_EXT_swap_control_tear
12246
  CONST_CAST(WGLEW_EXT_swap_control_tear) = _glewSearchExtension("WGL_EXT_swap_control_tear", extStart, extEnd);
12247
#endif /* WGL_EXT_swap_control_tear */
12248
#ifdef WGL_I3D_digital_video_control
12249
  CONST_CAST(WGLEW_I3D_digital_video_control) = _glewSearchExtension("WGL_I3D_digital_video_control", extStart, extEnd);
12250
  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);
12251
#endif /* WGL_I3D_digital_video_control */
12252
#ifdef WGL_I3D_gamma
12253
  CONST_CAST(WGLEW_I3D_gamma) = _glewSearchExtension("WGL_I3D_gamma", extStart, extEnd);
12254
  if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT);
12255
#endif /* WGL_I3D_gamma */
12256
#ifdef WGL_I3D_genlock
12257
  CONST_CAST(WGLEW_I3D_genlock) = _glewSearchExtension("WGL_I3D_genlock", extStart, extEnd);
12258
  if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT);
12259
#endif /* WGL_I3D_genlock */
12260
#ifdef WGL_I3D_image_buffer
12261
  CONST_CAST(WGLEW_I3D_image_buffer) = _glewSearchExtension("WGL_I3D_image_buffer", extStart, extEnd);
12262
  if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
12263
#endif /* WGL_I3D_image_buffer */
12264
#ifdef WGL_I3D_swap_frame_lock
12265
  CONST_CAST(WGLEW_I3D_swap_frame_lock) = _glewSearchExtension("WGL_I3D_swap_frame_lock", extStart, extEnd);
12266
  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);
12267
#endif /* WGL_I3D_swap_frame_lock */
12268
#ifdef WGL_I3D_swap_frame_usage
12269
  CONST_CAST(WGLEW_I3D_swap_frame_usage) = _glewSearchExtension("WGL_I3D_swap_frame_usage", extStart, extEnd);
12270
  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);
12271
#endif /* WGL_I3D_swap_frame_usage */
12272
#ifdef WGL_NV_DX_interop
12273
  CONST_CAST(WGLEW_NV_DX_interop) = _glewSearchExtension("WGL_NV_DX_interop", extStart, extEnd);
12274
  if (glewExperimental || WGLEW_NV_DX_interop|| crippled) CONST_CAST(WGLEW_NV_DX_interop)= !_glewInit_WGL_NV_DX_interop(GLEW_CONTEXT_ARG_VAR_INIT);
12275
#endif /* WGL_NV_DX_interop */
12276
#ifdef WGL_NV_DX_interop2
12277
  CONST_CAST(WGLEW_NV_DX_interop2) = _glewSearchExtension("WGL_NV_DX_interop2", extStart, extEnd);
12278
#endif /* WGL_NV_DX_interop2 */
12279
#ifdef WGL_NV_copy_image
12280
  CONST_CAST(WGLEW_NV_copy_image) = _glewSearchExtension("WGL_NV_copy_image", extStart, extEnd);
12281
  if (glewExperimental || WGLEW_NV_copy_image|| crippled) CONST_CAST(WGLEW_NV_copy_image)= !_glewInit_WGL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
12282
#endif /* WGL_NV_copy_image */
12283
#ifdef WGL_NV_float_buffer
12284
  CONST_CAST(WGLEW_NV_float_buffer) = _glewSearchExtension("WGL_NV_float_buffer", extStart, extEnd);
12285
#endif /* WGL_NV_float_buffer */
12286
#ifdef WGL_NV_gpu_affinity
12287
  CONST_CAST(WGLEW_NV_gpu_affinity) = _glewSearchExtension("WGL_NV_gpu_affinity", extStart, extEnd);
12288
  if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT);
12289
#endif /* WGL_NV_gpu_affinity */
12290
#ifdef WGL_NV_multisample_coverage
12291
  CONST_CAST(WGLEW_NV_multisample_coverage) = _glewSearchExtension("WGL_NV_multisample_coverage", extStart, extEnd);
12292
#endif /* WGL_NV_multisample_coverage */
12293
#ifdef WGL_NV_present_video
12294
  CONST_CAST(WGLEW_NV_present_video) = _glewSearchExtension("WGL_NV_present_video", extStart, extEnd);
12295
  if (glewExperimental || WGLEW_NV_present_video|| crippled) CONST_CAST(WGLEW_NV_present_video)= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
12296
#endif /* WGL_NV_present_video */
12297
#ifdef WGL_NV_render_depth_texture
12298
  CONST_CAST(WGLEW_NV_render_depth_texture) = _glewSearchExtension("WGL_NV_render_depth_texture", extStart, extEnd);
12299
#endif /* WGL_NV_render_depth_texture */
12300
#ifdef WGL_NV_render_texture_rectangle
12301
  CONST_CAST(WGLEW_NV_render_texture_rectangle) = _glewSearchExtension("WGL_NV_render_texture_rectangle", extStart, extEnd);
12302
#endif /* WGL_NV_render_texture_rectangle */
12303
#ifdef WGL_NV_swap_group
12304
  CONST_CAST(WGLEW_NV_swap_group) = _glewSearchExtension("WGL_NV_swap_group", extStart, extEnd);
12305
  if (glewExperimental || WGLEW_NV_swap_group|| crippled) CONST_CAST(WGLEW_NV_swap_group)= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
12306
#endif /* WGL_NV_swap_group */
12307
#ifdef WGL_NV_vertex_array_range
12308
  CONST_CAST(WGLEW_NV_vertex_array_range) = _glewSearchExtension("WGL_NV_vertex_array_range", extStart, extEnd);
12309
  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);
12310
#endif /* WGL_NV_vertex_array_range */
12311
#ifdef WGL_NV_video_capture
12312
  CONST_CAST(WGLEW_NV_video_capture) = _glewSearchExtension("WGL_NV_video_capture", extStart, extEnd);
12313
  if (glewExperimental || WGLEW_NV_video_capture|| crippled) CONST_CAST(WGLEW_NV_video_capture)= !_glewInit_WGL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
12314
#endif /* WGL_NV_video_capture */
12315
#ifdef WGL_NV_video_output
12316
  CONST_CAST(WGLEW_NV_video_output) = _glewSearchExtension("WGL_NV_video_output", extStart, extEnd);
12317
  if (glewExperimental || WGLEW_NV_video_output|| crippled) CONST_CAST(WGLEW_NV_video_output)= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);
12318
#endif /* WGL_NV_video_output */
12319
#ifdef WGL_OML_sync_control
12320
  CONST_CAST(WGLEW_OML_sync_control) = _glewSearchExtension("WGL_OML_sync_control", extStart, extEnd);
12321
  if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);
12322
#endif /* WGL_OML_sync_control */
12323
 
12324
  return GLEW_OK;
12325
}
12326
 
677 janba 12327
#elif !defined(__ANDROID__) && !defined(__native_client__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))
667 khor 12328
 
12329
PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;
12330
 
12331
PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;
12332
PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;
12333
PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;
12334
PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;
12335
PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;
12336
PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;
12337
PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;
12338
PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;
12339
PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;
12340
PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;
12341
PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;
12342
PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;
12343
PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;
12344
PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;
12345
PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;
12346
PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;
12347
PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;
12348
 
677 janba 12349
PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC __glewXBlitContextFramebufferAMD = NULL;
12350
PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC __glewXCreateAssociatedContextAMD = NULL;
12351
PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __glewXCreateAssociatedContextAttribsAMD = NULL;
12352
PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC __glewXDeleteAssociatedContextAMD = NULL;
12353
PFNGLXGETCONTEXTGPUIDAMDPROC __glewXGetContextGPUIDAMD = NULL;
12354
PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC __glewXGetCurrentAssociatedContextAMD = NULL;
12355
PFNGLXGETGPUIDSAMDPROC __glewXGetGPUIDsAMD = NULL;
12356
PFNGLXGETGPUINFOAMDPROC __glewXGetGPUInfoAMD = NULL;
12357
PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __glewXMakeAssociatedContextCurrentAMD = NULL;
12358
 
667 khor 12359
PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL;
12360
 
12361
PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;
12362
PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;
12363
PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;
12364
 
12365
PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;
12366
PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;
12367
PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;
12368
PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;
12369
 
12370
PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL;
12371
 
12372
PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;
12373
PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;
12374
 
12375
PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;
12376
 
12377
PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;
12378
 
12379
PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;
12380
 
12381
PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;
12382
 
12383
PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;
12384
 
12385
PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA = NULL;
12386
PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA = NULL;
12387
 
12388
PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL;
12389
 
12390
PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL;
12391
PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL;
12392
 
12393
PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL;
12394
PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL;
12395
PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL;
12396
PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL;
12397
PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL;
12398
PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL;
12399
 
12400
PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;
12401
PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;
12402
 
12403
PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV = NULL;
12404
PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV = NULL;
12405
PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV = NULL;
12406
PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV = NULL;
12407
PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV = NULL;
12408
 
12409
PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL;
12410
PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL;
12411
PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL;
12412
PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL;
12413
PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL;
12414
PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL;
12415
 
12416
PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;
12417
PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;
12418
PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;
12419
PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;
12420
PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;
12421
 
12422
PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;
12423
PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;
12424
PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;
12425
PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;
12426
PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;
12427
PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;
12428
 
12429
PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL;
12430
PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL;
12431
PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL;
12432
PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL;
12433
PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL;
12434
PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL;
12435
PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL;
12436
PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL;
12437
 
12438
PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;
12439
PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;
12440
PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;
12441
PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;
12442
PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;
12443
 
12444
PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;
12445
PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;
12446
 
12447
PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;
12448
 
12449
PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;
12450
PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;
12451
PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;
12452
PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;
12453
PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;
12454
 
12455
PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;
12456
 
12457
PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;
12458
PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;
12459
 
12460
PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;
12461
 
12462
PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;
12463
PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;
12464
 
12465
PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;
12466
 
12467
PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;
12468
PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;
12469
 
12470
#if !defined(GLEW_MX)
12471
 
12472
GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;
12473
GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;
12474
GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;
12475
GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;
12476
GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;
12477
GLboolean __GLXEW_3DFX_multisample = GL_FALSE;
12478
GLboolean __GLXEW_AMD_gpu_association = GL_FALSE;
12479
GLboolean __GLXEW_ARB_create_context = GL_FALSE;
12480
GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE;
12481
GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE;
12482
GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;
12483
GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE;
12484
GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;
12485
GLboolean __GLXEW_ARB_multisample = GL_FALSE;
12486
GLboolean __GLXEW_ARB_robustness_application_isolation = GL_FALSE;
12487
GLboolean __GLXEW_ARB_robustness_share_group_isolation = GL_FALSE;
12488
GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE;
12489
GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;
12490
GLboolean __GLXEW_ATI_render_texture = GL_FALSE;
677 janba 12491
GLboolean __GLXEW_EXT_buffer_age = GL_FALSE;
667 khor 12492
GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE;
12493
GLboolean __GLXEW_EXT_create_context_es_profile = GL_FALSE;
12494
GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;
12495
GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;
12496
GLboolean __GLXEW_EXT_import_context = GL_FALSE;
12497
GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;
12498
GLboolean __GLXEW_EXT_swap_control = GL_FALSE;
12499
GLboolean __GLXEW_EXT_swap_control_tear = GL_FALSE;
12500
GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;
12501
GLboolean __GLXEW_EXT_visual_info = GL_FALSE;
12502
GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;
12503
GLboolean __GLXEW_INTEL_swap_event = GL_FALSE;
12504
GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;
12505
GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;
12506
GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;
12507
GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;
12508
GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;
12509
GLboolean __GLXEW_MESA_swap_control = GL_FALSE;
12510
GLboolean __GLXEW_NV_copy_image = GL_FALSE;
12511
GLboolean __GLXEW_NV_float_buffer = GL_FALSE;
12512
GLboolean __GLXEW_NV_multisample_coverage = GL_FALSE;
12513
GLboolean __GLXEW_NV_present_video = GL_FALSE;
12514
GLboolean __GLXEW_NV_swap_group = GL_FALSE;
12515
GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;
12516
GLboolean __GLXEW_NV_video_capture = GL_FALSE;
677 janba 12517
GLboolean __GLXEW_NV_video_output = GL_FALSE;
667 khor 12518
GLboolean __GLXEW_OML_swap_method = GL_FALSE;
12519
GLboolean __GLXEW_OML_sync_control = GL_FALSE;
12520
GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;
12521
GLboolean __GLXEW_SGIS_color_range = GL_FALSE;
12522
GLboolean __GLXEW_SGIS_multisample = GL_FALSE;
12523
GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;
12524
GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;
12525
GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE;
12526
GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;
12527
GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;
12528
GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;
12529
GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;
12530
GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;
12531
GLboolean __GLXEW_SGI_cushion = GL_FALSE;
12532
GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;
12533
GLboolean __GLXEW_SGI_swap_control = GL_FALSE;
12534
GLboolean __GLXEW_SGI_video_sync = GL_FALSE;
12535
GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;
12536
GLboolean __GLXEW_SUN_video_resize = GL_FALSE;
12537
 
12538
#endif /* !GLEW_MX */
12539
 
12540
#ifdef GLX_VERSION_1_2
12541
 
12542
static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT)
12543
{
12544
  GLboolean r = GL_FALSE;
12545
 
12546
  r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;
12547
 
12548
  return r;
12549
}
12550
 
12551
#endif /* GLX_VERSION_1_2 */
12552
 
12553
#ifdef GLX_VERSION_1_3
12554
 
12555
static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT)
12556
{
12557
  GLboolean r = GL_FALSE;
12558
 
12559
  r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;
12560
  r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;
12561
  r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;
12562
  r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;
12563
  r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;
12564
  r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;
12565
  r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;
12566
  r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;
12567
  r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;
12568
  r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;
12569
  r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;
12570
  r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;
12571
  r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;
12572
  r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;
12573
  r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;
12574
  r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;
12575
  r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;
12576
 
12577
  return r;
12578
}
12579
 
12580
#endif /* GLX_VERSION_1_3 */
12581
 
12582
#ifdef GLX_VERSION_1_4
12583
 
12584
#endif /* GLX_VERSION_1_4 */
12585
 
12586
#ifdef GLX_3DFX_multisample
12587
 
12588
#endif /* GLX_3DFX_multisample */
12589
 
12590
#ifdef GLX_AMD_gpu_association
12591
 
677 janba 12592
static GLboolean _glewInit_GLX_AMD_gpu_association (GLXEW_CONTEXT_ARG_DEF_INIT)
12593
{
12594
  GLboolean r = GL_FALSE;
12595
 
12596
  r = ((glXBlitContextFramebufferAMD = (PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"glXBlitContextFramebufferAMD")) == NULL) || r;
12597
  r = ((glXCreateAssociatedContextAMD = (PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXCreateAssociatedContextAMD")) == NULL) || r;
12598
  r = ((glXCreateAssociatedContextAttribsAMD = (PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"glXCreateAssociatedContextAttribsAMD")) == NULL) || r;
12599
  r = ((glXDeleteAssociatedContextAMD = (PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXDeleteAssociatedContextAMD")) == NULL) || r;
12600
  r = ((glXGetContextGPUIDAMD = (PFNGLXGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetContextGPUIDAMD")) == NULL) || r;
12601
  r = ((glXGetCurrentAssociatedContextAMD = (PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentAssociatedContextAMD")) == NULL) || r;
12602
  r = ((glXGetGPUIDsAMD = (PFNGLXGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetGPUIDsAMD")) == NULL) || r;
12603
  r = ((glXGetGPUInfoAMD = (PFNGLXGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetGPUInfoAMD")) == NULL) || r;
12604
  r = ((glXMakeAssociatedContextCurrentAMD = (PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"glXMakeAssociatedContextCurrentAMD")) == NULL) || r;
12605
 
12606
  return r;
12607
}
12608
 
667 khor 12609
#endif /* GLX_AMD_gpu_association */
12610
 
12611
#ifdef GLX_ARB_create_context
12612
 
12613
static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT)
12614
{
12615
  GLboolean r = GL_FALSE;
12616
 
12617
  r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r;
12618
 
12619
  return r;
12620
}
12621
 
12622
#endif /* GLX_ARB_create_context */
12623
 
12624
#ifdef GLX_ARB_create_context_profile
12625
 
12626
#endif /* GLX_ARB_create_context_profile */
12627
 
12628
#ifdef GLX_ARB_create_context_robustness
12629
 
12630
#endif /* GLX_ARB_create_context_robustness */
12631
 
12632
#ifdef GLX_ARB_fbconfig_float
12633
 
12634
#endif /* GLX_ARB_fbconfig_float */
12635
 
12636
#ifdef GLX_ARB_framebuffer_sRGB
12637
 
12638
#endif /* GLX_ARB_framebuffer_sRGB */
12639
 
12640
#ifdef GLX_ARB_get_proc_address
12641
 
12642
#endif /* GLX_ARB_get_proc_address */
12643
 
12644
#ifdef GLX_ARB_multisample
12645
 
12646
#endif /* GLX_ARB_multisample */
12647
 
12648
#ifdef GLX_ARB_robustness_application_isolation
12649
 
12650
#endif /* GLX_ARB_robustness_application_isolation */
12651
 
12652
#ifdef GLX_ARB_robustness_share_group_isolation
12653
 
12654
#endif /* GLX_ARB_robustness_share_group_isolation */
12655
 
12656
#ifdef GLX_ARB_vertex_buffer_object
12657
 
12658
#endif /* GLX_ARB_vertex_buffer_object */
12659
 
12660
#ifdef GLX_ATI_pixel_format_float
12661
 
12662
#endif /* GLX_ATI_pixel_format_float */
12663
 
12664
#ifdef GLX_ATI_render_texture
12665
 
12666
static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT)
12667
{
12668
  GLboolean r = GL_FALSE;
12669
 
12670
  r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;
12671
  r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;
12672
  r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;
12673
 
12674
  return r;
12675
}
12676
 
12677
#endif /* GLX_ATI_render_texture */
12678
 
677 janba 12679
#ifdef GLX_EXT_buffer_age
12680
 
12681
#endif /* GLX_EXT_buffer_age */
12682
 
667 khor 12683
#ifdef GLX_EXT_create_context_es2_profile
12684
 
12685
#endif /* GLX_EXT_create_context_es2_profile */
12686
 
12687
#ifdef GLX_EXT_create_context_es_profile
12688
 
12689
#endif /* GLX_EXT_create_context_es_profile */
12690
 
12691
#ifdef GLX_EXT_fbconfig_packed_float
12692
 
12693
#endif /* GLX_EXT_fbconfig_packed_float */
12694
 
12695
#ifdef GLX_EXT_framebuffer_sRGB
12696
 
12697
#endif /* GLX_EXT_framebuffer_sRGB */
12698
 
12699
#ifdef GLX_EXT_import_context
12700
 
12701
static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)
12702
{
12703
  GLboolean r = GL_FALSE;
12704
 
12705
  r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;
12706
  r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;
12707
  r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;
12708
  r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;
12709
 
12710
  return r;
12711
}
12712
 
12713
#endif /* GLX_EXT_import_context */
12714
 
12715
#ifdef GLX_EXT_scene_marker
12716
 
12717
#endif /* GLX_EXT_scene_marker */
12718
 
12719
#ifdef GLX_EXT_swap_control
12720
 
12721
static GLboolean _glewInit_GLX_EXT_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
12722
{
12723
  GLboolean r = GL_FALSE;
12724
 
12725
  r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r;
12726
 
12727
  return r;
12728
}
12729
 
12730
#endif /* GLX_EXT_swap_control */
12731
 
12732
#ifdef GLX_EXT_swap_control_tear
12733
 
12734
#endif /* GLX_EXT_swap_control_tear */
12735
 
12736
#ifdef GLX_EXT_texture_from_pixmap
12737
 
12738
static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT)
12739
{
12740
  GLboolean r = GL_FALSE;
12741
 
12742
  r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r;
12743
  r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r;
12744
 
12745
  return r;
12746
}
12747
 
12748
#endif /* GLX_EXT_texture_from_pixmap */
12749
 
12750
#ifdef GLX_EXT_visual_info
12751
 
12752
#endif /* GLX_EXT_visual_info */
12753
 
12754
#ifdef GLX_EXT_visual_rating
12755
 
12756
#endif /* GLX_EXT_visual_rating */
12757
 
12758
#ifdef GLX_INTEL_swap_event
12759
 
12760
#endif /* GLX_INTEL_swap_event */
12761
 
12762
#ifdef GLX_MESA_agp_offset
12763
 
12764
static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)
12765
{
12766
  GLboolean r = GL_FALSE;
12767
 
12768
  r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;
12769
 
12770
  return r;
12771
}
12772
 
12773
#endif /* GLX_MESA_agp_offset */
12774
 
12775
#ifdef GLX_MESA_copy_sub_buffer
12776
 
12777
static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT)
12778
{
12779
  GLboolean r = GL_FALSE;
12780
 
12781
  r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;
12782
 
12783
  return r;
12784
}
12785
 
12786
#endif /* GLX_MESA_copy_sub_buffer */
12787
 
12788
#ifdef GLX_MESA_pixmap_colormap
12789
 
12790
static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT)
12791
{
12792
  GLboolean r = GL_FALSE;
12793
 
12794
  r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;
12795
 
12796
  return r;
12797
}
12798
 
12799
#endif /* GLX_MESA_pixmap_colormap */
12800
 
12801
#ifdef GLX_MESA_release_buffers
12802
 
12803
static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT)
12804
{
12805
  GLboolean r = GL_FALSE;
12806
 
12807
  r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;
12808
 
12809
  return r;
12810
}
12811
 
12812
#endif /* GLX_MESA_release_buffers */
12813
 
12814
#ifdef GLX_MESA_set_3dfx_mode
12815
 
12816
static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)
12817
{
12818
  GLboolean r = GL_FALSE;
12819
 
12820
  r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;
12821
 
12822
  return r;
12823
}
12824
 
12825
#endif /* GLX_MESA_set_3dfx_mode */
12826
 
12827
#ifdef GLX_MESA_swap_control
12828
 
12829
static GLboolean _glewInit_GLX_MESA_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
12830
{
12831
  GLboolean r = GL_FALSE;
12832
 
12833
  r = ((glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetSwapIntervalMESA")) == NULL) || r;
12834
  r = ((glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalMESA")) == NULL) || r;
12835
 
12836
  return r;
12837
}
12838
 
12839
#endif /* GLX_MESA_swap_control */
12840
 
12841
#ifdef GLX_NV_copy_image
12842
 
12843
static GLboolean _glewInit_GLX_NV_copy_image (GLXEW_CONTEXT_ARG_DEF_INIT)
12844
{
12845
  GLboolean r = GL_FALSE;
12846
 
12847
  r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r;
12848
 
12849
  return r;
12850
}
12851
 
12852
#endif /* GLX_NV_copy_image */
12853
 
12854
#ifdef GLX_NV_float_buffer
12855
 
12856
#endif /* GLX_NV_float_buffer */
12857
 
12858
#ifdef GLX_NV_multisample_coverage
12859
 
12860
#endif /* GLX_NV_multisample_coverage */
12861
 
12862
#ifdef GLX_NV_present_video
12863
 
12864
static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT)
12865
{
12866
  GLboolean r = GL_FALSE;
12867
 
12868
  r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;
12869
  r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r;
12870
 
12871
  return r;
12872
}
12873
 
12874
#endif /* GLX_NV_present_video */
12875
 
12876
#ifdef GLX_NV_swap_group
12877
 
12878
static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)
12879
{
12880
  GLboolean r = GL_FALSE;
12881
 
12882
  r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r;
12883
  r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r;
12884
  r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r;
12885
  r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r;
12886
  r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r;
12887
  r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r;
12888
 
12889
  return r;
12890
}
12891
 
12892
#endif /* GLX_NV_swap_group */
12893
 
12894
#ifdef GLX_NV_vertex_array_range
12895
 
12896
static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT)
12897
{
12898
  GLboolean r = GL_FALSE;
12899
 
12900
  r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;
12901
  r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;
12902
 
12903
  return r;
12904
}
12905
 
12906
#endif /* GLX_NV_vertex_array_range */
12907
 
12908
#ifdef GLX_NV_video_capture
12909
 
12910
static GLboolean _glewInit_GLX_NV_video_capture (GLXEW_CONTEXT_ARG_DEF_INIT)
12911
{
12912
  GLboolean r = GL_FALSE;
12913
 
12914
  r = ((glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoCaptureDeviceNV")) == NULL) || r;
12915
  r = ((glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoCaptureDevicesNV")) == NULL) || r;
12916
  r = ((glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXLockVideoCaptureDeviceNV")) == NULL) || r;
12917
  r = ((glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXQueryVideoCaptureDeviceNV")) == NULL) || r;
12918
  r = ((glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoCaptureDeviceNV")) == NULL) || r;
12919
 
12920
  return r;
12921
}
12922
 
12923
#endif /* GLX_NV_video_capture */
12924
 
677 janba 12925
#ifdef GLX_NV_video_output
667 khor 12926
 
677 janba 12927
static GLboolean _glewInit_GLX_NV_video_output (GLXEW_CONTEXT_ARG_DEF_INIT)
667 khor 12928
{
12929
  GLboolean r = GL_FALSE;
12930
 
12931
  r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r;
12932
  r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r;
12933
  r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r;
12934
  r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r;
12935
  r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r;
12936
  r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r;
12937
 
12938
  return r;
12939
}
12940
 
677 janba 12941
#endif /* GLX_NV_video_output */
667 khor 12942
 
12943
#ifdef GLX_OML_swap_method
12944
 
12945
#endif /* GLX_OML_swap_method */
12946
 
12947
#ifdef GLX_OML_sync_control
12948
 
12949
static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT)
12950
{
12951
  GLboolean r = GL_FALSE;
12952
 
12953
  r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;
12954
  r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;
12955
  r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;
12956
  r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;
12957
  r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;
12958
 
12959
  return r;
12960
}
12961
 
12962
#endif /* GLX_OML_sync_control */
12963
 
12964
#ifdef GLX_SGIS_blended_overlay
12965
 
12966
#endif /* GLX_SGIS_blended_overlay */
12967
 
12968
#ifdef GLX_SGIS_color_range
12969
 
12970
#endif /* GLX_SGIS_color_range */
12971
 
12972
#ifdef GLX_SGIS_multisample
12973
 
12974
#endif /* GLX_SGIS_multisample */
12975
 
12976
#ifdef GLX_SGIS_shared_multisample
12977
 
12978
#endif /* GLX_SGIS_shared_multisample */
12979
 
12980
#ifdef GLX_SGIX_fbconfig
12981
 
12982
static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT)
12983
{
12984
  GLboolean r = GL_FALSE;
12985
 
12986
  r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;
12987
  r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;
12988
  r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;
12989
  r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;
12990
  r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;
12991
  r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;
12992
 
12993
  return r;
12994
}
12995
 
12996
#endif /* GLX_SGIX_fbconfig */
12997
 
12998
#ifdef GLX_SGIX_hyperpipe
12999
 
13000
static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT)
13001
{
13002
  GLboolean r = GL_FALSE;
13003
 
13004
  r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r;
13005
  r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r;
13006
  r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r;
13007
  r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r;
13008
  r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r;
13009
  r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r;
13010
  r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r;
13011
  r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r;
13012
 
13013
  return r;
13014
}
13015
 
13016
#endif /* GLX_SGIX_hyperpipe */
13017
 
13018
#ifdef GLX_SGIX_pbuffer
13019
 
13020
static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT)
13021
{
13022
  GLboolean r = GL_FALSE;
13023
 
13024
  r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;
13025
  r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;
13026
  r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;
13027
  r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;
13028
  r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;
13029
 
13030
  return r;
13031
}
13032
 
13033
#endif /* GLX_SGIX_pbuffer */
13034
 
13035
#ifdef GLX_SGIX_swap_barrier
13036
 
13037
static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT)
13038
{
13039
  GLboolean r = GL_FALSE;
13040
 
13041
  r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;
13042
  r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;
13043
 
13044
  return r;
13045
}
13046
 
13047
#endif /* GLX_SGIX_swap_barrier */
13048
 
13049
#ifdef GLX_SGIX_swap_group
13050
 
13051
static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)
13052
{
13053
  GLboolean r = GL_FALSE;
13054
 
13055
  r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;
13056
 
13057
  return r;
13058
}
13059
 
13060
#endif /* GLX_SGIX_swap_group */
13061
 
13062
#ifdef GLX_SGIX_video_resize
13063
 
13064
static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)
13065
{
13066
  GLboolean r = GL_FALSE;
13067
 
13068
  r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;
13069
  r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;
13070
  r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;
13071
  r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;
13072
  r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;
13073
 
13074
  return r;
13075
}
13076
 
13077
#endif /* GLX_SGIX_video_resize */
13078
 
13079
#ifdef GLX_SGIX_visual_select_group
13080
 
13081
#endif /* GLX_SGIX_visual_select_group */
13082
 
13083
#ifdef GLX_SGI_cushion
13084
 
13085
static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT)
13086
{
13087
  GLboolean r = GL_FALSE;
13088
 
13089
  r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;
13090
 
13091
  return r;
13092
}
13093
 
13094
#endif /* GLX_SGI_cushion */
13095
 
13096
#ifdef GLX_SGI_make_current_read
13097
 
13098
static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT)
13099
{
13100
  GLboolean r = GL_FALSE;
13101
 
13102
  r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;
13103
  r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;
13104
 
13105
  return r;
13106
}
13107
 
13108
#endif /* GLX_SGI_make_current_read */
13109
 
13110
#ifdef GLX_SGI_swap_control
13111
 
13112
static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
13113
{
13114
  GLboolean r = GL_FALSE;
13115
 
13116
  r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;
13117
 
13118
  return r;
13119
}
13120
 
13121
#endif /* GLX_SGI_swap_control */
13122
 
13123
#ifdef GLX_SGI_video_sync
13124
 
13125
static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT)
13126
{
13127
  GLboolean r = GL_FALSE;
13128
 
13129
  r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;
13130
  r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;
13131
 
13132
  return r;
13133
}
13134
 
13135
#endif /* GLX_SGI_video_sync */
13136
 
13137
#ifdef GLX_SUN_get_transparent_index
13138
 
13139
static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT)
13140
{
13141
  GLboolean r = GL_FALSE;
13142
 
13143
  r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;
13144
 
13145
  return r;
13146
}
13147
 
13148
#endif /* GLX_SUN_get_transparent_index */
13149
 
13150
#ifdef GLX_SUN_video_resize
13151
 
13152
static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)
13153
{
13154
  GLboolean r = GL_FALSE;
13155
 
13156
  r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;
13157
  r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;
13158
 
13159
  return r;
13160
}
13161
 
13162
#endif /* GLX_SUN_video_resize */
13163
 
13164
/* ------------------------------------------------------------------------ */
13165
 
13166
GLboolean glxewGetExtension (const char* name)
13167
{    
13168
  const GLubyte* start;
13169
  const GLubyte* end;
13170
 
13171
  if (glXGetCurrentDisplay == NULL) return GL_FALSE;
13172
  start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
13173
  if (0 == start) return GL_FALSE;
13174
  end = start + _glewStrLen(start);
13175
  return _glewSearchExtension(name, start, end);
13176
}
13177
 
13178
GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
13179
{
13180
  int major, minor;
13181
  const GLubyte* extStart;
13182
  const GLubyte* extEnd;
13183
  /* initialize core GLX 1.2 */
13184
  if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY;
13185
  /* initialize flags */
13186
  CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE;
13187
  CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE;
13188
  CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE;
13189
  CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE;
13190
  CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE;
13191
  /* query GLX version */
13192
  glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
13193
  if (major == 1 && minor <= 3)
13194
  {
13195
    switch (minor)
13196
    {
13197
      case 3:
13198
      CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;
13199
      break;
13200
      case 2:
13201
      CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;
13202
      CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE;
13203
      break;
13204
      default:
13205
      return GLEW_ERROR_GLX_VERSION_11_ONLY;
13206
      break;
13207
    }
13208
  }
13209
  /* query GLX extension string */
13210
  extStart = 0;
13211
  if (glXGetCurrentDisplay != NULL)
13212
    extStart = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
13213
  if (extStart == 0)
13214
    extStart = (const GLubyte *)"";
13215
  extEnd = extStart + _glewStrLen(extStart);
13216
  /* initialize extensions */
13217
#ifdef GLX_VERSION_1_3
13218
  if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
13219
#endif /* GLX_VERSION_1_3 */
13220
#ifdef GLX_3DFX_multisample
13221
  CONST_CAST(GLXEW_3DFX_multisample) = _glewSearchExtension("GLX_3DFX_multisample", extStart, extEnd);
13222
#endif /* GLX_3DFX_multisample */
13223
#ifdef GLX_AMD_gpu_association
13224
  CONST_CAST(GLXEW_AMD_gpu_association) = _glewSearchExtension("GLX_AMD_gpu_association", extStart, extEnd);
677 janba 13225
  if (glewExperimental || GLXEW_AMD_gpu_association) CONST_CAST(GLXEW_AMD_gpu_association) = !_glewInit_GLX_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT);
667 khor 13226
#endif /* GLX_AMD_gpu_association */
13227
#ifdef GLX_ARB_create_context
13228
  CONST_CAST(GLXEW_ARB_create_context) = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd);
13229
  if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
13230
#endif /* GLX_ARB_create_context */
13231
#ifdef GLX_ARB_create_context_profile
13232
  CONST_CAST(GLXEW_ARB_create_context_profile) = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd);
13233
#endif /* GLX_ARB_create_context_profile */
13234
#ifdef GLX_ARB_create_context_robustness
13235
  CONST_CAST(GLXEW_ARB_create_context_robustness) = _glewSearchExtension("GLX_ARB_create_context_robustness", extStart, extEnd);
13236
#endif /* GLX_ARB_create_context_robustness */
13237
#ifdef GLX_ARB_fbconfig_float
13238
  CONST_CAST(GLXEW_ARB_fbconfig_float) = _glewSearchExtension("GLX_ARB_fbconfig_float", extStart, extEnd);
13239
#endif /* GLX_ARB_fbconfig_float */
13240
#ifdef GLX_ARB_framebuffer_sRGB
13241
  CONST_CAST(GLXEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GLX_ARB_framebuffer_sRGB", extStart, extEnd);
13242
#endif /* GLX_ARB_framebuffer_sRGB */
13243
#ifdef GLX_ARB_get_proc_address
13244
  CONST_CAST(GLXEW_ARB_get_proc_address) = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd);
13245
#endif /* GLX_ARB_get_proc_address */
13246
#ifdef GLX_ARB_multisample
13247
  CONST_CAST(GLXEW_ARB_multisample) = _glewSearchExtension("GLX_ARB_multisample", extStart, extEnd);
13248
#endif /* GLX_ARB_multisample */
13249
#ifdef GLX_ARB_robustness_application_isolation
13250
  CONST_CAST(GLXEW_ARB_robustness_application_isolation) = _glewSearchExtension("GLX_ARB_robustness_application_isolation", extStart, extEnd);
13251
#endif /* GLX_ARB_robustness_application_isolation */
13252
#ifdef GLX_ARB_robustness_share_group_isolation
13253
  CONST_CAST(GLXEW_ARB_robustness_share_group_isolation) = _glewSearchExtension("GLX_ARB_robustness_share_group_isolation", extStart, extEnd);
13254
#endif /* GLX_ARB_robustness_share_group_isolation */
13255
#ifdef GLX_ARB_vertex_buffer_object
13256
  CONST_CAST(GLXEW_ARB_vertex_buffer_object) = _glewSearchExtension("GLX_ARB_vertex_buffer_object", extStart, extEnd);
13257
#endif /* GLX_ARB_vertex_buffer_object */
13258
#ifdef GLX_ATI_pixel_format_float
13259
  CONST_CAST(GLXEW_ATI_pixel_format_float) = _glewSearchExtension("GLX_ATI_pixel_format_float", extStart, extEnd);
13260
#endif /* GLX_ATI_pixel_format_float */
13261
#ifdef GLX_ATI_render_texture
13262
  CONST_CAST(GLXEW_ATI_render_texture) = _glewSearchExtension("GLX_ATI_render_texture", extStart, extEnd);
13263
  if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
13264
#endif /* GLX_ATI_render_texture */
677 janba 13265
#ifdef GLX_EXT_buffer_age
13266
  CONST_CAST(GLXEW_EXT_buffer_age) = _glewSearchExtension("GLX_EXT_buffer_age", extStart, extEnd);
13267
#endif /* GLX_EXT_buffer_age */
667 khor 13268
#ifdef GLX_EXT_create_context_es2_profile
13269
  CONST_CAST(GLXEW_EXT_create_context_es2_profile) = _glewSearchExtension("GLX_EXT_create_context_es2_profile", extStart, extEnd);
13270
#endif /* GLX_EXT_create_context_es2_profile */
13271
#ifdef GLX_EXT_create_context_es_profile
13272
  CONST_CAST(GLXEW_EXT_create_context_es_profile) = _glewSearchExtension("GLX_EXT_create_context_es_profile", extStart, extEnd);
13273
#endif /* GLX_EXT_create_context_es_profile */
13274
#ifdef GLX_EXT_fbconfig_packed_float
13275
  CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = _glewSearchExtension("GLX_EXT_fbconfig_packed_float", extStart, extEnd);
13276
#endif /* GLX_EXT_fbconfig_packed_float */
13277
#ifdef GLX_EXT_framebuffer_sRGB
13278
  CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd);
13279
#endif /* GLX_EXT_framebuffer_sRGB */
13280
#ifdef GLX_EXT_import_context
13281
  CONST_CAST(GLXEW_EXT_import_context) = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd);
13282
  if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT);
13283
#endif /* GLX_EXT_import_context */
13284
#ifdef GLX_EXT_scene_marker
13285
  CONST_CAST(GLXEW_EXT_scene_marker) = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd);
13286
#endif /* GLX_EXT_scene_marker */
13287
#ifdef GLX_EXT_swap_control
13288
  CONST_CAST(GLXEW_EXT_swap_control) = _glewSearchExtension("GLX_EXT_swap_control", extStart, extEnd);
13289
  if (glewExperimental || GLXEW_EXT_swap_control) CONST_CAST(GLXEW_EXT_swap_control) = !_glewInit_GLX_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
13290
#endif /* GLX_EXT_swap_control */
13291
#ifdef GLX_EXT_swap_control_tear
13292
  CONST_CAST(GLXEW_EXT_swap_control_tear) = _glewSearchExtension("GLX_EXT_swap_control_tear", extStart, extEnd);
13293
#endif /* GLX_EXT_swap_control_tear */
13294
#ifdef GLX_EXT_texture_from_pixmap
13295
  CONST_CAST(GLXEW_EXT_texture_from_pixmap) = _glewSearchExtension("GLX_EXT_texture_from_pixmap", extStart, extEnd);
13296
  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);
13297
#endif /* GLX_EXT_texture_from_pixmap */
13298
#ifdef GLX_EXT_visual_info
13299
  CONST_CAST(GLXEW_EXT_visual_info) = _glewSearchExtension("GLX_EXT_visual_info", extStart, extEnd);
13300
#endif /* GLX_EXT_visual_info */
13301
#ifdef GLX_EXT_visual_rating
13302
  CONST_CAST(GLXEW_EXT_visual_rating) = _glewSearchExtension("GLX_EXT_visual_rating", extStart, extEnd);
13303
#endif /* GLX_EXT_visual_rating */
13304
#ifdef GLX_INTEL_swap_event
13305
  CONST_CAST(GLXEW_INTEL_swap_event) = _glewSearchExtension("GLX_INTEL_swap_event", extStart, extEnd);
13306
#endif /* GLX_INTEL_swap_event */
13307
#ifdef GLX_MESA_agp_offset
13308
  CONST_CAST(GLXEW_MESA_agp_offset) = _glewSearchExtension("GLX_MESA_agp_offset", extStart, extEnd);
13309
  if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);
13310
#endif /* GLX_MESA_agp_offset */
13311
#ifdef GLX_MESA_copy_sub_buffer
13312
  CONST_CAST(GLXEW_MESA_copy_sub_buffer) = _glewSearchExtension("GLX_MESA_copy_sub_buffer", extStart, extEnd);
13313
  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);
13314
#endif /* GLX_MESA_copy_sub_buffer */
13315
#ifdef GLX_MESA_pixmap_colormap
13316
  CONST_CAST(GLXEW_MESA_pixmap_colormap) = _glewSearchExtension("GLX_MESA_pixmap_colormap", extStart, extEnd);
13317
  if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT);
13318
#endif /* GLX_MESA_pixmap_colormap */
13319
#ifdef GLX_MESA_release_buffers
13320
  CONST_CAST(GLXEW_MESA_release_buffers) = _glewSearchExtension("GLX_MESA_release_buffers", extStart, extEnd);
13321
  if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
13322
#endif /* GLX_MESA_release_buffers */
13323
#ifdef GLX_MESA_set_3dfx_mode
13324
  CONST_CAST(GLXEW_MESA_set_3dfx_mode) = _glewSearchExtension("GLX_MESA_set_3dfx_mode", extStart, extEnd);
13325
  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);
13326
#endif /* GLX_MESA_set_3dfx_mode */
13327
#ifdef GLX_MESA_swap_control
13328
  CONST_CAST(GLXEW_MESA_swap_control) = _glewSearchExtension("GLX_MESA_swap_control", extStart, extEnd);
13329
  if (glewExperimental || GLXEW_MESA_swap_control) CONST_CAST(GLXEW_MESA_swap_control) = !_glewInit_GLX_MESA_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
13330
#endif /* GLX_MESA_swap_control */
13331
#ifdef GLX_NV_copy_image
13332
  CONST_CAST(GLXEW_NV_copy_image) = _glewSearchExtension("GLX_NV_copy_image", extStart, extEnd);
13333
  if (glewExperimental || GLXEW_NV_copy_image) CONST_CAST(GLXEW_NV_copy_image) = !_glewInit_GLX_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
13334
#endif /* GLX_NV_copy_image */
13335
#ifdef GLX_NV_float_buffer
13336
  CONST_CAST(GLXEW_NV_float_buffer) = _glewSearchExtension("GLX_NV_float_buffer", extStart, extEnd);
13337
#endif /* GLX_NV_float_buffer */
13338
#ifdef GLX_NV_multisample_coverage
13339
  CONST_CAST(GLXEW_NV_multisample_coverage) = _glewSearchExtension("GLX_NV_multisample_coverage", extStart, extEnd);
13340
#endif /* GLX_NV_multisample_coverage */
13341
#ifdef GLX_NV_present_video
13342
  CONST_CAST(GLXEW_NV_present_video) = _glewSearchExtension("GLX_NV_present_video", extStart, extEnd);
13343
  if (glewExperimental || GLXEW_NV_present_video) CONST_CAST(GLXEW_NV_present_video) = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
13344
#endif /* GLX_NV_present_video */
13345
#ifdef GLX_NV_swap_group
13346
  CONST_CAST(GLXEW_NV_swap_group) = _glewSearchExtension("GLX_NV_swap_group", extStart, extEnd);
13347
  if (glewExperimental || GLXEW_NV_swap_group) CONST_CAST(GLXEW_NV_swap_group) = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
13348
#endif /* GLX_NV_swap_group */
13349
#ifdef GLX_NV_vertex_array_range
13350
  CONST_CAST(GLXEW_NV_vertex_array_range) = _glewSearchExtension("GLX_NV_vertex_array_range", extStart, extEnd);
13351
  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);
13352
#endif /* GLX_NV_vertex_array_range */
13353
#ifdef GLX_NV_video_capture
13354
  CONST_CAST(GLXEW_NV_video_capture) = _glewSearchExtension("GLX_NV_video_capture", extStart, extEnd);
13355
  if (glewExperimental || GLXEW_NV_video_capture) CONST_CAST(GLXEW_NV_video_capture) = !_glewInit_GLX_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
13356
#endif /* GLX_NV_video_capture */
677 janba 13357
#ifdef GLX_NV_video_output
13358
  CONST_CAST(GLXEW_NV_video_output) = _glewSearchExtension("GLX_NV_video_output", extStart, extEnd);
13359
  if (glewExperimental || GLXEW_NV_video_output) CONST_CAST(GLXEW_NV_video_output) = !_glewInit_GLX_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);
13360
#endif /* GLX_NV_video_output */
667 khor 13361
#ifdef GLX_OML_swap_method
13362
  CONST_CAST(GLXEW_OML_swap_method) = _glewSearchExtension("GLX_OML_swap_method", extStart, extEnd);
13363
#endif /* GLX_OML_swap_method */
13364
#ifdef GLX_OML_sync_control
13365
  CONST_CAST(GLXEW_OML_sync_control) = _glewSearchExtension("GLX_OML_sync_control", extStart, extEnd);
13366
  if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);
13367
#endif /* GLX_OML_sync_control */
13368
#ifdef GLX_SGIS_blended_overlay
13369
  CONST_CAST(GLXEW_SGIS_blended_overlay) = _glewSearchExtension("GLX_SGIS_blended_overlay", extStart, extEnd);
13370
#endif /* GLX_SGIS_blended_overlay */
13371
#ifdef GLX_SGIS_color_range
13372
  CONST_CAST(GLXEW_SGIS_color_range) = _glewSearchExtension("GLX_SGIS_color_range", extStart, extEnd);
13373
#endif /* GLX_SGIS_color_range */
13374
#ifdef GLX_SGIS_multisample
13375
  CONST_CAST(GLXEW_SGIS_multisample) = _glewSearchExtension("GLX_SGIS_multisample", extStart, extEnd);
13376
#endif /* GLX_SGIS_multisample */
13377
#ifdef GLX_SGIS_shared_multisample
13378
  CONST_CAST(GLXEW_SGIS_shared_multisample) = _glewSearchExtension("GLX_SGIS_shared_multisample", extStart, extEnd);
13379
#endif /* GLX_SGIS_shared_multisample */
13380
#ifdef GLX_SGIX_fbconfig
13381
  CONST_CAST(GLXEW_SGIX_fbconfig) = _glewSearchExtension("GLX_SGIX_fbconfig", extStart, extEnd);
13382
  if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT);
13383
#endif /* GLX_SGIX_fbconfig */
13384
#ifdef GLX_SGIX_hyperpipe
13385
  CONST_CAST(GLXEW_SGIX_hyperpipe) = _glewSearchExtension("GLX_SGIX_hyperpipe", extStart, extEnd);
13386
  if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT);
13387
#endif /* GLX_SGIX_hyperpipe */
13388
#ifdef GLX_SGIX_pbuffer
13389
  CONST_CAST(GLXEW_SGIX_pbuffer) = _glewSearchExtension("GLX_SGIX_pbuffer", extStart, extEnd);
13390
  if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
13391
#endif /* GLX_SGIX_pbuffer */
13392
#ifdef GLX_SGIX_swap_barrier
13393
  CONST_CAST(GLXEW_SGIX_swap_barrier) = _glewSearchExtension("GLX_SGIX_swap_barrier", extStart, extEnd);
13394
  if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
13395
#endif /* GLX_SGIX_swap_barrier */
13396
#ifdef GLX_SGIX_swap_group
13397
  CONST_CAST(GLXEW_SGIX_swap_group) = _glewSearchExtension("GLX_SGIX_swap_group", extStart, extEnd);
13398
  if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
13399
#endif /* GLX_SGIX_swap_group */
13400
#ifdef GLX_SGIX_video_resize
13401
  CONST_CAST(GLXEW_SGIX_video_resize) = _glewSearchExtension("GLX_SGIX_video_resize", extStart, extEnd);
13402
  if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);
13403
#endif /* GLX_SGIX_video_resize */
13404
#ifdef GLX_SGIX_visual_select_group
13405
  CONST_CAST(GLXEW_SGIX_visual_select_group) = _glewSearchExtension("GLX_SGIX_visual_select_group", extStart, extEnd);
13406
#endif /* GLX_SGIX_visual_select_group */
13407
#ifdef GLX_SGI_cushion
13408
  CONST_CAST(GLXEW_SGI_cushion) = _glewSearchExtension("GLX_SGI_cushion", extStart, extEnd);
13409
  if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT);
13410
#endif /* GLX_SGI_cushion */
13411
#ifdef GLX_SGI_make_current_read
13412
  CONST_CAST(GLXEW_SGI_make_current_read) = _glewSearchExtension("GLX_SGI_make_current_read", extStart, extEnd);
13413
  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);
13414
#endif /* GLX_SGI_make_current_read */
13415
#ifdef GLX_SGI_swap_control
13416
  CONST_CAST(GLXEW_SGI_swap_control) = _glewSearchExtension("GLX_SGI_swap_control", extStart, extEnd);
13417
  if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
13418
#endif /* GLX_SGI_swap_control */
13419
#ifdef GLX_SGI_video_sync
13420
  CONST_CAST(GLXEW_SGI_video_sync) = _glewSearchExtension("GLX_SGI_video_sync", extStart, extEnd);
13421
  if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT);
13422
#endif /* GLX_SGI_video_sync */
13423
#ifdef GLX_SUN_get_transparent_index
13424
  CONST_CAST(GLXEW_SUN_get_transparent_index) = _glewSearchExtension("GLX_SUN_get_transparent_index", extStart, extEnd);
13425
  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);
13426
#endif /* GLX_SUN_get_transparent_index */
13427
#ifdef GLX_SUN_video_resize
13428
  CONST_CAST(GLXEW_SUN_video_resize) = _glewSearchExtension("GLX_SUN_video_resize", extStart, extEnd);
13429
  if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);
13430
#endif /* GLX_SUN_video_resize */
13431
 
13432
  return GLEW_OK;
13433
}
13434
 
677 janba 13435
#endif /* !defined(__ANDROID__) && !defined(__native_client__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) */
667 khor 13436
 
13437
/* ------------------------------------------------------------------------ */
13438
 
13439
const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error)
13440
{
13441
  static const GLubyte* _glewErrorString[] =
13442
  {
13443
    (const GLubyte*)"No error",
13444
    (const GLubyte*)"Missing GL version",
13445
    (const GLubyte*)"GL 1.1 and up are not supported",
13446
    (const GLubyte*)"GLX 1.2 and up are not supported",
13447
    (const GLubyte*)"Unknown error"
13448
  };
13449
  const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;
13450
  return _glewErrorString[(int)error > max_error ? max_error : (int)error];
13451
}
13452
 
13453
const GLubyte * GLEWAPIENTRY glewGetString (GLenum name)
13454
{
13455
  static const GLubyte* _glewString[] =
13456
  {
13457
    (const GLubyte*)NULL,
677 janba 13458
    (const GLubyte*)"1.10.0",
667 khor 13459
    (const GLubyte*)"1",
677 janba 13460
    (const GLubyte*)"10",
667 khor 13461
    (const GLubyte*)"0"
13462
  };
13463
  const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;
13464
  return _glewString[(int)name > max_string ? 0 : (int)name];
13465
}
13466
 
13467
/* ------------------------------------------------------------------------ */
13468
 
13469
GLboolean glewExperimental = GL_FALSE;
13470
 
13471
#if !defined(GLEW_MX)
13472
 
13473
#if defined(_WIN32)
13474
extern GLenum GLEWAPIENTRY wglewContextInit (void);
677 janba 13475
#elif !defined(__ANDROID__) && !defined(__native_client__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))
667 khor 13476
extern GLenum GLEWAPIENTRY glxewContextInit (void);
13477
#endif /* _WIN32 */
13478
 
13479
GLenum GLEWAPIENTRY glewInit (void)
13480
{
13481
  GLenum r;
13482
  r = glewContextInit();
13483
  if ( r != 0 ) return r;
13484
#if defined(_WIN32)
13485
  return wglewContextInit();
677 janba 13486
#elif !defined(__ANDROID__) && !defined(__native_client__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) /* _UNIX */
667 khor 13487
  return glxewContextInit();
13488
#else
13489
  return r;
13490
#endif /* _WIN32 */
13491
}
13492
 
13493
#endif /* !GLEW_MX */
13494
#ifdef GLEW_MX
13495
GLboolean GLEWAPIENTRY glewContextIsSupported (const GLEWContext* ctx, const char* name)
13496
#else
13497
GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
13498
#endif
13499
{
13500
  GLubyte* pos = (GLubyte*)name;
13501
  GLuint len = _glewStrLen(pos);
13502
  GLboolean ret = GL_TRUE;
13503
  while (ret && len > 0)
13504
  {
13505
    if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))
13506
    {
13507
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))
13508
      {
13509
#ifdef GL_VERSION_1_2
13510
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))
13511
        {
13512
          ret = GLEW_VERSION_1_2;
13513
          continue;
13514
        }
13515
#endif
13516
#ifdef GL_VERSION_1_2_1
13517
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5))
13518
        {
13519
          ret = GLEW_VERSION_1_2_1;
13520
          continue;
13521
        }
13522
#endif
13523
#ifdef GL_VERSION_1_3
13524
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))
13525
        {
13526
          ret = GLEW_VERSION_1_3;
13527
          continue;
13528
        }
13529
#endif
13530
#ifdef GL_VERSION_1_4
13531
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))
13532
        {
13533
          ret = GLEW_VERSION_1_4;
13534
          continue;
13535
        }
13536
#endif
13537
#ifdef GL_VERSION_1_5
13538
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))
13539
        {
13540
          ret = GLEW_VERSION_1_5;
13541
          continue;
13542
        }
13543
#endif
13544
#ifdef GL_VERSION_2_0
13545
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))
13546
        {
13547
          ret = GLEW_VERSION_2_0;
13548
          continue;
13549
        }
13550
#endif
13551
#ifdef GL_VERSION_2_1
13552
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3))
13553
        {
13554
          ret = GLEW_VERSION_2_1;
13555
          continue;
13556
        }
13557
#endif
13558
#ifdef GL_VERSION_3_0
13559
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3))
13560
        {
13561
          ret = GLEW_VERSION_3_0;
13562
          continue;
13563
        }
13564
#endif
13565
#ifdef GL_VERSION_3_1
13566
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3))
13567
        {
13568
          ret = GLEW_VERSION_3_1;
13569
          continue;
13570
        }
13571
#endif
13572
#ifdef GL_VERSION_3_2
13573
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3))
13574
        {
13575
          ret = GLEW_VERSION_3_2;
13576
          continue;
13577
        }
13578
#endif
13579
#ifdef GL_VERSION_3_3
13580
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3))
13581
        {
13582
          ret = GLEW_VERSION_3_3;
13583
          continue;
13584
        }
13585
#endif
13586
#ifdef GL_VERSION_4_0
13587
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3))
13588
        {
13589
          ret = GLEW_VERSION_4_0;
13590
          continue;
13591
        }
13592
#endif
13593
#ifdef GL_VERSION_4_1
13594
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3))
13595
        {
13596
          ret = GLEW_VERSION_4_1;
13597
          continue;
13598
        }
13599
#endif
13600
#ifdef GL_VERSION_4_2
13601
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3))
13602
        {
13603
          ret = GLEW_VERSION_4_2;
13604
          continue;
13605
        }
13606
#endif
13607
#ifdef GL_VERSION_4_3
13608
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_3", 3))
13609
        {
13610
          ret = GLEW_VERSION_4_3;
13611
          continue;
13612
        }
13613
#endif
677 janba 13614
#ifdef GL_VERSION_4_4
13615
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_4", 3))
13616
        {
13617
          ret = GLEW_VERSION_4_4;
13618
          continue;
13619
        }
13620
#endif
667 khor 13621
      }
13622
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
13623
      {
13624
#ifdef GL_3DFX_multisample
13625
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
13626
        {
13627
          ret = GLEW_3DFX_multisample;
13628
          continue;
13629
        }
13630
#endif
13631
#ifdef GL_3DFX_tbuffer
13632
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))
13633
        {
13634
          ret = GLEW_3DFX_tbuffer;
13635
          continue;
13636
        }
13637
#endif
13638
#ifdef GL_3DFX_texture_compression_FXT1
13639
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))
13640
        {
13641
          ret = GLEW_3DFX_texture_compression_FXT1;
13642
          continue;
13643
        }
13644
#endif
13645
      }
13646
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
13647
      {
13648
#ifdef GL_AMD_blend_minmax_factor
13649
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19))
13650
        {
13651
          ret = GLEW_AMD_blend_minmax_factor;
13652
          continue;
13653
        }
13654
#endif
13655
#ifdef GL_AMD_conservative_depth
13656
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
13657
        {
13658
          ret = GLEW_AMD_conservative_depth;
13659
          continue;
13660
        }
13661
#endif
13662
#ifdef GL_AMD_debug_output
13663
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))
13664
        {
13665
          ret = GLEW_AMD_debug_output;
13666
          continue;
13667
        }
13668
#endif
13669
#ifdef GL_AMD_depth_clamp_separate
13670
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp_separate", 20))
13671
        {
13672
          ret = GLEW_AMD_depth_clamp_separate;
13673
          continue;
13674
        }
13675
#endif
13676
#ifdef GL_AMD_draw_buffers_blend
13677
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
13678
        {
13679
          ret = GLEW_AMD_draw_buffers_blend;
13680
          continue;
13681
        }
13682
#endif
677 janba 13683
#ifdef GL_AMD_interleaved_elements
13684
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interleaved_elements", 20))
13685
        {
13686
          ret = GLEW_AMD_interleaved_elements;
13687
          continue;
13688
        }
13689
#endif
667 khor 13690
#ifdef GL_AMD_multi_draw_indirect
13691
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))
13692
        {
13693
          ret = GLEW_AMD_multi_draw_indirect;
13694
          continue;
13695
        }
13696
#endif
13697
#ifdef GL_AMD_name_gen_delete
13698
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"name_gen_delete", 15))
13699
        {
13700
          ret = GLEW_AMD_name_gen_delete;
13701
          continue;
13702
        }
13703
#endif
13704
#ifdef GL_AMD_performance_monitor
13705
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19))
13706
        {
13707
          ret = GLEW_AMD_performance_monitor;
13708
          continue;
13709
        }
13710
#endif
13711
#ifdef GL_AMD_pinned_memory
13712
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pinned_memory", 13))
13713
        {
13714
          ret = GLEW_AMD_pinned_memory;
13715
          continue;
13716
        }
13717
#endif
13718
#ifdef GL_AMD_query_buffer_object
13719
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19))
13720
        {
13721
          ret = GLEW_AMD_query_buffer_object;
13722
          continue;
13723
        }
13724
#endif
13725
#ifdef GL_AMD_sample_positions
13726
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_positions", 16))
13727
        {
13728
          ret = GLEW_AMD_sample_positions;
13729
          continue;
13730
        }
13731
#endif
13732
#ifdef GL_AMD_seamless_cubemap_per_texture
13733
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))
13734
        {
13735
          ret = GLEW_AMD_seamless_cubemap_per_texture;
13736
          continue;
13737
        }
13738
#endif
13739
#ifdef GL_AMD_shader_stencil_export
13740
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
13741
        {
13742
          ret = GLEW_AMD_shader_stencil_export;
13743
          continue;
13744
        }
13745
#endif
677 janba 13746
#ifdef GL_AMD_shader_trinary_minmax
13747
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_trinary_minmax", 21))
13748
        {
13749
          ret = GLEW_AMD_shader_trinary_minmax;
13750
          continue;
13751
        }
13752
#endif
13753
#ifdef GL_AMD_sparse_texture
13754
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14))
13755
        {
13756
          ret = GLEW_AMD_sparse_texture;
13757
          continue;
13758
        }
13759
#endif
667 khor 13760
#ifdef GL_AMD_stencil_operation_extended
13761
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_operation_extended", 26))
13762
        {
13763
          ret = GLEW_AMD_stencil_operation_extended;
13764
          continue;
13765
        }
13766
#endif
13767
#ifdef GL_AMD_texture_texture4
13768
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16))
13769
        {
13770
          ret = GLEW_AMD_texture_texture4;
13771
          continue;
13772
        }
13773
#endif
13774
#ifdef GL_AMD_transform_feedback3_lines_triangles
13775
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3_lines_triangles", 35))
13776
        {
13777
          ret = GLEW_AMD_transform_feedback3_lines_triangles;
13778
          continue;
13779
        }
13780
#endif
13781
#ifdef GL_AMD_vertex_shader_layer
13782
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_layer", 19))
13783
        {
13784
          ret = GLEW_AMD_vertex_shader_layer;
13785
          continue;
13786
        }
13787
#endif
13788
#ifdef GL_AMD_vertex_shader_tessellator
13789
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25))
13790
        {
13791
          ret = GLEW_AMD_vertex_shader_tessellator;
13792
          continue;
13793
        }
13794
#endif
13795
#ifdef GL_AMD_vertex_shader_viewport_index
13796
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_viewport_index", 28))
13797
        {
13798
          ret = GLEW_AMD_vertex_shader_viewport_index;
13799
          continue;
13800
        }
13801
#endif
13802
      }
677 janba 13803
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6))
13804
      {
13805
#ifdef GL_ANGLE_depth_texture
13806
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
13807
        {
13808
          ret = GLEW_ANGLE_depth_texture;
13809
          continue;
13810
        }
13811
#endif
13812
#ifdef GL_ANGLE_framebuffer_blit
13813
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))
13814
        {
13815
          ret = GLEW_ANGLE_framebuffer_blit;
13816
          continue;
13817
        }
13818
#endif
13819
#ifdef GL_ANGLE_framebuffer_multisample
13820
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))
13821
        {
13822
          ret = GLEW_ANGLE_framebuffer_multisample;
13823
          continue;
13824
        }
13825
#endif
13826
#ifdef GL_ANGLE_instanced_arrays
13827
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))
13828
        {
13829
          ret = GLEW_ANGLE_instanced_arrays;
13830
          continue;
13831
        }
13832
#endif
13833
#ifdef GL_ANGLE_pack_reverse_row_order
13834
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_reverse_row_order", 22))
13835
        {
13836
          ret = GLEW_ANGLE_pack_reverse_row_order;
13837
          continue;
13838
        }
13839
#endif
13840
#ifdef GL_ANGLE_program_binary
13841
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14))
13842
        {
13843
          ret = GLEW_ANGLE_program_binary;
13844
          continue;
13845
        }
13846
#endif
13847
#ifdef GL_ANGLE_texture_compression_dxt1
13848
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))
13849
        {
13850
          ret = GLEW_ANGLE_texture_compression_dxt1;
13851
          continue;
13852
        }
13853
#endif
13854
#ifdef GL_ANGLE_texture_compression_dxt3
13855
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt3", 24))
13856
        {
13857
          ret = GLEW_ANGLE_texture_compression_dxt3;
13858
          continue;
13859
        }
13860
#endif
13861
#ifdef GL_ANGLE_texture_compression_dxt5
13862
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt5", 24))
13863
        {
13864
          ret = GLEW_ANGLE_texture_compression_dxt5;
13865
          continue;
13866
        }
13867
#endif
13868
#ifdef GL_ANGLE_texture_usage
13869
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_usage", 13))
13870
        {
13871
          ret = GLEW_ANGLE_texture_usage;
13872
          continue;
13873
        }
13874
#endif
13875
#ifdef GL_ANGLE_timer_query
13876
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
13877
        {
13878
          ret = GLEW_ANGLE_timer_query;
13879
          continue;
13880
        }
13881
#endif
13882
#ifdef GL_ANGLE_translated_shader_source
13883
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"translated_shader_source", 24))
13884
        {
13885
          ret = GLEW_ANGLE_translated_shader_source;
13886
          continue;
13887
        }
13888
#endif
13889
      }
667 khor 13890
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))
13891
      {
13892
#ifdef GL_APPLE_aux_depth_stencil
13893
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17))
13894
        {
13895
          ret = GLEW_APPLE_aux_depth_stencil;
13896
          continue;
13897
        }
13898
#endif
13899
#ifdef GL_APPLE_client_storage
13900
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))
13901
        {
13902
          ret = GLEW_APPLE_client_storage;
13903
          continue;
13904
        }
13905
#endif
13906
#ifdef GL_APPLE_element_array
13907
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))
13908
        {
13909
          ret = GLEW_APPLE_element_array;
13910
          continue;
13911
        }
13912
#endif
13913
#ifdef GL_APPLE_fence
13914
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))
13915
        {
13916
          ret = GLEW_APPLE_fence;
13917
          continue;
13918
        }
13919
#endif
13920
#ifdef GL_APPLE_float_pixels
13921
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))
13922
        {
13923
          ret = GLEW_APPLE_float_pixels;
13924
          continue;
13925
        }
13926
#endif
13927
#ifdef GL_APPLE_flush_buffer_range
13928
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18))
13929
        {
13930
          ret = GLEW_APPLE_flush_buffer_range;
13931
          continue;
13932
        }
13933
#endif
13934
#ifdef GL_APPLE_object_purgeable
13935
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16))
13936
        {
13937
          ret = GLEW_APPLE_object_purgeable;
13938
          continue;
13939
        }
13940
#endif
13941
#ifdef GL_APPLE_pixel_buffer
13942
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))
13943
        {
13944
          ret = GLEW_APPLE_pixel_buffer;
13945
          continue;
13946
        }
13947
#endif
13948
#ifdef GL_APPLE_rgb_422
13949
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7))
13950
        {
13951
          ret = GLEW_APPLE_rgb_422;
13952
          continue;
13953
        }
13954
#endif
13955
#ifdef GL_APPLE_row_bytes
13956
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9))
13957
        {
13958
          ret = GLEW_APPLE_row_bytes;
13959
          continue;
13960
        }
13961
#endif
13962
#ifdef GL_APPLE_specular_vector
13963
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))
13964
        {
13965
          ret = GLEW_APPLE_specular_vector;
13966
          continue;
13967
        }
13968
#endif
13969
#ifdef GL_APPLE_texture_range
13970
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))
13971
        {
13972
          ret = GLEW_APPLE_texture_range;
13973
          continue;
13974
        }
13975
#endif
13976
#ifdef GL_APPLE_transform_hint
13977
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))
13978
        {
13979
          ret = GLEW_APPLE_transform_hint;
13980
          continue;
13981
        }
13982
#endif
13983
#ifdef GL_APPLE_vertex_array_object
13984
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
13985
        {
13986
          ret = GLEW_APPLE_vertex_array_object;
13987
          continue;
13988
        }
13989
#endif
13990
#ifdef GL_APPLE_vertex_array_range
13991
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
13992
        {
13993
          ret = GLEW_APPLE_vertex_array_range;
13994
          continue;
13995
        }
13996
#endif
13997
#ifdef GL_APPLE_vertex_program_evaluators
13998
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25))
13999
        {
14000
          ret = GLEW_APPLE_vertex_program_evaluators;
14001
          continue;
14002
        }
14003
#endif
14004
#ifdef GL_APPLE_ycbcr_422
14005
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))
14006
        {
14007
          ret = GLEW_APPLE_ycbcr_422;
14008
          continue;
14009
        }
14010
#endif
14011
      }
14012
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
14013
      {
14014
#ifdef GL_ARB_ES2_compatibility
14015
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES2_compatibility", 17))
14016
        {
14017
          ret = GLEW_ARB_ES2_compatibility;
14018
          continue;
14019
        }
14020
#endif
14021
#ifdef GL_ARB_ES3_compatibility
14022
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_compatibility", 17))
14023
        {
14024
          ret = GLEW_ARB_ES3_compatibility;
14025
          continue;
14026
        }
14027
#endif
14028
#ifdef GL_ARB_arrays_of_arrays
14029
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"arrays_of_arrays", 16))
14030
        {
14031
          ret = GLEW_ARB_arrays_of_arrays;
14032
          continue;
14033
        }
14034
#endif
14035
#ifdef GL_ARB_base_instance
14036
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13))
14037
        {
14038
          ret = GLEW_ARB_base_instance;
14039
          continue;
14040
        }
14041
#endif
677 janba 14042
#ifdef GL_ARB_bindless_texture
14043
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16))
14044
        {
14045
          ret = GLEW_ARB_bindless_texture;
14046
          continue;
14047
        }
14048
#endif
667 khor 14049
#ifdef GL_ARB_blend_func_extended
14050
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19))
14051
        {
14052
          ret = GLEW_ARB_blend_func_extended;
14053
          continue;
14054
        }
14055
#endif
677 janba 14056
#ifdef GL_ARB_buffer_storage
14057
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_storage", 14))
14058
        {
14059
          ret = GLEW_ARB_buffer_storage;
14060
          continue;
14061
        }
14062
#endif
667 khor 14063
#ifdef GL_ARB_cl_event
14064
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8))
14065
        {
14066
          ret = GLEW_ARB_cl_event;
14067
          continue;
14068
        }
14069
#endif
14070
#ifdef GL_ARB_clear_buffer_object
14071
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_buffer_object", 19))
14072
        {
14073
          ret = GLEW_ARB_clear_buffer_object;
14074
          continue;
14075
        }
14076
#endif
677 janba 14077
#ifdef GL_ARB_clear_texture
14078
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_texture", 13))
14079
        {
14080
          ret = GLEW_ARB_clear_texture;
14081
          continue;
14082
        }
14083
#endif
667 khor 14084
#ifdef GL_ARB_color_buffer_float
14085
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))
14086
        {
14087
          ret = GLEW_ARB_color_buffer_float;
14088
          continue;
14089
        }
14090
#endif
14091
#ifdef GL_ARB_compatibility
14092
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13))
14093
        {
14094
          ret = GLEW_ARB_compatibility;
14095
          continue;
14096
        }
14097
#endif
14098
#ifdef GL_ARB_compressed_texture_pixel_storage
14099
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_texture_pixel_storage", 32))
14100
        {
14101
          ret = GLEW_ARB_compressed_texture_pixel_storage;
14102
          continue;
14103
        }
14104
#endif
14105
#ifdef GL_ARB_compute_shader
14106
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_shader", 14))
14107
        {
14108
          ret = GLEW_ARB_compute_shader;
14109
          continue;
14110
        }
14111
#endif
677 janba 14112
#ifdef GL_ARB_compute_variable_group_size
14113
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_variable_group_size", 27))
14114
        {
14115
          ret = GLEW_ARB_compute_variable_group_size;
14116
          continue;
14117
        }
14118
#endif
667 khor 14119
#ifdef GL_ARB_conservative_depth
14120
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
14121
        {
14122
          ret = GLEW_ARB_conservative_depth;
14123
          continue;
14124
        }
14125
#endif
14126
#ifdef GL_ARB_copy_buffer
14127
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))
14128
        {
14129
          ret = GLEW_ARB_copy_buffer;
14130
          continue;
14131
        }
14132
#endif
14133
#ifdef GL_ARB_copy_image
14134
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
14135
        {
14136
          ret = GLEW_ARB_copy_image;
14137
          continue;
14138
        }
14139
#endif
14140
#ifdef GL_ARB_debug_output
14141
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))
14142
        {
14143
          ret = GLEW_ARB_debug_output;
14144
          continue;
14145
        }
14146
#endif
14147
#ifdef GL_ARB_depth_buffer_float
14148
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
14149
        {
14150
          ret = GLEW_ARB_depth_buffer_float;
14151
          continue;
14152
        }
14153
#endif
14154
#ifdef GL_ARB_depth_clamp
14155
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
14156
        {
14157
          ret = GLEW_ARB_depth_clamp;
14158
          continue;
14159
        }
14160
#endif
14161
#ifdef GL_ARB_depth_texture
14162
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
14163
        {
14164
          ret = GLEW_ARB_depth_texture;
14165
          continue;
14166
        }
14167
#endif
14168
#ifdef GL_ARB_draw_buffers
14169
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))
14170
        {
14171
          ret = GLEW_ARB_draw_buffers;
14172
          continue;
14173
        }
14174
#endif
14175
#ifdef GL_ARB_draw_buffers_blend
14176
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
14177
        {
14178
          ret = GLEW_ARB_draw_buffers_blend;
14179
          continue;
14180
        }
14181
#endif
14182
#ifdef GL_ARB_draw_elements_base_vertex
14183
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25))
14184
        {
14185
          ret = GLEW_ARB_draw_elements_base_vertex;
14186
          continue;
14187
        }
14188
#endif
14189
#ifdef GL_ARB_draw_indirect
14190
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13))
14191
        {
14192
          ret = GLEW_ARB_draw_indirect;
14193
          continue;
14194
        }
14195
#endif
14196
#ifdef GL_ARB_draw_instanced
14197
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
14198
        {
14199
          ret = GLEW_ARB_draw_instanced;
14200
          continue;
14201
        }
14202
#endif
677 janba 14203
#ifdef GL_ARB_enhanced_layouts
14204
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"enhanced_layouts", 16))
14205
        {
14206
          ret = GLEW_ARB_enhanced_layouts;
14207
          continue;
14208
        }
14209
#endif
667 khor 14210
#ifdef GL_ARB_explicit_attrib_location
14211
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24))
14212
        {
14213
          ret = GLEW_ARB_explicit_attrib_location;
14214
          continue;
14215
        }
14216
#endif
14217
#ifdef GL_ARB_explicit_uniform_location
14218
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_uniform_location", 25))
14219
        {
14220
          ret = GLEW_ARB_explicit_uniform_location;
14221
          continue;
14222
        }
14223
#endif
14224
#ifdef GL_ARB_fragment_coord_conventions
14225
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26))
14226
        {
14227
          ret = GLEW_ARB_fragment_coord_conventions;
14228
          continue;
14229
        }
14230
#endif
14231
#ifdef GL_ARB_fragment_layer_viewport
14232
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_layer_viewport", 23))
14233
        {
14234
          ret = GLEW_ARB_fragment_layer_viewport;
14235
          continue;
14236
        }
14237
#endif
14238
#ifdef GL_ARB_fragment_program
14239
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
14240
        {
14241
          ret = GLEW_ARB_fragment_program;
14242
          continue;
14243
        }
14244
#endif
14245
#ifdef GL_ARB_fragment_program_shadow
14246
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))
14247
        {
14248
          ret = GLEW_ARB_fragment_program_shadow;
14249
          continue;
14250
        }
14251
#endif
14252
#ifdef GL_ARB_fragment_shader
14253
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))
14254
        {
14255
          ret = GLEW_ARB_fragment_shader;
14256
          continue;
14257
        }
14258
#endif
14259
#ifdef GL_ARB_framebuffer_no_attachments
14260
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_no_attachments", 26))
14261
        {
14262
          ret = GLEW_ARB_framebuffer_no_attachments;
14263
          continue;
14264
        }
14265
#endif
14266
#ifdef GL_ARB_framebuffer_object
14267
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))
14268
        {
14269
          ret = GLEW_ARB_framebuffer_object;
14270
          continue;
14271
        }
14272
#endif
14273
#ifdef GL_ARB_framebuffer_sRGB
14274
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
14275
        {
14276
          ret = GLEW_ARB_framebuffer_sRGB;
14277
          continue;
14278
        }
14279
#endif
14280
#ifdef GL_ARB_geometry_shader4
14281
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
14282
        {
14283
          ret = GLEW_ARB_geometry_shader4;
14284
          continue;
14285
        }
14286
#endif
14287
#ifdef GL_ARB_get_program_binary
14288
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18))
14289
        {
14290
          ret = GLEW_ARB_get_program_binary;
14291
          continue;
14292
        }
14293
#endif
14294
#ifdef GL_ARB_gpu_shader5
14295
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
14296
        {
14297
          ret = GLEW_ARB_gpu_shader5;
14298
          continue;
14299
        }
14300
#endif
14301
#ifdef GL_ARB_gpu_shader_fp64
14302
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15))
14303
        {
14304
          ret = GLEW_ARB_gpu_shader_fp64;
14305
          continue;
14306
        }
14307
#endif
14308
#ifdef GL_ARB_half_float_pixel
14309
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))
14310
        {
14311
          ret = GLEW_ARB_half_float_pixel;
14312
          continue;
14313
        }
14314
#endif
14315
#ifdef GL_ARB_half_float_vertex
14316
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17))
14317
        {
14318
          ret = GLEW_ARB_half_float_vertex;
14319
          continue;
14320
        }
14321
#endif
14322
#ifdef GL_ARB_imaging
14323
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))
14324
        {
14325
          ret = GLEW_ARB_imaging;
14326
          continue;
14327
        }
14328
#endif
677 janba 14329
#ifdef GL_ARB_indirect_parameters
14330
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"indirect_parameters", 19))
14331
        {
14332
          ret = GLEW_ARB_indirect_parameters;
14333
          continue;
14334
        }
14335
#endif
667 khor 14336
#ifdef GL_ARB_instanced_arrays
14337
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))
14338
        {
14339
          ret = GLEW_ARB_instanced_arrays;
14340
          continue;
14341
        }
14342
#endif
14343
#ifdef GL_ARB_internalformat_query
14344
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query", 20))
14345
        {
14346
          ret = GLEW_ARB_internalformat_query;
14347
          continue;
14348
        }
14349
#endif
14350
#ifdef GL_ARB_internalformat_query2
14351
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query2", 21))
14352
        {
14353
          ret = GLEW_ARB_internalformat_query2;
14354
          continue;
14355
        }
14356
#endif
14357
#ifdef GL_ARB_invalidate_subdata
14358
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"invalidate_subdata", 18))
14359
        {
14360
          ret = GLEW_ARB_invalidate_subdata;
14361
          continue;
14362
        }
14363
#endif
14364
#ifdef GL_ARB_map_buffer_alignment
14365
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_alignment", 20))
14366
        {
14367
          ret = GLEW_ARB_map_buffer_alignment;
14368
          continue;
14369
        }
14370
#endif
14371
#ifdef GL_ARB_map_buffer_range
14372
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16))
14373
        {
14374
          ret = GLEW_ARB_map_buffer_range;
14375
          continue;
14376
        }
14377
#endif
14378
#ifdef GL_ARB_matrix_palette
14379
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))
14380
        {
14381
          ret = GLEW_ARB_matrix_palette;
14382
          continue;
14383
        }
14384
#endif
677 janba 14385
#ifdef GL_ARB_multi_bind
14386
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_bind", 10))
14387
        {
14388
          ret = GLEW_ARB_multi_bind;
14389
          continue;
14390
        }
14391
#endif
667 khor 14392
#ifdef GL_ARB_multi_draw_indirect
14393
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))
14394
        {
14395
          ret = GLEW_ARB_multi_draw_indirect;
14396
          continue;
14397
        }
14398
#endif
14399
#ifdef GL_ARB_multisample
14400
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
14401
        {
14402
          ret = GLEW_ARB_multisample;
14403
          continue;
14404
        }
14405
#endif
14406
#ifdef GL_ARB_multitexture
14407
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))
14408
        {
14409
          ret = GLEW_ARB_multitexture;
14410
          continue;
14411
        }
14412
#endif
14413
#ifdef GL_ARB_occlusion_query
14414
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))
14415
        {
14416
          ret = GLEW_ARB_occlusion_query;
14417
          continue;
14418
        }
14419
#endif
14420
#ifdef GL_ARB_occlusion_query2
14421
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16))
14422
        {
14423
          ret = GLEW_ARB_occlusion_query2;
14424
          continue;
14425
        }
14426
#endif
14427
#ifdef GL_ARB_pixel_buffer_object
14428
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
14429
        {
14430
          ret = GLEW_ARB_pixel_buffer_object;
14431
          continue;
14432
        }
14433
#endif
14434
#ifdef GL_ARB_point_parameters
14435
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))
14436
        {
14437
          ret = GLEW_ARB_point_parameters;
14438
          continue;
14439
        }
14440
#endif
14441
#ifdef GL_ARB_point_sprite
14442
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))
14443
        {
14444
          ret = GLEW_ARB_point_sprite;
14445
          continue;
14446
        }
14447
#endif
14448
#ifdef GL_ARB_program_interface_query
14449
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_interface_query", 23))
14450
        {
14451
          ret = GLEW_ARB_program_interface_query;
14452
          continue;
14453
        }
14454
#endif
14455
#ifdef GL_ARB_provoking_vertex
14456
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
14457
        {
14458
          ret = GLEW_ARB_provoking_vertex;
14459
          continue;
14460
        }
14461
#endif
677 janba 14462
#ifdef GL_ARB_query_buffer_object
14463
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19))
14464
        {
14465
          ret = GLEW_ARB_query_buffer_object;
14466
          continue;
14467
        }
14468
#endif
667 khor 14469
#ifdef GL_ARB_robust_buffer_access_behavior
14470
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29))
14471
        {
14472
          ret = GLEW_ARB_robust_buffer_access_behavior;
14473
          continue;
14474
        }
14475
#endif
14476
#ifdef GL_ARB_robustness
14477
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10))
14478
        {
14479
          ret = GLEW_ARB_robustness;
14480
          continue;
14481
        }
14482
#endif
14483
#ifdef GL_ARB_robustness_application_isolation
14484
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))
14485
        {
14486
          ret = GLEW_ARB_robustness_application_isolation;
14487
          continue;
14488
        }
14489
#endif
14490
#ifdef GL_ARB_robustness_share_group_isolation
14491
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))
14492
        {
14493
          ret = GLEW_ARB_robustness_share_group_isolation;
14494
          continue;
14495
        }
14496
#endif
14497
#ifdef GL_ARB_sample_shading
14498
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14))
14499
        {
14500
          ret = GLEW_ARB_sample_shading;
14501
          continue;
14502
        }
14503
#endif
14504
#ifdef GL_ARB_sampler_objects
14505
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15))
14506
        {
14507
          ret = GLEW_ARB_sampler_objects;
14508
          continue;
14509
        }
14510
#endif
14511
#ifdef GL_ARB_seamless_cube_map
14512
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17))
14513
        {
14514
          ret = GLEW_ARB_seamless_cube_map;
14515
          continue;
14516
        }
14517
#endif
677 janba 14518
#ifdef GL_ARB_seamless_cubemap_per_texture
14519
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))
14520
        {
14521
          ret = GLEW_ARB_seamless_cubemap_per_texture;
14522
          continue;
14523
        }
14524
#endif
667 khor 14525
#ifdef GL_ARB_separate_shader_objects
14526
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
14527
        {
14528
          ret = GLEW_ARB_separate_shader_objects;
14529
          continue;
14530
        }
14531
#endif
14532
#ifdef GL_ARB_shader_atomic_counters
14533
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22))
14534
        {
14535
          ret = GLEW_ARB_shader_atomic_counters;
14536
          continue;
14537
        }
14538
#endif
14539
#ifdef GL_ARB_shader_bit_encoding
14540
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19))
14541
        {
14542
          ret = GLEW_ARB_shader_bit_encoding;
14543
          continue;
14544
        }
14545
#endif
677 janba 14546
#ifdef GL_ARB_shader_draw_parameters
14547
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_draw_parameters", 22))
14548
        {
14549
          ret = GLEW_ARB_shader_draw_parameters;
14550
          continue;
14551
        }
14552
#endif
14553
#ifdef GL_ARB_shader_group_vote
14554
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_group_vote", 17))
14555
        {
14556
          ret = GLEW_ARB_shader_group_vote;
14557
          continue;
14558
        }
14559
#endif
667 khor 14560
#ifdef GL_ARB_shader_image_load_store
14561
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
14562
        {
14563
          ret = GLEW_ARB_shader_image_load_store;
14564
          continue;
14565
        }
14566
#endif
14567
#ifdef GL_ARB_shader_image_size
14568
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_size", 17))
14569
        {
14570
          ret = GLEW_ARB_shader_image_size;
14571
          continue;
14572
        }
14573
#endif
14574
#ifdef GL_ARB_shader_objects
14575
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))
14576
        {
14577
          ret = GLEW_ARB_shader_objects;
14578
          continue;
14579
        }
14580
#endif
14581
#ifdef GL_ARB_shader_precision
14582
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_precision", 16))
14583
        {
14584
          ret = GLEW_ARB_shader_precision;
14585
          continue;
14586
        }
14587
#endif
14588
#ifdef GL_ARB_shader_stencil_export
14589
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
14590
        {
14591
          ret = GLEW_ARB_shader_stencil_export;
14592
          continue;
14593
        }
14594
#endif
14595
#ifdef GL_ARB_shader_storage_buffer_object
14596
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28))
14597
        {
14598
          ret = GLEW_ARB_shader_storage_buffer_object;
14599
          continue;
14600
        }
14601
#endif
14602
#ifdef GL_ARB_shader_subroutine
14603
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17))
14604
        {
14605
          ret = GLEW_ARB_shader_subroutine;
14606
          continue;
14607
        }
14608
#endif
14609
#ifdef GL_ARB_shader_texture_lod
14610
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
14611
        {
14612
          ret = GLEW_ARB_shader_texture_lod;
14613
          continue;
14614
        }
14615
#endif
14616
#ifdef GL_ARB_shading_language_100
14617
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))
14618
        {
14619
          ret = GLEW_ARB_shading_language_100;
14620
          continue;
14621
        }
14622
#endif
14623
#ifdef GL_ARB_shading_language_420pack
14624
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_420pack", 24))
14625
        {
14626
          ret = GLEW_ARB_shading_language_420pack;
14627
          continue;
14628
        }
14629
#endif
14630
#ifdef GL_ARB_shading_language_include
14631
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24))
14632
        {
14633
          ret = GLEW_ARB_shading_language_include;
14634
          continue;
14635
        }
14636
#endif
14637
#ifdef GL_ARB_shading_language_packing
14638
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_packing", 24))
14639
        {
14640
          ret = GLEW_ARB_shading_language_packing;
14641
          continue;
14642
        }
14643
#endif
14644
#ifdef GL_ARB_shadow
14645
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
14646
        {
14647
          ret = GLEW_ARB_shadow;
14648
          continue;
14649
        }
14650
#endif
14651
#ifdef GL_ARB_shadow_ambient
14652
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))
14653
        {
14654
          ret = GLEW_ARB_shadow_ambient;
14655
          continue;
14656
        }
14657
#endif
677 janba 14658
#ifdef GL_ARB_sparse_texture
14659
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14))
14660
        {
14661
          ret = GLEW_ARB_sparse_texture;
14662
          continue;
14663
        }
14664
#endif
667 khor 14665
#ifdef GL_ARB_stencil_texturing
14666
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_texturing", 17))
14667
        {
14668
          ret = GLEW_ARB_stencil_texturing;
14669
          continue;
14670
        }
14671
#endif
14672
#ifdef GL_ARB_sync
14673
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))
14674
        {
14675
          ret = GLEW_ARB_sync;
14676
          continue;
14677
        }
14678
#endif
14679
#ifdef GL_ARB_tessellation_shader
14680
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19))
14681
        {
14682
          ret = GLEW_ARB_tessellation_shader;
14683
          continue;
14684
        }
14685
#endif
14686
#ifdef GL_ARB_texture_border_clamp
14687
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
14688
        {
14689
          ret = GLEW_ARB_texture_border_clamp;
14690
          continue;
14691
        }
14692
#endif
14693
#ifdef GL_ARB_texture_buffer_object
14694
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))
14695
        {
14696
          ret = GLEW_ARB_texture_buffer_object;
14697
          continue;
14698
        }
14699
#endif
14700
#ifdef GL_ARB_texture_buffer_object_rgb32
14701
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27))
14702
        {
14703
          ret = GLEW_ARB_texture_buffer_object_rgb32;
14704
          continue;
14705
        }
14706
#endif
14707
#ifdef GL_ARB_texture_buffer_range
14708
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_range", 20))
14709
        {
14710
          ret = GLEW_ARB_texture_buffer_range;
14711
          continue;
14712
        }
14713
#endif
14714
#ifdef GL_ARB_texture_compression
14715
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))
14716
        {
14717
          ret = GLEW_ARB_texture_compression;
14718
          continue;
14719
        }
14720
#endif
14721
#ifdef GL_ARB_texture_compression_bptc
14722
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24))
14723
        {
14724
          ret = GLEW_ARB_texture_compression_bptc;
14725
          continue;
14726
        }
14727
#endif
14728
#ifdef GL_ARB_texture_compression_rgtc
14729
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
14730
        {
14731
          ret = GLEW_ARB_texture_compression_rgtc;
14732
          continue;
14733
        }
14734
#endif
14735
#ifdef GL_ARB_texture_cube_map
14736
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))
14737
        {
14738
          ret = GLEW_ARB_texture_cube_map;
14739
          continue;
14740
        }
14741
#endif
14742
#ifdef GL_ARB_texture_cube_map_array
14743
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22))
14744
        {
14745
          ret = GLEW_ARB_texture_cube_map_array;
14746
          continue;
14747
        }
14748
#endif
14749
#ifdef GL_ARB_texture_env_add
14750
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
14751
        {
14752
          ret = GLEW_ARB_texture_env_add;
14753
          continue;
14754
        }
14755
#endif
14756
#ifdef GL_ARB_texture_env_combine
14757
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))
14758
        {
14759
          ret = GLEW_ARB_texture_env_combine;
14760
          continue;
14761
        }
14762
#endif
14763
#ifdef GL_ARB_texture_env_crossbar
14764
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))
14765
        {
14766
          ret = GLEW_ARB_texture_env_crossbar;
14767
          continue;
14768
        }
14769
#endif
14770
#ifdef GL_ARB_texture_env_dot3
14771
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))
14772
        {
14773
          ret = GLEW_ARB_texture_env_dot3;
14774
          continue;
14775
        }
14776
#endif
14777
#ifdef GL_ARB_texture_float
14778
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))
14779
        {
14780
          ret = GLEW_ARB_texture_float;
14781
          continue;
14782
        }
14783
#endif
14784
#ifdef GL_ARB_texture_gather
14785
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14))
14786
        {
14787
          ret = GLEW_ARB_texture_gather;
14788
          continue;
14789
        }
14790
#endif
677 janba 14791
#ifdef GL_ARB_texture_mirror_clamp_to_edge
14792
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp_to_edge", 28))
14793
        {
14794
          ret = GLEW_ARB_texture_mirror_clamp_to_edge;
14795
          continue;
14796
        }
14797
#endif
667 khor 14798
#ifdef GL_ARB_texture_mirrored_repeat
14799
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
14800
        {
14801
          ret = GLEW_ARB_texture_mirrored_repeat;
14802
          continue;
14803
        }
14804
#endif
14805
#ifdef GL_ARB_texture_multisample
14806
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
14807
        {
14808
          ret = GLEW_ARB_texture_multisample;
14809
          continue;
14810
        }
14811
#endif
14812
#ifdef GL_ARB_texture_non_power_of_two
14813
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))
14814
        {
14815
          ret = GLEW_ARB_texture_non_power_of_two;
14816
          continue;
14817
        }
14818
#endif
14819
#ifdef GL_ARB_texture_query_levels
14820
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_levels", 20))
14821
        {
14822
          ret = GLEW_ARB_texture_query_levels;
14823
          continue;
14824
        }
14825
#endif
14826
#ifdef GL_ARB_texture_query_lod
14827
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17))
14828
        {
14829
          ret = GLEW_ARB_texture_query_lod;
14830
          continue;
14831
        }
14832
#endif
14833
#ifdef GL_ARB_texture_rectangle
14834
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
14835
        {
14836
          ret = GLEW_ARB_texture_rectangle;
14837
          continue;
14838
        }
14839
#endif
14840
#ifdef GL_ARB_texture_rg
14841
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10))
14842
        {
14843
          ret = GLEW_ARB_texture_rg;
14844
          continue;
14845
        }
14846
#endif
14847
#ifdef GL_ARB_texture_rgb10_a2ui
14848
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18))
14849
        {
14850
          ret = GLEW_ARB_texture_rgb10_a2ui;
14851
          continue;
14852
        }
14853
#endif
677 janba 14854
#ifdef GL_ARB_texture_stencil8
14855
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stencil8", 16))
14856
        {
14857
          ret = GLEW_ARB_texture_stencil8;
14858
          continue;
14859
        }
14860
#endif
667 khor 14861
#ifdef GL_ARB_texture_storage
14862
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15))
14863
        {
14864
          ret = GLEW_ARB_texture_storage;
14865
          continue;
14866
        }
14867
#endif
14868
#ifdef GL_ARB_texture_storage_multisample
14869
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_multisample", 27))
14870
        {
14871
          ret = GLEW_ARB_texture_storage_multisample;
14872
          continue;
14873
        }
14874
#endif
14875
#ifdef GL_ARB_texture_swizzle
14876
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
14877
        {
14878
          ret = GLEW_ARB_texture_swizzle;
14879
          continue;
14880
        }
14881
#endif
14882
#ifdef GL_ARB_texture_view
14883
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12))
14884
        {
14885
          ret = GLEW_ARB_texture_view;
14886
          continue;
14887
        }
14888
#endif
14889
#ifdef GL_ARB_timer_query
14890
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
14891
        {
14892
          ret = GLEW_ARB_timer_query;
14893
          continue;
14894
        }
14895
#endif
14896
#ifdef GL_ARB_transform_feedback2
14897
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
14898
        {
14899
          ret = GLEW_ARB_transform_feedback2;
14900
          continue;
14901
        }
14902
#endif
14903
#ifdef GL_ARB_transform_feedback3
14904
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19))
14905
        {
14906
          ret = GLEW_ARB_transform_feedback3;
14907
          continue;
14908
        }
14909
#endif
14910
#ifdef GL_ARB_transform_feedback_instanced
14911
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_instanced", 28))
14912
        {
14913
          ret = GLEW_ARB_transform_feedback_instanced;
14914
          continue;
14915
        }
14916
#endif
14917
#ifdef GL_ARB_transpose_matrix
14918
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))
14919
        {
14920
          ret = GLEW_ARB_transpose_matrix;
14921
          continue;
14922
        }
14923
#endif
14924
#ifdef GL_ARB_uniform_buffer_object
14925
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21))
14926
        {
14927
          ret = GLEW_ARB_uniform_buffer_object;
14928
          continue;
14929
        }
14930
#endif
14931
#ifdef GL_ARB_vertex_array_bgra
14932
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
14933
        {
14934
          ret = GLEW_ARB_vertex_array_bgra;
14935
          continue;
14936
        }
14937
#endif
14938
#ifdef GL_ARB_vertex_array_object
14939
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
14940
        {
14941
          ret = GLEW_ARB_vertex_array_object;
14942
          continue;
14943
        }
14944
#endif
14945
#ifdef GL_ARB_vertex_attrib_64bit
14946
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
14947
        {
14948
          ret = GLEW_ARB_vertex_attrib_64bit;
14949
          continue;
14950
        }
14951
#endif
14952
#ifdef GL_ARB_vertex_attrib_binding
14953
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_binding", 21))
14954
        {
14955
          ret = GLEW_ARB_vertex_attrib_binding;
14956
          continue;
14957
        }
14958
#endif
14959
#ifdef GL_ARB_vertex_blend
14960
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))
14961
        {
14962
          ret = GLEW_ARB_vertex_blend;
14963
          continue;
14964
        }
14965
#endif
14966
#ifdef GL_ARB_vertex_buffer_object
14967
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
14968
        {
14969
          ret = GLEW_ARB_vertex_buffer_object;
14970
          continue;
14971
        }
14972
#endif
14973
#ifdef GL_ARB_vertex_program
14974
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
14975
        {
14976
          ret = GLEW_ARB_vertex_program;
14977
          continue;
14978
        }
14979
#endif
14980
#ifdef GL_ARB_vertex_shader
14981
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
14982
        {
14983
          ret = GLEW_ARB_vertex_shader;
14984
          continue;
14985
        }
14986
#endif
677 janba 14987
#ifdef GL_ARB_vertex_type_10f_11f_11f_rev
14988
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_10f_11f_11f_rev", 27))
14989
        {
14990
          ret = GLEW_ARB_vertex_type_10f_11f_11f_rev;
14991
          continue;
14992
        }
14993
#endif
667 khor 14994
#ifdef GL_ARB_vertex_type_2_10_10_10_rev
14995
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26))
14996
        {
14997
          ret = GLEW_ARB_vertex_type_2_10_10_10_rev;
14998
          continue;
14999
        }
15000
#endif
15001
#ifdef GL_ARB_viewport_array
15002
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14))
15003
        {
15004
          ret = GLEW_ARB_viewport_array;
15005
          continue;
15006
        }
15007
#endif
15008
#ifdef GL_ARB_window_pos
15009
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
15010
        {
15011
          ret = GLEW_ARB_window_pos;
15012
          continue;
15013
        }
15014
#endif
15015
      }
15016
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))
15017
      {
15018
#ifdef GL_ATIX_point_sprites
15019
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))
15020
        {
15021
          ret = GLEW_ATIX_point_sprites;
15022
          continue;
15023
        }
15024
#endif
15025
#ifdef GL_ATIX_texture_env_combine3
15026
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))
15027
        {
15028
          ret = GLEW_ATIX_texture_env_combine3;
15029
          continue;
15030
        }
15031
#endif
15032
#ifdef GL_ATIX_texture_env_route
15033
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))
15034
        {
15035
          ret = GLEW_ATIX_texture_env_route;
15036
          continue;
15037
        }
15038
#endif
15039
#ifdef GL_ATIX_vertex_shader_output_point_size
15040
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))
15041
        {
15042
          ret = GLEW_ATIX_vertex_shader_output_point_size;
15043
          continue;
15044
        }
15045
#endif
15046
      }
15047
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
15048
      {
15049
#ifdef GL_ATI_draw_buffers
15050
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))
15051
        {
15052
          ret = GLEW_ATI_draw_buffers;
15053
          continue;
15054
        }
15055
#endif
15056
#ifdef GL_ATI_element_array
15057
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))
15058
        {
15059
          ret = GLEW_ATI_element_array;
15060
          continue;
15061
        }
15062
#endif
15063
#ifdef GL_ATI_envmap_bumpmap
15064
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))
15065
        {
15066
          ret = GLEW_ATI_envmap_bumpmap;
15067
          continue;
15068
        }
15069
#endif
15070
#ifdef GL_ATI_fragment_shader
15071
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))
15072
        {
15073
          ret = GLEW_ATI_fragment_shader;
15074
          continue;
15075
        }
15076
#endif
15077
#ifdef GL_ATI_map_object_buffer
15078
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))
15079
        {
15080
          ret = GLEW_ATI_map_object_buffer;
15081
          continue;
15082
        }
15083
#endif
15084
#ifdef GL_ATI_meminfo
15085
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7))
15086
        {
15087
          ret = GLEW_ATI_meminfo;
15088
          continue;
15089
        }
15090
#endif
15091
#ifdef GL_ATI_pn_triangles
15092
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))
15093
        {
15094
          ret = GLEW_ATI_pn_triangles;
15095
          continue;
15096
        }
15097
#endif
15098
#ifdef GL_ATI_separate_stencil
15099
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))
15100
        {
15101
          ret = GLEW_ATI_separate_stencil;
15102
          continue;
15103
        }
15104
#endif
15105
#ifdef GL_ATI_shader_texture_lod
15106
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
15107
        {
15108
          ret = GLEW_ATI_shader_texture_lod;
15109
          continue;
15110
        }
15111
#endif
15112
#ifdef GL_ATI_text_fragment_shader
15113
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))
15114
        {
15115
          ret = GLEW_ATI_text_fragment_shader;
15116
          continue;
15117
        }
15118
#endif
15119
#ifdef GL_ATI_texture_compression_3dc
15120
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))
15121
        {
15122
          ret = GLEW_ATI_texture_compression_3dc;
15123
          continue;
15124
        }
15125
#endif
15126
#ifdef GL_ATI_texture_env_combine3
15127
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))
15128
        {
15129
          ret = GLEW_ATI_texture_env_combine3;
15130
          continue;
15131
        }
15132
#endif
15133
#ifdef GL_ATI_texture_float
15134
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))
15135
        {
15136
          ret = GLEW_ATI_texture_float;
15137
          continue;
15138
        }
15139
#endif
15140
#ifdef GL_ATI_texture_mirror_once
15141
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))
15142
        {
15143
          ret = GLEW_ATI_texture_mirror_once;
15144
          continue;
15145
        }
15146
#endif
15147
#ifdef GL_ATI_vertex_array_object
15148
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
15149
        {
15150
          ret = GLEW_ATI_vertex_array_object;
15151
          continue;
15152
        }
15153
#endif
15154
#ifdef GL_ATI_vertex_attrib_array_object
15155
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))
15156
        {
15157
          ret = GLEW_ATI_vertex_attrib_array_object;
15158
          continue;
15159
        }
15160
#endif
15161
#ifdef GL_ATI_vertex_streams
15162
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))
15163
        {
15164
          ret = GLEW_ATI_vertex_streams;
15165
          continue;
15166
        }
15167
#endif
15168
      }
15169
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
15170
      {
15171
#ifdef GL_EXT_422_pixels
15172
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))
15173
        {
15174
          ret = GLEW_EXT_422_pixels;
15175
          continue;
15176
        }
15177
#endif
15178
#ifdef GL_EXT_Cg_shader
15179
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))
15180
        {
15181
          ret = GLEW_EXT_Cg_shader;
15182
          continue;
15183
        }
15184
#endif
15185
#ifdef GL_EXT_abgr
15186
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))
15187
        {
15188
          ret = GLEW_EXT_abgr;
15189
          continue;
15190
        }
15191
#endif
15192
#ifdef GL_EXT_bgra
15193
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))
15194
        {
15195
          ret = GLEW_EXT_bgra;
15196
          continue;
15197
        }
15198
#endif
15199
#ifdef GL_EXT_bindable_uniform
15200
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16))
15201
        {
15202
          ret = GLEW_EXT_bindable_uniform;
15203
          continue;
15204
        }
15205
#endif
15206
#ifdef GL_EXT_blend_color
15207
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))
15208
        {
15209
          ret = GLEW_EXT_blend_color;
15210
          continue;
15211
        }
15212
#endif
15213
#ifdef GL_EXT_blend_equation_separate
15214
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))
15215
        {
15216
          ret = GLEW_EXT_blend_equation_separate;
15217
          continue;
15218
        }
15219
#endif
15220
#ifdef GL_EXT_blend_func_separate
15221
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))
15222
        {
15223
          ret = GLEW_EXT_blend_func_separate;
15224
          continue;
15225
        }
15226
#endif
15227
#ifdef GL_EXT_blend_logic_op
15228
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))
15229
        {
15230
          ret = GLEW_EXT_blend_logic_op;
15231
          continue;
15232
        }
15233
#endif
15234
#ifdef GL_EXT_blend_minmax
15235
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))
15236
        {
15237
          ret = GLEW_EXT_blend_minmax;
15238
          continue;
15239
        }
15240
#endif
15241
#ifdef GL_EXT_blend_subtract
15242
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))
15243
        {
15244
          ret = GLEW_EXT_blend_subtract;
15245
          continue;
15246
        }
15247
#endif
15248
#ifdef GL_EXT_clip_volume_hint
15249
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))
15250
        {
15251
          ret = GLEW_EXT_clip_volume_hint;
15252
          continue;
15253
        }
15254
#endif
15255
#ifdef GL_EXT_cmyka
15256
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))
15257
        {
15258
          ret = GLEW_EXT_cmyka;
15259
          continue;
15260
        }
15261
#endif
15262
#ifdef GL_EXT_color_subtable
15263
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))
15264
        {
15265
          ret = GLEW_EXT_color_subtable;
15266
          continue;
15267
        }
15268
#endif
15269
#ifdef GL_EXT_compiled_vertex_array
15270
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))
15271
        {
15272
          ret = GLEW_EXT_compiled_vertex_array;
15273
          continue;
15274
        }
15275
#endif
15276
#ifdef GL_EXT_convolution
15277
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))
15278
        {
15279
          ret = GLEW_EXT_convolution;
15280
          continue;
15281
        }
15282
#endif
15283
#ifdef GL_EXT_coordinate_frame
15284
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))
15285
        {
15286
          ret = GLEW_EXT_coordinate_frame;
15287
          continue;
15288
        }
15289
#endif
15290
#ifdef GL_EXT_copy_texture
15291
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))
15292
        {
15293
          ret = GLEW_EXT_copy_texture;
15294
          continue;
15295
        }
15296
#endif
15297
#ifdef GL_EXT_cull_vertex
15298
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))
15299
        {
15300
          ret = GLEW_EXT_cull_vertex;
15301
          continue;
15302
        }
15303
#endif
15304
#ifdef GL_EXT_debug_marker
15305
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_marker", 12))
15306
        {
15307
          ret = GLEW_EXT_debug_marker;
15308
          continue;
15309
        }
15310
#endif
15311
#ifdef GL_EXT_depth_bounds_test
15312
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))
15313
        {
15314
          ret = GLEW_EXT_depth_bounds_test;
15315
          continue;
15316
        }
15317
#endif
15318
#ifdef GL_EXT_direct_state_access
15319
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19))
15320
        {
15321
          ret = GLEW_EXT_direct_state_access;
15322
          continue;
15323
        }
15324
#endif
15325
#ifdef GL_EXT_draw_buffers2
15326
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13))
15327
        {
15328
          ret = GLEW_EXT_draw_buffers2;
15329
          continue;
15330
        }
15331
#endif
15332
#ifdef GL_EXT_draw_instanced
15333
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
15334
        {
15335
          ret = GLEW_EXT_draw_instanced;
15336
          continue;
15337
        }
15338
#endif
15339
#ifdef GL_EXT_draw_range_elements
15340
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))
15341
        {
15342
          ret = GLEW_EXT_draw_range_elements;
15343
          continue;
15344
        }
15345
#endif
15346
#ifdef GL_EXT_fog_coord
15347
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))
15348
        {
15349
          ret = GLEW_EXT_fog_coord;
15350
          continue;
15351
        }
15352
#endif
15353
#ifdef GL_EXT_fragment_lighting
15354
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))
15355
        {
15356
          ret = GLEW_EXT_fragment_lighting;
15357
          continue;
15358
        }
15359
#endif
15360
#ifdef GL_EXT_framebuffer_blit
15361
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))
15362
        {
15363
          ret = GLEW_EXT_framebuffer_blit;
15364
          continue;
15365
        }
15366
#endif
15367
#ifdef GL_EXT_framebuffer_multisample
15368
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))
15369
        {
15370
          ret = GLEW_EXT_framebuffer_multisample;
15371
          continue;
15372
        }
15373
#endif
15374
#ifdef GL_EXT_framebuffer_multisample_blit_scaled
15375
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_blit_scaled", 35))
15376
        {
15377
          ret = GLEW_EXT_framebuffer_multisample_blit_scaled;
15378
          continue;
15379
        }
15380
#endif
15381
#ifdef GL_EXT_framebuffer_object
15382
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))
15383
        {
15384
          ret = GLEW_EXT_framebuffer_object;
15385
          continue;
15386
        }
15387
#endif
15388
#ifdef GL_EXT_framebuffer_sRGB
15389
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
15390
        {
15391
          ret = GLEW_EXT_framebuffer_sRGB;
15392
          continue;
15393
        }
15394
#endif
15395
#ifdef GL_EXT_geometry_shader4
15396
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
15397
        {
15398
          ret = GLEW_EXT_geometry_shader4;
15399
          continue;
15400
        }
15401
#endif
15402
#ifdef GL_EXT_gpu_program_parameters
15403
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22))
15404
        {
15405
          ret = GLEW_EXT_gpu_program_parameters;
15406
          continue;
15407
        }
15408
#endif
15409
#ifdef GL_EXT_gpu_shader4
15410
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11))
15411
        {
15412
          ret = GLEW_EXT_gpu_shader4;
15413
          continue;
15414
        }
15415
#endif
15416
#ifdef GL_EXT_histogram
15417
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))
15418
        {
15419
          ret = GLEW_EXT_histogram;
15420
          continue;
15421
        }
15422
#endif
15423
#ifdef GL_EXT_index_array_formats
15424
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))
15425
        {
15426
          ret = GLEW_EXT_index_array_formats;
15427
          continue;
15428
        }
15429
#endif
15430
#ifdef GL_EXT_index_func
15431
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))
15432
        {
15433
          ret = GLEW_EXT_index_func;
15434
          continue;
15435
        }
15436
#endif
15437
#ifdef GL_EXT_index_material
15438
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))
15439
        {
15440
          ret = GLEW_EXT_index_material;
15441
          continue;
15442
        }
15443
#endif
15444
#ifdef GL_EXT_index_texture
15445
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))
15446
        {
15447
          ret = GLEW_EXT_index_texture;
15448
          continue;
15449
        }
15450
#endif
15451
#ifdef GL_EXT_light_texture
15452
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))
15453
        {
15454
          ret = GLEW_EXT_light_texture;
15455
          continue;
15456
        }
15457
#endif
15458
#ifdef GL_EXT_misc_attribute
15459
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))
15460
        {
15461
          ret = GLEW_EXT_misc_attribute;
15462
          continue;
15463
        }
15464
#endif
15465
#ifdef GL_EXT_multi_draw_arrays
15466
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))
15467
        {
15468
          ret = GLEW_EXT_multi_draw_arrays;
15469
          continue;
15470
        }
15471
#endif
15472
#ifdef GL_EXT_multisample
15473
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
15474
        {
15475
          ret = GLEW_EXT_multisample;
15476
          continue;
15477
        }
15478
#endif
15479
#ifdef GL_EXT_packed_depth_stencil
15480
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))
15481
        {
15482
          ret = GLEW_EXT_packed_depth_stencil;
15483
          continue;
15484
        }
15485
#endif
15486
#ifdef GL_EXT_packed_float
15487
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))
15488
        {
15489
          ret = GLEW_EXT_packed_float;
15490
          continue;
15491
        }
15492
#endif
15493
#ifdef GL_EXT_packed_pixels
15494
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))
15495
        {
15496
          ret = GLEW_EXT_packed_pixels;
15497
          continue;
15498
        }
15499
#endif
15500
#ifdef GL_EXT_paletted_texture
15501
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))
15502
        {
15503
          ret = GLEW_EXT_paletted_texture;
15504
          continue;
15505
        }
15506
#endif
15507
#ifdef GL_EXT_pixel_buffer_object
15508
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
15509
        {
15510
          ret = GLEW_EXT_pixel_buffer_object;
15511
          continue;
15512
        }
15513
#endif
15514
#ifdef GL_EXT_pixel_transform
15515
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))
15516
        {
15517
          ret = GLEW_EXT_pixel_transform;
15518
          continue;
15519
        }
15520
#endif
15521
#ifdef GL_EXT_pixel_transform_color_table
15522
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))
15523
        {
15524
          ret = GLEW_EXT_pixel_transform_color_table;
15525
          continue;
15526
        }
15527
#endif
15528
#ifdef GL_EXT_point_parameters
15529
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))
15530
        {
15531
          ret = GLEW_EXT_point_parameters;
15532
          continue;
15533
        }
15534
#endif
15535
#ifdef GL_EXT_polygon_offset
15536
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))
15537
        {
15538
          ret = GLEW_EXT_polygon_offset;
15539
          continue;
15540
        }
15541
#endif
15542
#ifdef GL_EXT_provoking_vertex
15543
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
15544
        {
15545
          ret = GLEW_EXT_provoking_vertex;
15546
          continue;
15547
        }
15548
#endif
15549
#ifdef GL_EXT_rescale_normal
15550
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))
15551
        {
15552
          ret = GLEW_EXT_rescale_normal;
15553
          continue;
15554
        }
15555
#endif
15556
#ifdef GL_EXT_scene_marker
15557
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))
15558
        {
15559
          ret = GLEW_EXT_scene_marker;
15560
          continue;
15561
        }
15562
#endif
15563
#ifdef GL_EXT_secondary_color
15564
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))
15565
        {
15566
          ret = GLEW_EXT_secondary_color;
15567
          continue;
15568
        }
15569
#endif
15570
#ifdef GL_EXT_separate_shader_objects
15571
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
15572
        {
15573
          ret = GLEW_EXT_separate_shader_objects;
15574
          continue;
15575
        }
15576
#endif
15577
#ifdef GL_EXT_separate_specular_color
15578
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))
15579
        {
15580
          ret = GLEW_EXT_separate_specular_color;
15581
          continue;
15582
        }
15583
#endif
15584
#ifdef GL_EXT_shader_image_load_store
15585
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
15586
        {
15587
          ret = GLEW_EXT_shader_image_load_store;
15588
          continue;
15589
        }
15590
#endif
15591
#ifdef GL_EXT_shadow_funcs
15592
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))
15593
        {
15594
          ret = GLEW_EXT_shadow_funcs;
15595
          continue;
15596
        }
15597
#endif
15598
#ifdef GL_EXT_shared_texture_palette
15599
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))
15600
        {
15601
          ret = GLEW_EXT_shared_texture_palette;
15602
          continue;
15603
        }
15604
#endif
15605
#ifdef GL_EXT_stencil_clear_tag
15606
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17))
15607
        {
15608
          ret = GLEW_EXT_stencil_clear_tag;
15609
          continue;
15610
        }
15611
#endif
15612
#ifdef GL_EXT_stencil_two_side
15613
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))
15614
        {
15615
          ret = GLEW_EXT_stencil_two_side;
15616
          continue;
15617
        }
15618
#endif
15619
#ifdef GL_EXT_stencil_wrap
15620
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))
15621
        {
15622
          ret = GLEW_EXT_stencil_wrap;
15623
          continue;
15624
        }
15625
#endif
15626
#ifdef GL_EXT_subtexture
15627
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))
15628
        {
15629
          ret = GLEW_EXT_subtexture;
15630
          continue;
15631
        }
15632
#endif
15633
#ifdef GL_EXT_texture
15634
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))
15635
        {
15636
          ret = GLEW_EXT_texture;
15637
          continue;
15638
        }
15639
#endif
15640
#ifdef GL_EXT_texture3D
15641
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))
15642
        {
15643
          ret = GLEW_EXT_texture3D;
15644
          continue;
15645
        }
15646
#endif
15647
#ifdef GL_EXT_texture_array
15648
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))
15649
        {
15650
          ret = GLEW_EXT_texture_array;
15651
          continue;
15652
        }
15653
#endif
15654
#ifdef GL_EXT_texture_buffer_object
15655
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))
15656
        {
15657
          ret = GLEW_EXT_texture_buffer_object;
15658
          continue;
15659
        }
15660
#endif
15661
#ifdef GL_EXT_texture_compression_dxt1
15662
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))
15663
        {
15664
          ret = GLEW_EXT_texture_compression_dxt1;
15665
          continue;
15666
        }
15667
#endif
15668
#ifdef GL_EXT_texture_compression_latc
15669
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))
15670
        {
15671
          ret = GLEW_EXT_texture_compression_latc;
15672
          continue;
15673
        }
15674
#endif
15675
#ifdef GL_EXT_texture_compression_rgtc
15676
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
15677
        {
15678
          ret = GLEW_EXT_texture_compression_rgtc;
15679
          continue;
15680
        }
15681
#endif
15682
#ifdef GL_EXT_texture_compression_s3tc
15683
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))
15684
        {
15685
          ret = GLEW_EXT_texture_compression_s3tc;
15686
          continue;
15687
        }
15688
#endif
15689
#ifdef GL_EXT_texture_cube_map
15690
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))
15691
        {
15692
          ret = GLEW_EXT_texture_cube_map;
15693
          continue;
15694
        }
15695
#endif
15696
#ifdef GL_EXT_texture_edge_clamp
15697
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))
15698
        {
15699
          ret = GLEW_EXT_texture_edge_clamp;
15700
          continue;
15701
        }
15702
#endif
15703
#ifdef GL_EXT_texture_env
15704
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))
15705
        {
15706
          ret = GLEW_EXT_texture_env;
15707
          continue;
15708
        }
15709
#endif
15710
#ifdef GL_EXT_texture_env_add
15711
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
15712
        {
15713
          ret = GLEW_EXT_texture_env_add;
15714
          continue;
15715
        }
15716
#endif
15717
#ifdef GL_EXT_texture_env_combine
15718
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))
15719
        {
15720
          ret = GLEW_EXT_texture_env_combine;
15721
          continue;
15722
        }
15723
#endif
15724
#ifdef GL_EXT_texture_env_dot3
15725
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))
15726
        {
15727
          ret = GLEW_EXT_texture_env_dot3;
15728
          continue;
15729
        }
15730
#endif
15731
#ifdef GL_EXT_texture_filter_anisotropic
15732
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))
15733
        {
15734
          ret = GLEW_EXT_texture_filter_anisotropic;
15735
          continue;
15736
        }
15737
#endif
15738
#ifdef GL_EXT_texture_integer
15739
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15))
15740
        {
15741
          ret = GLEW_EXT_texture_integer;
15742
          continue;
15743
        }
15744
#endif
15745
#ifdef GL_EXT_texture_lod_bias
15746
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
15747
        {
15748
          ret = GLEW_EXT_texture_lod_bias;
15749
          continue;
15750
        }
15751
#endif
15752
#ifdef GL_EXT_texture_mirror_clamp
15753
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))
15754
        {
15755
          ret = GLEW_EXT_texture_mirror_clamp;
15756
          continue;
15757
        }
15758
#endif
15759
#ifdef GL_EXT_texture_object
15760
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))
15761
        {
15762
          ret = GLEW_EXT_texture_object;
15763
          continue;
15764
        }
15765
#endif
15766
#ifdef GL_EXT_texture_perturb_normal
15767
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))
15768
        {
15769
          ret = GLEW_EXT_texture_perturb_normal;
15770
          continue;
15771
        }
15772
#endif
15773
#ifdef GL_EXT_texture_rectangle
15774
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
15775
        {
15776
          ret = GLEW_EXT_texture_rectangle;
15777
          continue;
15778
        }
15779
#endif
15780
#ifdef GL_EXT_texture_sRGB
15781
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12))
15782
        {
15783
          ret = GLEW_EXT_texture_sRGB;
15784
          continue;
15785
        }
15786
#endif
15787
#ifdef GL_EXT_texture_sRGB_decode
15788
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19))
15789
        {
15790
          ret = GLEW_EXT_texture_sRGB_decode;
15791
          continue;
15792
        }
15793
#endif
15794
#ifdef GL_EXT_texture_shared_exponent
15795
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23))
15796
        {
15797
          ret = GLEW_EXT_texture_shared_exponent;
15798
          continue;
15799
        }
15800
#endif
15801
#ifdef GL_EXT_texture_snorm
15802
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13))
15803
        {
15804
          ret = GLEW_EXT_texture_snorm;
15805
          continue;
15806
        }
15807
#endif
15808
#ifdef GL_EXT_texture_swizzle
15809
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
15810
        {
15811
          ret = GLEW_EXT_texture_swizzle;
15812
          continue;
15813
        }
15814
#endif
15815
#ifdef GL_EXT_timer_query
15816
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
15817
        {
15818
          ret = GLEW_EXT_timer_query;
15819
          continue;
15820
        }
15821
#endif
15822
#ifdef GL_EXT_transform_feedback
15823
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
15824
        {
15825
          ret = GLEW_EXT_transform_feedback;
15826
          continue;
15827
        }
15828
#endif
15829
#ifdef GL_EXT_vertex_array
15830
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))
15831
        {
15832
          ret = GLEW_EXT_vertex_array;
15833
          continue;
15834
        }
15835
#endif
15836
#ifdef GL_EXT_vertex_array_bgra
15837
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
15838
        {
15839
          ret = GLEW_EXT_vertex_array_bgra;
15840
          continue;
15841
        }
15842
#endif
15843
#ifdef GL_EXT_vertex_attrib_64bit
15844
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
15845
        {
15846
          ret = GLEW_EXT_vertex_attrib_64bit;
15847
          continue;
15848
        }
15849
#endif
15850
#ifdef GL_EXT_vertex_shader
15851
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
15852
        {
15853
          ret = GLEW_EXT_vertex_shader;
15854
          continue;
15855
        }
15856
#endif
15857
#ifdef GL_EXT_vertex_weighting
15858
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))
15859
        {
15860
          ret = GLEW_EXT_vertex_weighting;
15861
          continue;
15862
        }
15863
#endif
15864
#ifdef GL_EXT_x11_sync_object
15865
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"x11_sync_object", 15))
15866
        {
15867
          ret = GLEW_EXT_x11_sync_object;
15868
          continue;
15869
        }
15870
#endif
15871
      }
15872
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8))
15873
      {
15874
#ifdef GL_GREMEDY_frame_terminator
15875
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16))
15876
        {
15877
          ret = GLEW_GREMEDY_frame_terminator;
15878
          continue;
15879
        }
15880
#endif
15881
#ifdef GL_GREMEDY_string_marker
15882
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13))
15883
        {
15884
          ret = GLEW_GREMEDY_string_marker;
15885
          continue;
15886
        }
15887
#endif
15888
      }
15889
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))
15890
      {
15891
#ifdef GL_HP_convolution_border_modes
15892
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))
15893
        {
15894
          ret = GLEW_HP_convolution_border_modes;
15895
          continue;
15896
        }
15897
#endif
15898
#ifdef GL_HP_image_transform
15899
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))
15900
        {
15901
          ret = GLEW_HP_image_transform;
15902
          continue;
15903
        }
15904
#endif
15905
#ifdef GL_HP_occlusion_test
15906
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))
15907
        {
15908
          ret = GLEW_HP_occlusion_test;
15909
          continue;
15910
        }
15911
#endif
15912
#ifdef GL_HP_texture_lighting
15913
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))
15914
        {
15915
          ret = GLEW_HP_texture_lighting;
15916
          continue;
15917
        }
15918
#endif
15919
      }
15920
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))
15921
      {
15922
#ifdef GL_IBM_cull_vertex
15923
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))
15924
        {
15925
          ret = GLEW_IBM_cull_vertex;
15926
          continue;
15927
        }
15928
#endif
15929
#ifdef GL_IBM_multimode_draw_arrays
15930
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))
15931
        {
15932
          ret = GLEW_IBM_multimode_draw_arrays;
15933
          continue;
15934
        }
15935
#endif
15936
#ifdef GL_IBM_rasterpos_clip
15937
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))
15938
        {
15939
          ret = GLEW_IBM_rasterpos_clip;
15940
          continue;
15941
        }
15942
#endif
15943
#ifdef GL_IBM_static_data
15944
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))
15945
        {
15946
          ret = GLEW_IBM_static_data;
15947
          continue;
15948
        }
15949
#endif
15950
#ifdef GL_IBM_texture_mirrored_repeat
15951
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
15952
        {
15953
          ret = GLEW_IBM_texture_mirrored_repeat;
15954
          continue;
15955
        }
15956
#endif
15957
#ifdef GL_IBM_vertex_array_lists
15958
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))
15959
        {
15960
          ret = GLEW_IBM_vertex_array_lists;
15961
          continue;
15962
        }
15963
#endif
15964
      }
15965
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))
15966
      {
15967
#ifdef GL_INGR_color_clamp
15968
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))
15969
        {
15970
          ret = GLEW_INGR_color_clamp;
15971
          continue;
15972
        }
15973
#endif
15974
#ifdef GL_INGR_interlace_read
15975
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))
15976
        {
15977
          ret = GLEW_INGR_interlace_read;
15978
          continue;
15979
        }
15980
#endif
15981
      }
15982
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
15983
      {
677 janba 15984
#ifdef GL_INTEL_map_texture
15985
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_texture", 11))
15986
        {
15987
          ret = GLEW_INTEL_map_texture;
15988
          continue;
15989
        }
15990
#endif
667 khor 15991
#ifdef GL_INTEL_parallel_arrays
15992
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))
15993
        {
15994
          ret = GLEW_INTEL_parallel_arrays;
15995
          continue;
15996
        }
15997
#endif
15998
#ifdef GL_INTEL_texture_scissor
15999
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))
16000
        {
16001
          ret = GLEW_INTEL_texture_scissor;
16002
          continue;
16003
        }
16004
#endif
16005
      }
16006
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"KHR_", 4))
16007
      {
16008
#ifdef GL_KHR_debug
16009
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug", 5))
16010
        {
16011
          ret = GLEW_KHR_debug;
16012
          continue;
16013
        }
16014
#endif
16015
#ifdef GL_KHR_texture_compression_astc_ldr
16016
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_ldr", 28))
16017
        {
16018
          ret = GLEW_KHR_texture_compression_astc_ldr;
16019
          continue;
16020
        }
16021
#endif
16022
      }
16023
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))
16024
      {
16025
#ifdef GL_KTX_buffer_region
16026
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))
16027
        {
16028
          ret = GLEW_KTX_buffer_region;
16029
          continue;
16030
        }
16031
#endif
16032
      }
16033
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6))
16034
      {
16035
#ifdef GL_MESAX_texture_stack
16036
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13))
16037
        {
16038
          ret = GLEW_MESAX_texture_stack;
16039
          continue;
16040
        }
16041
#endif
16042
      }
16043
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
16044
      {
16045
#ifdef GL_MESA_pack_invert
16046
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))
16047
        {
16048
          ret = GLEW_MESA_pack_invert;
16049
          continue;
16050
        }
16051
#endif
16052
#ifdef GL_MESA_resize_buffers
16053
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))
16054
        {
16055
          ret = GLEW_MESA_resize_buffers;
16056
          continue;
16057
        }
16058
#endif
16059
#ifdef GL_MESA_window_pos
16060
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
16061
        {
16062
          ret = GLEW_MESA_window_pos;
16063
          continue;
16064
        }
16065
#endif
16066
#ifdef GL_MESA_ycbcr_texture
16067
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))
16068
        {
16069
          ret = GLEW_MESA_ycbcr_texture;
16070
          continue;
16071
        }
16072
#endif
16073
      }
16074
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NVX_", 4))
16075
      {
677 janba 16076
#ifdef GL_NVX_conditional_render
16077
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))
16078
        {
16079
          ret = GLEW_NVX_conditional_render;
16080
          continue;
16081
        }
16082
#endif
667 khor 16083
#ifdef GL_NVX_gpu_memory_info
16084
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_memory_info", 15))
16085
        {
16086
          ret = GLEW_NVX_gpu_memory_info;
16087
          continue;
16088
        }
16089
#endif
16090
      }
16091
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
16092
      {
677 janba 16093
#ifdef GL_NV_bindless_multi_draw_indirect
16094
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_multi_draw_indirect", 28))
16095
        {
16096
          ret = GLEW_NV_bindless_multi_draw_indirect;
16097
          continue;
16098
        }
16099
#endif
667 khor 16100
#ifdef GL_NV_bindless_texture
16101
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16))
16102
        {
16103
          ret = GLEW_NV_bindless_texture;
16104
          continue;
16105
        }
16106
#endif
677 janba 16107
#ifdef GL_NV_blend_equation_advanced
16108
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced", 23))
16109
        {
16110
          ret = GLEW_NV_blend_equation_advanced;
16111
          continue;
16112
        }
16113
#endif
16114
#ifdef GL_NV_blend_equation_advanced_coherent
16115
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced_coherent", 32))
16116
        {
16117
          ret = GLEW_NV_blend_equation_advanced_coherent;
16118
          continue;
16119
        }
16120
#endif
667 khor 16121
#ifdef GL_NV_blend_square
16122
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))
16123
        {
16124
          ret = GLEW_NV_blend_square;
16125
          continue;
16126
        }
16127
#endif
677 janba 16128
#ifdef GL_NV_compute_program5
16129
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_program5", 16))
16130
        {
16131
          ret = GLEW_NV_compute_program5;
16132
          continue;
16133
        }
16134
#endif
667 khor 16135
#ifdef GL_NV_conditional_render
16136
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))
16137
        {
16138
          ret = GLEW_NV_conditional_render;
16139
          continue;
16140
        }
16141
#endif
16142
#ifdef GL_NV_copy_depth_to_color
16143
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))
16144
        {
16145
          ret = GLEW_NV_copy_depth_to_color;
16146
          continue;
16147
        }
16148
#endif
16149
#ifdef GL_NV_copy_image
16150
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
16151
        {
16152
          ret = GLEW_NV_copy_image;
16153
          continue;
16154
        }
16155
#endif
677 janba 16156
#ifdef GL_NV_deep_texture3D
16157
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"deep_texture3D", 14))
16158
        {
16159
          ret = GLEW_NV_deep_texture3D;
16160
          continue;
16161
        }
16162
#endif
667 khor 16163
#ifdef GL_NV_depth_buffer_float
16164
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
16165
        {
16166
          ret = GLEW_NV_depth_buffer_float;
16167
          continue;
16168
        }
16169
#endif
16170
#ifdef GL_NV_depth_clamp
16171
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
16172
        {
16173
          ret = GLEW_NV_depth_clamp;
16174
          continue;
16175
        }
16176
#endif
16177
#ifdef GL_NV_depth_range_unclamped
16178
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21))
16179
        {
16180
          ret = GLEW_NV_depth_range_unclamped;
16181
          continue;
16182
        }
16183
#endif
677 janba 16184
#ifdef GL_NV_draw_texture
16185
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_texture", 12))
16186
        {
16187
          ret = GLEW_NV_draw_texture;
16188
          continue;
16189
        }
16190
#endif
667 khor 16191
#ifdef GL_NV_evaluators
16192
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))
16193
        {
16194
          ret = GLEW_NV_evaluators;
16195
          continue;
16196
        }
16197
#endif
16198
#ifdef GL_NV_explicit_multisample
16199
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20))
16200
        {
16201
          ret = GLEW_NV_explicit_multisample;
16202
          continue;
16203
        }
16204
#endif
16205
#ifdef GL_NV_fence
16206
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))
16207
        {
16208
          ret = GLEW_NV_fence;
16209
          continue;
16210
        }
16211
#endif
16212
#ifdef GL_NV_float_buffer
16213
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
16214
        {
16215
          ret = GLEW_NV_float_buffer;
16216
          continue;
16217
        }
16218
#endif
16219
#ifdef GL_NV_fog_distance
16220
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))
16221
        {
16222
          ret = GLEW_NV_fog_distance;
16223
          continue;
16224
        }
16225
#endif
16226
#ifdef GL_NV_fragment_program
16227
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
16228
        {
16229
          ret = GLEW_NV_fragment_program;
16230
          continue;
16231
        }
16232
#endif
16233
#ifdef GL_NV_fragment_program2
16234
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))
16235
        {
16236
          ret = GLEW_NV_fragment_program2;
16237
          continue;
16238
        }
16239
#endif
16240
#ifdef GL_NV_fragment_program4
16241
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17))
16242
        {
16243
          ret = GLEW_NV_fragment_program4;
16244
          continue;
16245
        }
16246
#endif
16247
#ifdef GL_NV_fragment_program_option
16248
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))
16249
        {
16250
          ret = GLEW_NV_fragment_program_option;
16251
          continue;
16252
        }
16253
#endif
16254
#ifdef GL_NV_framebuffer_multisample_coverage
16255
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32))
16256
        {
16257
          ret = GLEW_NV_framebuffer_multisample_coverage;
16258
          continue;
16259
        }
16260
#endif
16261
#ifdef GL_NV_geometry_program4
16262
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17))
16263
        {
16264
          ret = GLEW_NV_geometry_program4;
16265
          continue;
16266
        }
16267
#endif
16268
#ifdef GL_NV_geometry_shader4
16269
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
16270
        {
16271
          ret = GLEW_NV_geometry_shader4;
16272
          continue;
16273
        }
16274
#endif
16275
#ifdef GL_NV_gpu_program4
16276
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12))
16277
        {
16278
          ret = GLEW_NV_gpu_program4;
16279
          continue;
16280
        }
16281
#endif
16282
#ifdef GL_NV_gpu_program5
16283
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12))
16284
        {
16285
          ret = GLEW_NV_gpu_program5;
16286
          continue;
16287
        }
16288
#endif
677 janba 16289
#ifdef GL_NV_gpu_program5_mem_extended
16290
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5_mem_extended", 25))
16291
        {
16292
          ret = GLEW_NV_gpu_program5_mem_extended;
16293
          continue;
16294
        }
16295
#endif
667 khor 16296
#ifdef GL_NV_gpu_program_fp64
16297
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16))
16298
        {
16299
          ret = GLEW_NV_gpu_program_fp64;
16300
          continue;
16301
        }
16302
#endif
16303
#ifdef GL_NV_gpu_shader5
16304
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
16305
        {
16306
          ret = GLEW_NV_gpu_shader5;
16307
          continue;
16308
        }
16309
#endif
16310
#ifdef GL_NV_half_float
16311
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))
16312
        {
16313
          ret = GLEW_NV_half_float;
16314
          continue;
16315
        }
16316
#endif
16317
#ifdef GL_NV_light_max_exponent
16318
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))
16319
        {
16320
          ret = GLEW_NV_light_max_exponent;
16321
          continue;
16322
        }
16323
#endif
16324
#ifdef GL_NV_multisample_coverage
16325
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
16326
        {
16327
          ret = GLEW_NV_multisample_coverage;
16328
          continue;
16329
        }
16330
#endif
16331
#ifdef GL_NV_multisample_filter_hint
16332
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))
16333
        {
16334
          ret = GLEW_NV_multisample_filter_hint;
16335
          continue;
16336
        }
16337
#endif
16338
#ifdef GL_NV_occlusion_query
16339
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))
16340
        {
16341
          ret = GLEW_NV_occlusion_query;
16342
          continue;
16343
        }
16344
#endif
16345
#ifdef GL_NV_packed_depth_stencil
16346
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))
16347
        {
16348
          ret = GLEW_NV_packed_depth_stencil;
16349
          continue;
16350
        }
16351
#endif
16352
#ifdef GL_NV_parameter_buffer_object
16353
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23))
16354
        {
16355
          ret = GLEW_NV_parameter_buffer_object;
16356
          continue;
16357
        }
16358
#endif
16359
#ifdef GL_NV_parameter_buffer_object2
16360
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24))
16361
        {
16362
          ret = GLEW_NV_parameter_buffer_object2;
16363
          continue;
16364
        }
16365
#endif
16366
#ifdef GL_NV_path_rendering
16367
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering", 14))
16368
        {
16369
          ret = GLEW_NV_path_rendering;
16370
          continue;
16371
        }
16372
#endif
16373
#ifdef GL_NV_pixel_data_range
16374
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))
16375
        {
16376
          ret = GLEW_NV_pixel_data_range;
16377
          continue;
16378
        }
16379
#endif
16380
#ifdef GL_NV_point_sprite
16381
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))
16382
        {
16383
          ret = GLEW_NV_point_sprite;
16384
          continue;
16385
        }
16386
#endif
16387
#ifdef GL_NV_present_video
16388
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
16389
        {
16390
          ret = GLEW_NV_present_video;
16391
          continue;
16392
        }
16393
#endif
16394
#ifdef GL_NV_primitive_restart
16395
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))
16396
        {
16397
          ret = GLEW_NV_primitive_restart;
16398
          continue;
16399
        }
16400
#endif
16401
#ifdef GL_NV_register_combiners
16402
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))
16403
        {
16404
          ret = GLEW_NV_register_combiners;
16405
          continue;
16406
        }
16407
#endif
16408
#ifdef GL_NV_register_combiners2
16409
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))
16410
        {
16411
          ret = GLEW_NV_register_combiners2;
16412
          continue;
16413
        }
16414
#endif
677 janba 16415
#ifdef GL_NV_shader_atomic_counters
16416
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22))
16417
        {
16418
          ret = GLEW_NV_shader_atomic_counters;
16419
          continue;
16420
        }
16421
#endif
667 khor 16422
#ifdef GL_NV_shader_atomic_float
16423
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_float", 19))
16424
        {
16425
          ret = GLEW_NV_shader_atomic_float;
16426
          continue;
16427
        }
16428
#endif
16429
#ifdef GL_NV_shader_buffer_load
16430
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18))
16431
        {
16432
          ret = GLEW_NV_shader_buffer_load;
16433
          continue;
16434
        }
16435
#endif
677 janba 16436
#ifdef GL_NV_shader_storage_buffer_object
16437
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28))
16438
        {
16439
          ret = GLEW_NV_shader_storage_buffer_object;
16440
          continue;
16441
        }
16442
#endif
667 khor 16443
#ifdef GL_NV_tessellation_program5
16444
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21))
16445
        {
16446
          ret = GLEW_NV_tessellation_program5;
16447
          continue;
16448
        }
16449
#endif
16450
#ifdef GL_NV_texgen_emboss
16451
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))
16452
        {
16453
          ret = GLEW_NV_texgen_emboss;
16454
          continue;
16455
        }
16456
#endif
16457
#ifdef GL_NV_texgen_reflection
16458
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))
16459
        {
16460
          ret = GLEW_NV_texgen_reflection;
16461
          continue;
16462
        }
16463
#endif
16464
#ifdef GL_NV_texture_barrier
16465
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15))
16466
        {
16467
          ret = GLEW_NV_texture_barrier;
16468
          continue;
16469
        }
16470
#endif
16471
#ifdef GL_NV_texture_compression_vtc
16472
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))
16473
        {
16474
          ret = GLEW_NV_texture_compression_vtc;
16475
          continue;
16476
        }
16477
#endif
16478
#ifdef GL_NV_texture_env_combine4
16479
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))
16480
        {
16481
          ret = GLEW_NV_texture_env_combine4;
16482
          continue;
16483
        }
16484
#endif
16485
#ifdef GL_NV_texture_expand_normal
16486
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))
16487
        {
16488
          ret = GLEW_NV_texture_expand_normal;
16489
          continue;
16490
        }
16491
#endif
16492
#ifdef GL_NV_texture_multisample
16493
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
16494
        {
16495
          ret = GLEW_NV_texture_multisample;
16496
          continue;
16497
        }
16498
#endif
16499
#ifdef GL_NV_texture_rectangle
16500
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
16501
        {
16502
          ret = GLEW_NV_texture_rectangle;
16503
          continue;
16504
        }
16505
#endif
16506
#ifdef GL_NV_texture_shader
16507
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))
16508
        {
16509
          ret = GLEW_NV_texture_shader;
16510
          continue;
16511
        }
16512
#endif
16513
#ifdef GL_NV_texture_shader2
16514
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))
16515
        {
16516
          ret = GLEW_NV_texture_shader2;
16517
          continue;
16518
        }
16519
#endif
16520
#ifdef GL_NV_texture_shader3
16521
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))
16522
        {
16523
          ret = GLEW_NV_texture_shader3;
16524
          continue;
16525
        }
16526
#endif
16527
#ifdef GL_NV_transform_feedback
16528
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
16529
        {
16530
          ret = GLEW_NV_transform_feedback;
16531
          continue;
16532
        }
16533
#endif
16534
#ifdef GL_NV_transform_feedback2
16535
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
16536
        {
16537
          ret = GLEW_NV_transform_feedback2;
16538
          continue;
16539
        }
16540
#endif
16541
#ifdef GL_NV_vdpau_interop
16542
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vdpau_interop", 13))
16543
        {
16544
          ret = GLEW_NV_vdpau_interop;
16545
          continue;
16546
        }
16547
#endif
16548
#ifdef GL_NV_vertex_array_range
16549
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
16550
        {
16551
          ret = GLEW_NV_vertex_array_range;
16552
          continue;
16553
        }
16554
#endif
16555
#ifdef GL_NV_vertex_array_range2
16556
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))
16557
        {
16558
          ret = GLEW_NV_vertex_array_range2;
16559
          continue;
16560
        }
16561
#endif
16562
#ifdef GL_NV_vertex_attrib_integer_64bit
16563
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27))
16564
        {
16565
          ret = GLEW_NV_vertex_attrib_integer_64bit;
16566
          continue;
16567
        }
16568
#endif
16569
#ifdef GL_NV_vertex_buffer_unified_memory
16570
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28))
16571
        {
16572
          ret = GLEW_NV_vertex_buffer_unified_memory;
16573
          continue;
16574
        }
16575
#endif
16576
#ifdef GL_NV_vertex_program
16577
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
16578
        {
16579
          ret = GLEW_NV_vertex_program;
16580
          continue;
16581
        }
16582
#endif
16583
#ifdef GL_NV_vertex_program1_1
16584
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))
16585
        {
16586
          ret = GLEW_NV_vertex_program1_1;
16587
          continue;
16588
        }
16589
#endif
16590
#ifdef GL_NV_vertex_program2
16591
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))
16592
        {
16593
          ret = GLEW_NV_vertex_program2;
16594
          continue;
16595
        }
16596
#endif
16597
#ifdef GL_NV_vertex_program2_option
16598
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))
16599
        {
16600
          ret = GLEW_NV_vertex_program2_option;
16601
          continue;
16602
        }
16603
#endif
16604
#ifdef GL_NV_vertex_program3
16605
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))
16606
        {
16607
          ret = GLEW_NV_vertex_program3;
16608
          continue;
16609
        }
16610
#endif
16611
#ifdef GL_NV_vertex_program4
16612
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15))
16613
        {
16614
          ret = GLEW_NV_vertex_program4;
16615
          continue;
16616
        }
16617
#endif
16618
#ifdef GL_NV_video_capture
16619
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
16620
        {
16621
          ret = GLEW_NV_video_capture;
16622
          continue;
16623
        }
16624
#endif
16625
      }
16626
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4))
16627
      {
16628
#ifdef GL_OES_byte_coordinates
16629
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16))
16630
        {
16631
          ret = GLEW_OES_byte_coordinates;
16632
          continue;
16633
        }
16634
#endif
16635
#ifdef GL_OES_compressed_paletted_texture
16636
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27))
16637
        {
16638
          ret = GLEW_OES_compressed_paletted_texture;
16639
          continue;
16640
        }
16641
#endif
16642
#ifdef GL_OES_read_format
16643
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11))
16644
        {
16645
          ret = GLEW_OES_read_format;
16646
          continue;
16647
        }
16648
#endif
16649
#ifdef GL_OES_single_precision
16650
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16))
16651
        {
16652
          ret = GLEW_OES_single_precision;
16653
          continue;
16654
        }
16655
#endif
16656
      }
16657
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
16658
      {
16659
#ifdef GL_OML_interlace
16660
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))
16661
        {
16662
          ret = GLEW_OML_interlace;
16663
          continue;
16664
        }
16665
#endif
16666
#ifdef GL_OML_resample
16667
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))
16668
        {
16669
          ret = GLEW_OML_resample;
16670
          continue;
16671
        }
16672
#endif
16673
#ifdef GL_OML_subsample
16674
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))
16675
        {
16676
          ret = GLEW_OML_subsample;
16677
          continue;
16678
        }
16679
#endif
16680
      }
16681
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))
16682
      {
16683
#ifdef GL_PGI_misc_hints
16684
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))
16685
        {
16686
          ret = GLEW_PGI_misc_hints;
16687
          continue;
16688
        }
16689
#endif
16690
#ifdef GL_PGI_vertex_hints
16691
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))
16692
        {
16693
          ret = GLEW_PGI_vertex_hints;
16694
          continue;
16695
        }
16696
#endif
16697
      }
16698
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6))
16699
      {
677 janba 16700
#ifdef GL_REGAL_ES1_0_compatibility
16701
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES1_0_compatibility", 19))
16702
        {
16703
          ret = GLEW_REGAL_ES1_0_compatibility;
16704
          continue;
16705
        }
16706
#endif
16707
#ifdef GL_REGAL_ES1_1_compatibility
16708
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES1_1_compatibility", 19))
16709
        {
16710
          ret = GLEW_REGAL_ES1_1_compatibility;
16711
          continue;
16712
        }
16713
#endif
16714
#ifdef GL_REGAL_enable
16715
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"enable", 6))
16716
        {
16717
          ret = GLEW_REGAL_enable;
16718
          continue;
16719
        }
16720
#endif
667 khor 16721
#ifdef GL_REGAL_error_string
16722
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"error_string", 12))
16723
        {
16724
          ret = GLEW_REGAL_error_string;
16725
          continue;
16726
        }
16727
#endif
16728
#ifdef GL_REGAL_extension_query
16729
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"extension_query", 15))
16730
        {
16731
          ret = GLEW_REGAL_extension_query;
16732
          continue;
16733
        }
16734
#endif
16735
#ifdef GL_REGAL_log
16736
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"log", 3))
16737
        {
16738
          ret = GLEW_REGAL_log;
16739
          continue;
16740
        }
16741
#endif
16742
      }
16743
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))
16744
      {
16745
#ifdef GL_REND_screen_coordinates
16746
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))
16747
        {
16748
          ret = GLEW_REND_screen_coordinates;
16749
          continue;
16750
        }
16751
#endif
16752
      }
16753
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))
16754
      {
16755
#ifdef GL_S3_s3tc
16756
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))
16757
        {
16758
          ret = GLEW_S3_s3tc;
16759
          continue;
16760
        }
16761
#endif
16762
      }
16763
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))
16764
      {
16765
#ifdef GL_SGIS_color_range
16766
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))
16767
        {
16768
          ret = GLEW_SGIS_color_range;
16769
          continue;
16770
        }
16771
#endif
16772
#ifdef GL_SGIS_detail_texture
16773
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))
16774
        {
16775
          ret = GLEW_SGIS_detail_texture;
16776
          continue;
16777
        }
16778
#endif
16779
#ifdef GL_SGIS_fog_function
16780
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))
16781
        {
16782
          ret = GLEW_SGIS_fog_function;
16783
          continue;
16784
        }
16785
#endif
16786
#ifdef GL_SGIS_generate_mipmap
16787
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))
16788
        {
16789
          ret = GLEW_SGIS_generate_mipmap;
16790
          continue;
16791
        }
16792
#endif
16793
#ifdef GL_SGIS_multisample
16794
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
16795
        {
16796
          ret = GLEW_SGIS_multisample;
16797
          continue;
16798
        }
16799
#endif
16800
#ifdef GL_SGIS_pixel_texture
16801
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))
16802
        {
16803
          ret = GLEW_SGIS_pixel_texture;
16804
          continue;
16805
        }
16806
#endif
16807
#ifdef GL_SGIS_point_line_texgen
16808
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17))
16809
        {
16810
          ret = GLEW_SGIS_point_line_texgen;
16811
          continue;
16812
        }
16813
#endif
16814
#ifdef GL_SGIS_sharpen_texture
16815
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))
16816
        {
16817
          ret = GLEW_SGIS_sharpen_texture;
16818
          continue;
16819
        }
16820
#endif
16821
#ifdef GL_SGIS_texture4D
16822
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))
16823
        {
16824
          ret = GLEW_SGIS_texture4D;
16825
          continue;
16826
        }
16827
#endif
16828
#ifdef GL_SGIS_texture_border_clamp
16829
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
16830
        {
16831
          ret = GLEW_SGIS_texture_border_clamp;
16832
          continue;
16833
        }
16834
#endif
16835
#ifdef GL_SGIS_texture_edge_clamp
16836
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))
16837
        {
16838
          ret = GLEW_SGIS_texture_edge_clamp;
16839
          continue;
16840
        }
16841
#endif
16842
#ifdef GL_SGIS_texture_filter4
16843
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))
16844
        {
16845
          ret = GLEW_SGIS_texture_filter4;
16846
          continue;
16847
        }
16848
#endif
16849
#ifdef GL_SGIS_texture_lod
16850
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))
16851
        {
16852
          ret = GLEW_SGIS_texture_lod;
16853
          continue;
16854
        }
16855
#endif
16856
#ifdef GL_SGIS_texture_select
16857
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))
16858
        {
16859
          ret = GLEW_SGIS_texture_select;
16860
          continue;
16861
        }
16862
#endif
16863
      }
16864
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))
16865
      {
16866
#ifdef GL_SGIX_async
16867
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))
16868
        {
16869
          ret = GLEW_SGIX_async;
16870
          continue;
16871
        }
16872
#endif
16873
#ifdef GL_SGIX_async_histogram
16874
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))
16875
        {
16876
          ret = GLEW_SGIX_async_histogram;
16877
          continue;
16878
        }
16879
#endif
16880
#ifdef GL_SGIX_async_pixel
16881
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))
16882
        {
16883
          ret = GLEW_SGIX_async_pixel;
16884
          continue;
16885
        }
16886
#endif
16887
#ifdef GL_SGIX_blend_alpha_minmax
16888
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))
16889
        {
16890
          ret = GLEW_SGIX_blend_alpha_minmax;
16891
          continue;
16892
        }
16893
#endif
16894
#ifdef GL_SGIX_clipmap
16895
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))
16896
        {
16897
          ret = GLEW_SGIX_clipmap;
16898
          continue;
16899
        }
16900
#endif
16901
#ifdef GL_SGIX_convolution_accuracy
16902
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20))
16903
        {
16904
          ret = GLEW_SGIX_convolution_accuracy;
16905
          continue;
16906
        }
16907
#endif
16908
#ifdef GL_SGIX_depth_texture
16909
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
16910
        {
16911
          ret = GLEW_SGIX_depth_texture;
16912
          continue;
16913
        }
16914
#endif
16915
#ifdef GL_SGIX_flush_raster
16916
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))
16917
        {
16918
          ret = GLEW_SGIX_flush_raster;
16919
          continue;
16920
        }
16921
#endif
16922
#ifdef GL_SGIX_fog_offset
16923
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))
16924
        {
16925
          ret = GLEW_SGIX_fog_offset;
16926
          continue;
16927
        }
16928
#endif
16929
#ifdef GL_SGIX_fog_texture
16930
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))
16931
        {
16932
          ret = GLEW_SGIX_fog_texture;
16933
          continue;
16934
        }
16935
#endif
16936
#ifdef GL_SGIX_fragment_specular_lighting
16937
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))
16938
        {
16939
          ret = GLEW_SGIX_fragment_specular_lighting;
16940
          continue;
16941
        }
16942
#endif
16943
#ifdef GL_SGIX_framezoom
16944
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))
16945
        {
16946
          ret = GLEW_SGIX_framezoom;
16947
          continue;
16948
        }
16949
#endif
16950
#ifdef GL_SGIX_interlace
16951
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))
16952
        {
16953
          ret = GLEW_SGIX_interlace;
16954
          continue;
16955
        }
16956
#endif
16957
#ifdef GL_SGIX_ir_instrument1
16958
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))
16959
        {
16960
          ret = GLEW_SGIX_ir_instrument1;
16961
          continue;
16962
        }
16963
#endif
16964
#ifdef GL_SGIX_list_priority
16965
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))
16966
        {
16967
          ret = GLEW_SGIX_list_priority;
16968
          continue;
16969
        }
16970
#endif
16971
#ifdef GL_SGIX_pixel_texture
16972
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))
16973
        {
16974
          ret = GLEW_SGIX_pixel_texture;
16975
          continue;
16976
        }
16977
#endif
16978
#ifdef GL_SGIX_pixel_texture_bits
16979
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))
16980
        {
16981
          ret = GLEW_SGIX_pixel_texture_bits;
16982
          continue;
16983
        }
16984
#endif
16985
#ifdef GL_SGIX_reference_plane
16986
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))
16987
        {
16988
          ret = GLEW_SGIX_reference_plane;
16989
          continue;
16990
        }
16991
#endif
16992
#ifdef GL_SGIX_resample
16993
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))
16994
        {
16995
          ret = GLEW_SGIX_resample;
16996
          continue;
16997
        }
16998
#endif
16999
#ifdef GL_SGIX_shadow
17000
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
17001
        {
17002
          ret = GLEW_SGIX_shadow;
17003
          continue;
17004
        }
17005
#endif
17006
#ifdef GL_SGIX_shadow_ambient
17007
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))
17008
        {
17009
          ret = GLEW_SGIX_shadow_ambient;
17010
          continue;
17011
        }
17012
#endif
17013
#ifdef GL_SGIX_sprite
17014
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))
17015
        {
17016
          ret = GLEW_SGIX_sprite;
17017
          continue;
17018
        }
17019
#endif
17020
#ifdef GL_SGIX_tag_sample_buffer
17021
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))
17022
        {
17023
          ret = GLEW_SGIX_tag_sample_buffer;
17024
          continue;
17025
        }
17026
#endif
17027
#ifdef GL_SGIX_texture_add_env
17028
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))
17029
        {
17030
          ret = GLEW_SGIX_texture_add_env;
17031
          continue;
17032
        }
17033
#endif
17034
#ifdef GL_SGIX_texture_coordinate_clamp
17035
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))
17036
        {
17037
          ret = GLEW_SGIX_texture_coordinate_clamp;
17038
          continue;
17039
        }
17040
#endif
17041
#ifdef GL_SGIX_texture_lod_bias
17042
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
17043
        {
17044
          ret = GLEW_SGIX_texture_lod_bias;
17045
          continue;
17046
        }
17047
#endif
17048
#ifdef GL_SGIX_texture_multi_buffer
17049
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))
17050
        {
17051
          ret = GLEW_SGIX_texture_multi_buffer;
17052
          continue;
17053
        }
17054
#endif
17055
#ifdef GL_SGIX_texture_range
17056
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))
17057
        {
17058
          ret = GLEW_SGIX_texture_range;
17059
          continue;
17060
        }
17061
#endif
17062
#ifdef GL_SGIX_texture_scale_bias
17063
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))
17064
        {
17065
          ret = GLEW_SGIX_texture_scale_bias;
17066
          continue;
17067
        }
17068
#endif
17069
#ifdef GL_SGIX_vertex_preclip
17070
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))
17071
        {
17072
          ret = GLEW_SGIX_vertex_preclip;
17073
          continue;
17074
        }
17075
#endif
17076
#ifdef GL_SGIX_vertex_preclip_hint
17077
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))
17078
        {
17079
          ret = GLEW_SGIX_vertex_preclip_hint;
17080
          continue;
17081
        }
17082
#endif
17083
#ifdef GL_SGIX_ycrcb
17084
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))
17085
        {
17086
          ret = GLEW_SGIX_ycrcb;
17087
          continue;
17088
        }
17089
#endif
17090
      }
17091
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))
17092
      {
17093
#ifdef GL_SGI_color_matrix
17094
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))
17095
        {
17096
          ret = GLEW_SGI_color_matrix;
17097
          continue;
17098
        }
17099
#endif
17100
#ifdef GL_SGI_color_table
17101
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))
17102
        {
17103
          ret = GLEW_SGI_color_table;
17104
          continue;
17105
        }
17106
#endif
17107
#ifdef GL_SGI_texture_color_table
17108
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))
17109
        {
17110
          ret = GLEW_SGI_texture_color_table;
17111
          continue;
17112
        }
17113
#endif
17114
      }
17115
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))
17116
      {
17117
#ifdef GL_SUNX_constant_data
17118
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))
17119
        {
17120
          ret = GLEW_SUNX_constant_data;
17121
          continue;
17122
        }
17123
#endif
17124
      }
17125
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))
17126
      {
17127
#ifdef GL_SUN_convolution_border_modes
17128
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))
17129
        {
17130
          ret = GLEW_SUN_convolution_border_modes;
17131
          continue;
17132
        }
17133
#endif
17134
#ifdef GL_SUN_global_alpha
17135
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))
17136
        {
17137
          ret = GLEW_SUN_global_alpha;
17138
          continue;
17139
        }
17140
#endif
17141
#ifdef GL_SUN_mesh_array
17142
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))
17143
        {
17144
          ret = GLEW_SUN_mesh_array;
17145
          continue;
17146
        }
17147
#endif
17148
#ifdef GL_SUN_read_video_pixels
17149
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))
17150
        {
17151
          ret = GLEW_SUN_read_video_pixels;
17152
          continue;
17153
        }
17154
#endif
17155
#ifdef GL_SUN_slice_accum
17156
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))
17157
        {
17158
          ret = GLEW_SUN_slice_accum;
17159
          continue;
17160
        }
17161
#endif
17162
#ifdef GL_SUN_triangle_list
17163
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))
17164
        {
17165
          ret = GLEW_SUN_triangle_list;
17166
          continue;
17167
        }
17168
#endif
17169
#ifdef GL_SUN_vertex
17170
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))
17171
        {
17172
          ret = GLEW_SUN_vertex;
17173
          continue;
17174
        }
17175
#endif
17176
      }
17177
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))
17178
      {
17179
#ifdef GL_WIN_phong_shading
17180
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))
17181
        {
17182
          ret = GLEW_WIN_phong_shading;
17183
          continue;
17184
        }
17185
#endif
17186
#ifdef GL_WIN_specular_fog
17187
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))
17188
        {
17189
          ret = GLEW_WIN_specular_fog;
17190
          continue;
17191
        }
17192
#endif
17193
#ifdef GL_WIN_swap_hint
17194
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))
17195
        {
17196
          ret = GLEW_WIN_swap_hint;
17197
          continue;
17198
        }
17199
#endif
17200
      }
17201
    }
17202
    ret = (len == 0);
17203
  }
17204
  return ret;
17205
}
17206
 
17207
#if defined(_WIN32)
17208
 
17209
#if defined(GLEW_MX)
17210
GLboolean GLEWAPIENTRY wglewContextIsSupported (const WGLEWContext* ctx, const char* name)
17211
#else
17212
GLboolean GLEWAPIENTRY wglewIsSupported (const char* name)
17213
#endif
17214
{
17215
  GLubyte* pos = (GLubyte*)name;
17216
  GLuint len = _glewStrLen(pos);
17217
  GLboolean ret = GL_TRUE;
17218
  while (ret && len > 0)
17219
  {
17220
    if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))
17221
    {
17222
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
17223
      {
17224
#ifdef WGL_3DFX_multisample
17225
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
17226
        {
17227
          ret = WGLEW_3DFX_multisample;
17228
          continue;
17229
        }
17230
#endif
17231
      }
17232
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4))
17233
      {
17234
#ifdef WGL_3DL_stereo_control
17235
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14))
17236
        {
17237
          ret = WGLEW_3DL_stereo_control;
17238
          continue;
17239
        }
17240
#endif
17241
      }
17242
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
17243
      {
17244
#ifdef WGL_AMD_gpu_association
17245
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
17246
        {
17247
          ret = WGLEW_AMD_gpu_association;
17248
          continue;
17249
        }
17250
#endif
17251
      }
17252
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
17253
      {
17254
#ifdef WGL_ARB_buffer_region
17255
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))
17256
        {
17257
          ret = WGLEW_ARB_buffer_region;
17258
          continue;
17259
        }
17260
#endif
17261
#ifdef WGL_ARB_create_context
17262
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))
17263
        {
17264
          ret = WGLEW_ARB_create_context;
17265
          continue;
17266
        }
17267
#endif
17268
#ifdef WGL_ARB_create_context_profile
17269
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
17270
        {
17271
          ret = WGLEW_ARB_create_context_profile;
17272
          continue;
17273
        }
17274
#endif
17275
#ifdef WGL_ARB_create_context_robustness
17276
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
17277
        {
17278
          ret = WGLEW_ARB_create_context_robustness;
17279
          continue;
17280
        }
17281
#endif
17282
#ifdef WGL_ARB_extensions_string
17283
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
17284
        {
17285
          ret = WGLEW_ARB_extensions_string;
17286
          continue;
17287
        }
17288
#endif
17289
#ifdef WGL_ARB_framebuffer_sRGB
17290
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
17291
        {
17292
          ret = WGLEW_ARB_framebuffer_sRGB;
17293
          continue;
17294
        }
17295
#endif
17296
#ifdef WGL_ARB_make_current_read
17297
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
17298
        {
17299
          ret = WGLEW_ARB_make_current_read;
17300
          continue;
17301
        }
17302
#endif
17303
#ifdef WGL_ARB_multisample
17304
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
17305
        {
17306
          ret = WGLEW_ARB_multisample;
17307
          continue;
17308
        }
17309
#endif
17310
#ifdef WGL_ARB_pbuffer
17311
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
17312
        {
17313
          ret = WGLEW_ARB_pbuffer;
17314
          continue;
17315
        }
17316
#endif
17317
#ifdef WGL_ARB_pixel_format
17318
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))
17319
        {
17320
          ret = WGLEW_ARB_pixel_format;
17321
          continue;
17322
        }
17323
#endif
17324
#ifdef WGL_ARB_pixel_format_float
17325
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
17326
        {
17327
          ret = WGLEW_ARB_pixel_format_float;
17328
          continue;
17329
        }
17330
#endif
17331
#ifdef WGL_ARB_render_texture
17332
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))
17333
        {
17334
          ret = WGLEW_ARB_render_texture;
17335
          continue;
17336
        }
17337
#endif
677 janba 17338
#ifdef WGL_ARB_robustness_application_isolation
17339
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))
17340
        {
17341
          ret = WGLEW_ARB_robustness_application_isolation;
17342
          continue;
17343
        }
17344
#endif
17345
#ifdef WGL_ARB_robustness_share_group_isolation
17346
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))
17347
        {
17348
          ret = WGLEW_ARB_robustness_share_group_isolation;
17349
          continue;
17350
        }
17351
#endif
667 khor 17352
      }
17353
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
17354
      {
17355
#ifdef WGL_ATI_pixel_format_float
17356
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
17357
        {
17358
          ret = WGLEW_ATI_pixel_format_float;
17359
          continue;
17360
        }
17361
#endif
17362
#ifdef WGL_ATI_render_texture_rectangle
17363
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))
17364
        {
17365
          ret = WGLEW_ATI_render_texture_rectangle;
17366
          continue;
17367
        }
17368
#endif
17369
      }
17370
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
17371
      {
17372
#ifdef WGL_EXT_create_context_es2_profile
17373
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))
17374
        {
17375
          ret = WGLEW_EXT_create_context_es2_profile;
17376
          continue;
17377
        }
17378
#endif
17379
#ifdef WGL_EXT_create_context_es_profile
17380
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25))
17381
        {
17382
          ret = WGLEW_EXT_create_context_es_profile;
17383
          continue;
17384
        }
17385
#endif
17386
#ifdef WGL_EXT_depth_float
17387
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))
17388
        {
17389
          ret = WGLEW_EXT_depth_float;
17390
          continue;
17391
        }
17392
#endif
17393
#ifdef WGL_EXT_display_color_table
17394
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))
17395
        {
17396
          ret = WGLEW_EXT_display_color_table;
17397
          continue;
17398
        }
17399
#endif
17400
#ifdef WGL_EXT_extensions_string
17401
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
17402
        {
17403
          ret = WGLEW_EXT_extensions_string;
17404
          continue;
17405
        }
17406
#endif
17407
#ifdef WGL_EXT_framebuffer_sRGB
17408
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
17409
        {
17410
          ret = WGLEW_EXT_framebuffer_sRGB;
17411
          continue;
17412
        }
17413
#endif
17414
#ifdef WGL_EXT_make_current_read
17415
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
17416
        {
17417
          ret = WGLEW_EXT_make_current_read;
17418
          continue;
17419
        }
17420
#endif
17421
#ifdef WGL_EXT_multisample
17422
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
17423
        {
17424
          ret = WGLEW_EXT_multisample;
17425
          continue;
17426
        }
17427
#endif
17428
#ifdef WGL_EXT_pbuffer
17429
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
17430
        {
17431
          ret = WGLEW_EXT_pbuffer;
17432
          continue;
17433
        }
17434
#endif
17435
#ifdef WGL_EXT_pixel_format
17436
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))
17437
        {
17438
          ret = WGLEW_EXT_pixel_format;
17439
          continue;
17440
        }
17441
#endif
17442
#ifdef WGL_EXT_pixel_format_packed_float
17443
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25))
17444
        {
17445
          ret = WGLEW_EXT_pixel_format_packed_float;
17446
          continue;
17447
        }
17448
#endif
17449
#ifdef WGL_EXT_swap_control
17450
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
17451
        {
17452
          ret = WGLEW_EXT_swap_control;
17453
          continue;
17454
        }
17455
#endif
17456
#ifdef WGL_EXT_swap_control_tear
17457
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17))
17458
        {
17459
          ret = WGLEW_EXT_swap_control_tear;
17460
          continue;
17461
        }
17462
#endif
17463
      }
17464
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))
17465
      {
17466
#ifdef WGL_I3D_digital_video_control
17467
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))
17468
        {
17469
          ret = WGLEW_I3D_digital_video_control;
17470
          continue;
17471
        }
17472
#endif
17473
#ifdef WGL_I3D_gamma
17474
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))
17475
        {
17476
          ret = WGLEW_I3D_gamma;
17477
          continue;
17478
        }
17479
#endif
17480
#ifdef WGL_I3D_genlock
17481
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))
17482
        {
17483
          ret = WGLEW_I3D_genlock;
17484
          continue;
17485
        }
17486
#endif
17487
#ifdef WGL_I3D_image_buffer
17488
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))
17489
        {
17490
          ret = WGLEW_I3D_image_buffer;
17491
          continue;
17492
        }
17493
#endif
17494
#ifdef WGL_I3D_swap_frame_lock
17495
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))
17496
        {
17497
          ret = WGLEW_I3D_swap_frame_lock;
17498
          continue;
17499
        }
17500
#endif
17501
#ifdef WGL_I3D_swap_frame_usage
17502
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))
17503
        {
17504
          ret = WGLEW_I3D_swap_frame_usage;
17505
          continue;
17506
        }
17507
#endif
17508
      }
17509
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
17510
      {
17511
#ifdef WGL_NV_DX_interop
17512
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop", 10))
17513
        {
17514
          ret = WGLEW_NV_DX_interop;
17515
          continue;
17516
        }
17517
#endif
17518
#ifdef WGL_NV_DX_interop2
17519
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop2", 11))
17520
        {
17521
          ret = WGLEW_NV_DX_interop2;
17522
          continue;
17523
        }
17524
#endif
17525
#ifdef WGL_NV_copy_image
17526
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
17527
        {
17528
          ret = WGLEW_NV_copy_image;
17529
          continue;
17530
        }
17531
#endif
17532
#ifdef WGL_NV_float_buffer
17533
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
17534
        {
17535
          ret = WGLEW_NV_float_buffer;
17536
          continue;
17537
        }
17538
#endif
17539
#ifdef WGL_NV_gpu_affinity
17540
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12))
17541
        {
17542
          ret = WGLEW_NV_gpu_affinity;
17543
          continue;
17544
        }
17545
#endif
17546
#ifdef WGL_NV_multisample_coverage
17547
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
17548
        {
17549
          ret = WGLEW_NV_multisample_coverage;
17550
          continue;
17551
        }
17552
#endif
17553
#ifdef WGL_NV_present_video
17554
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
17555
        {
17556
          ret = WGLEW_NV_present_video;
17557
          continue;
17558
        }
17559
#endif
17560
#ifdef WGL_NV_render_depth_texture
17561
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))
17562
        {
17563
          ret = WGLEW_NV_render_depth_texture;
17564
          continue;
17565
        }
17566
#endif
17567
#ifdef WGL_NV_render_texture_rectangle
17568
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))
17569
        {
17570
          ret = WGLEW_NV_render_texture_rectangle;
17571
          continue;
17572
        }
17573
#endif
17574
#ifdef WGL_NV_swap_group
17575
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
17576
        {
17577
          ret = WGLEW_NV_swap_group;
17578
          continue;
17579
        }
17580
#endif
17581
#ifdef WGL_NV_vertex_array_range
17582
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
17583
        {
17584
          ret = WGLEW_NV_vertex_array_range;
17585
          continue;
17586
        }
17587
#endif
17588
#ifdef WGL_NV_video_capture
17589
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
17590
        {
17591
          ret = WGLEW_NV_video_capture;
17592
          continue;
17593
        }
17594
#endif
17595
#ifdef WGL_NV_video_output
17596
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))
17597
        {
17598
          ret = WGLEW_NV_video_output;
17599
          continue;
17600
        }
17601
#endif
17602
      }
17603
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
17604
      {
17605
#ifdef WGL_OML_sync_control
17606
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))
17607
        {
17608
          ret = WGLEW_OML_sync_control;
17609
          continue;
17610
        }
17611
#endif
17612
      }
17613
    }
17614
    ret = (len == 0);
17615
  }
17616
  return ret;
17617
}
17618
 
677 janba 17619
#elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
667 khor 17620
 
17621
#if defined(GLEW_MX)
17622
GLboolean glxewContextIsSupported (const GLXEWContext* ctx, const char* name)
17623
#else
17624
GLboolean glxewIsSupported (const char* name)
17625
#endif
17626
{
17627
  GLubyte* pos = (GLubyte*)name;
17628
  GLuint len = _glewStrLen(pos);
17629
  GLboolean ret = GL_TRUE;
17630
  while (ret && len > 0)
17631
  {
17632
    if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))
17633
    {
17634
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))
17635
      {
17636
#ifdef GLX_VERSION_1_2
17637
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))
17638
        {
17639
          ret = GLXEW_VERSION_1_2;
17640
          continue;
17641
        }
17642
#endif
17643
#ifdef GLX_VERSION_1_3
17644
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))
17645
        {
17646
          ret = GLXEW_VERSION_1_3;
17647
          continue;
17648
        }
17649
#endif
17650
#ifdef GLX_VERSION_1_4
17651
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))
17652
        {
17653
          ret = GLXEW_VERSION_1_4;
17654
          continue;
17655
        }
17656
#endif
17657
      }
17658
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
17659
      {
17660
#ifdef GLX_3DFX_multisample
17661
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
17662
        {
17663
          ret = GLXEW_3DFX_multisample;
17664
          continue;
17665
        }
17666
#endif
17667
      }
17668
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
17669
      {
17670
#ifdef GLX_AMD_gpu_association
17671
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
17672
        {
17673
          ret = GLXEW_AMD_gpu_association;
17674
          continue;
17675
        }
17676
#endif
17677
      }
17678
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
17679
      {
17680
#ifdef GLX_ARB_create_context
17681
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))
17682
        {
17683
          ret = GLXEW_ARB_create_context;
17684
          continue;
17685
        }
17686
#endif
17687
#ifdef GLX_ARB_create_context_profile
17688
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
17689
        {
17690
          ret = GLXEW_ARB_create_context_profile;
17691
          continue;
17692
        }
17693
#endif
17694
#ifdef GLX_ARB_create_context_robustness
17695
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
17696
        {
17697
          ret = GLXEW_ARB_create_context_robustness;
17698
          continue;
17699
        }
17700
#endif
17701
#ifdef GLX_ARB_fbconfig_float
17702
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))
17703
        {
17704
          ret = GLXEW_ARB_fbconfig_float;
17705
          continue;
17706
        }
17707
#endif
17708
#ifdef GLX_ARB_framebuffer_sRGB
17709
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
17710
        {
17711
          ret = GLXEW_ARB_framebuffer_sRGB;
17712
          continue;
17713
        }
17714
#endif
17715
#ifdef GLX_ARB_get_proc_address
17716
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))
17717
        {
17718
          ret = GLXEW_ARB_get_proc_address;
17719
          continue;
17720
        }
17721
#endif
17722
#ifdef GLX_ARB_multisample
17723
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
17724
        {
17725
          ret = GLXEW_ARB_multisample;
17726
          continue;
17727
        }
17728
#endif
17729
#ifdef GLX_ARB_robustness_application_isolation
17730
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))
17731
        {
17732
          ret = GLXEW_ARB_robustness_application_isolation;
17733
          continue;
17734
        }
17735
#endif
17736
#ifdef GLX_ARB_robustness_share_group_isolation
17737
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))
17738
        {
17739
          ret = GLXEW_ARB_robustness_share_group_isolation;
17740
          continue;
17741
        }
17742
#endif
17743
#ifdef GLX_ARB_vertex_buffer_object
17744
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
17745
        {
17746
          ret = GLXEW_ARB_vertex_buffer_object;
17747
          continue;
17748
        }
17749
#endif
17750
      }
17751
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
17752
      {
17753
#ifdef GLX_ATI_pixel_format_float
17754
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
17755
        {
17756
          ret = GLXEW_ATI_pixel_format_float;
17757
          continue;
17758
        }
17759
#endif
17760
#ifdef GLX_ATI_render_texture
17761
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))
17762
        {
17763
          ret = GLXEW_ATI_render_texture;
17764
          continue;
17765
        }
17766
#endif
17767
      }
17768
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
17769
      {
677 janba 17770
#ifdef GLX_EXT_buffer_age
17771
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_age", 10))
17772
        {
17773
          ret = GLXEW_EXT_buffer_age;
17774
          continue;
17775
        }
17776
#endif
667 khor 17777
#ifdef GLX_EXT_create_context_es2_profile
17778
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))
17779
        {
17780
          ret = GLXEW_EXT_create_context_es2_profile;
17781
          continue;
17782
        }
17783
#endif
17784
#ifdef GLX_EXT_create_context_es_profile
17785
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25))
17786
        {
17787
          ret = GLXEW_EXT_create_context_es_profile;
17788
          continue;
17789
        }
17790
#endif
17791
#ifdef GLX_EXT_fbconfig_packed_float
17792
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21))
17793
        {
17794
          ret = GLXEW_EXT_fbconfig_packed_float;
17795
          continue;
17796
        }
17797
#endif
17798
#ifdef GLX_EXT_framebuffer_sRGB
17799
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
17800
        {
17801
          ret = GLXEW_EXT_framebuffer_sRGB;
17802
          continue;
17803
        }
17804
#endif
17805
#ifdef GLX_EXT_import_context
17806
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))
17807
        {
17808
          ret = GLXEW_EXT_import_context;
17809
          continue;
17810
        }
17811
#endif
17812
#ifdef GLX_EXT_scene_marker
17813
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))
17814
        {
17815
          ret = GLXEW_EXT_scene_marker;
17816
          continue;
17817
        }
17818
#endif
17819
#ifdef GLX_EXT_swap_control
17820
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
17821
        {
17822
          ret = GLXEW_EXT_swap_control;
17823
          continue;
17824
        }
17825
#endif
17826
#ifdef GLX_EXT_swap_control_tear
17827
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17))
17828
        {
17829
          ret = GLXEW_EXT_swap_control_tear;
17830
          continue;
17831
        }
17832
#endif
17833
#ifdef GLX_EXT_texture_from_pixmap
17834
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))
17835
        {
17836
          ret = GLXEW_EXT_texture_from_pixmap;
17837
          continue;
17838
        }
17839
#endif
17840
#ifdef GLX_EXT_visual_info
17841
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))
17842
        {
17843
          ret = GLXEW_EXT_visual_info;
17844
          continue;
17845
        }
17846
#endif
17847
#ifdef GLX_EXT_visual_rating
17848
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))
17849
        {
17850
          ret = GLXEW_EXT_visual_rating;
17851
          continue;
17852
        }
17853
#endif
17854
      }
17855
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
17856
      {
17857
#ifdef GLX_INTEL_swap_event
17858
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10))
17859
        {
17860
          ret = GLXEW_INTEL_swap_event;
17861
          continue;
17862
        }
17863
#endif
17864
      }
17865
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
17866
      {
17867
#ifdef GLX_MESA_agp_offset
17868
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))
17869
        {
17870
          ret = GLXEW_MESA_agp_offset;
17871
          continue;
17872
        }
17873
#endif
17874
#ifdef GLX_MESA_copy_sub_buffer
17875
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))
17876
        {
17877
          ret = GLXEW_MESA_copy_sub_buffer;
17878
          continue;
17879
        }
17880
#endif
17881
#ifdef GLX_MESA_pixmap_colormap
17882
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))
17883
        {
17884
          ret = GLXEW_MESA_pixmap_colormap;
17885
          continue;
17886
        }
17887
#endif
17888
#ifdef GLX_MESA_release_buffers
17889
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))
17890
        {
17891
          ret = GLXEW_MESA_release_buffers;
17892
          continue;
17893
        }
17894
#endif
17895
#ifdef GLX_MESA_set_3dfx_mode
17896
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))
17897
        {
17898
          ret = GLXEW_MESA_set_3dfx_mode;
17899
          continue;
17900
        }
17901
#endif
17902
#ifdef GLX_MESA_swap_control
17903
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
17904
        {
17905
          ret = GLXEW_MESA_swap_control;
17906
          continue;
17907
        }
17908
#endif
17909
      }
17910
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
17911
      {
17912
#ifdef GLX_NV_copy_image
17913
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
17914
        {
17915
          ret = GLXEW_NV_copy_image;
17916
          continue;
17917
        }
17918
#endif
17919
#ifdef GLX_NV_float_buffer
17920
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
17921
        {
17922
          ret = GLXEW_NV_float_buffer;
17923
          continue;
17924
        }
17925
#endif
17926
#ifdef GLX_NV_multisample_coverage
17927
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
17928
        {
17929
          ret = GLXEW_NV_multisample_coverage;
17930
          continue;
17931
        }
17932
#endif
17933
#ifdef GLX_NV_present_video
17934
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
17935
        {
17936
          ret = GLXEW_NV_present_video;
17937
          continue;
17938
        }
17939
#endif
17940
#ifdef GLX_NV_swap_group
17941
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
17942
        {
17943
          ret = GLXEW_NV_swap_group;
17944
          continue;
17945
        }
17946
#endif
17947
#ifdef GLX_NV_vertex_array_range
17948
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
17949
        {
17950
          ret = GLXEW_NV_vertex_array_range;
17951
          continue;
17952
        }
17953
#endif
17954
#ifdef GLX_NV_video_capture
17955
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
17956
        {
17957
          ret = GLXEW_NV_video_capture;
17958
          continue;
17959
        }
17960
#endif
677 janba 17961
#ifdef GLX_NV_video_output
17962
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))
667 khor 17963
        {
677 janba 17964
          ret = GLXEW_NV_video_output;
667 khor 17965
          continue;
17966
        }
17967
#endif
17968
      }
17969
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
17970
      {
17971
#ifdef GLX_OML_swap_method
17972
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))
17973
        {
17974
          ret = GLXEW_OML_swap_method;
17975
          continue;
17976
        }
17977
#endif
17978
#ifdef GLX_OML_sync_control
17979
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))
17980
        {
17981
          ret = GLXEW_OML_sync_control;
17982
          continue;
17983
        }
17984
#endif
17985
      }
17986
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))
17987
      {
17988
#ifdef GLX_SGIS_blended_overlay
17989
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))
17990
        {
17991
          ret = GLXEW_SGIS_blended_overlay;
17992
          continue;
17993
        }
17994
#endif
17995
#ifdef GLX_SGIS_color_range
17996
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))
17997
        {
17998
          ret = GLXEW_SGIS_color_range;
17999
          continue;
18000
        }
18001
#endif
18002
#ifdef GLX_SGIS_multisample
18003
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
18004
        {
18005
          ret = GLXEW_SGIS_multisample;
18006
          continue;
18007
        }
18008
#endif
18009
#ifdef GLX_SGIS_shared_multisample
18010
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))
18011
        {
18012
          ret = GLXEW_SGIS_shared_multisample;
18013
          continue;
18014
        }
18015
#endif
18016
      }
18017
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))
18018
      {
18019
#ifdef GLX_SGIX_fbconfig
18020
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))
18021
        {
18022
          ret = GLXEW_SGIX_fbconfig;
18023
          continue;
18024
        }
18025
#endif
18026
#ifdef GLX_SGIX_hyperpipe
18027
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9))
18028
        {
18029
          ret = GLXEW_SGIX_hyperpipe;
18030
          continue;
18031
        }
18032
#endif
18033
#ifdef GLX_SGIX_pbuffer
18034
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
18035
        {
18036
          ret = GLXEW_SGIX_pbuffer;
18037
          continue;
18038
        }
18039
#endif
18040
#ifdef GLX_SGIX_swap_barrier
18041
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))
18042
        {
18043
          ret = GLXEW_SGIX_swap_barrier;
18044
          continue;
18045
        }
18046
#endif
18047
#ifdef GLX_SGIX_swap_group
18048
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
18049
        {
18050
          ret = GLXEW_SGIX_swap_group;
18051
          continue;
18052
        }
18053
#endif
18054
#ifdef GLX_SGIX_video_resize
18055
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))
18056
        {
18057
          ret = GLXEW_SGIX_video_resize;
18058
          continue;
18059
        }
18060
#endif
18061
#ifdef GLX_SGIX_visual_select_group
18062
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))
18063
        {
18064
          ret = GLXEW_SGIX_visual_select_group;
18065
          continue;
18066
        }
18067
#endif
18068
      }
18069
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))
18070
      {
18071
#ifdef GLX_SGI_cushion
18072
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))
18073
        {
18074
          ret = GLXEW_SGI_cushion;
18075
          continue;
18076
        }
18077
#endif
18078
#ifdef GLX_SGI_make_current_read
18079
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
18080
        {
18081
          ret = GLXEW_SGI_make_current_read;
18082
          continue;
18083
        }
18084
#endif
18085
#ifdef GLX_SGI_swap_control
18086
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
18087
        {
18088
          ret = GLXEW_SGI_swap_control;
18089
          continue;
18090
        }
18091
#endif
18092
#ifdef GLX_SGI_video_sync
18093
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))
18094
        {
18095
          ret = GLXEW_SGI_video_sync;
18096
          continue;
18097
        }
18098
#endif
18099
      }
18100
      if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))
18101
      {
18102
#ifdef GLX_SUN_get_transparent_index
18103
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))
18104
        {
18105
          ret = GLXEW_SUN_get_transparent_index;
18106
          continue;
18107
        }
18108
#endif
18109
#ifdef GLX_SUN_video_resize
18110
        if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))
18111
        {
18112
          ret = GLXEW_SUN_video_resize;
18113
          continue;
18114
        }
18115
#endif
18116
      }
18117
    }
18118
    ret = (len == 0);
18119
  }
18120
  return ret;
18121
}
18122
 
18123
#endif /* _WIN32 */