rayfract: 1496aae2e7d4 src/glew/glew.c

rayfract

view src/glew/glew.c @ 10:1496aae2e7d4

- simplified build by including dependences in the source tree - added make dep tracking - added mingw cross-build rules - added readme & licence

author	John Tsiombikas <nuclear@member.fsf.org>
date	Mon, 31 Jul 2023 18:58:56 +0300
parents
children

line source

1 /*

2 ** The OpenGL Extension Wrangler Library

8 **

9 ** Redistribution and use in source and binary forms, with or without

10 ** modification, are permitted provided that the following conditions are met:

11 **

12 ** * Redistributions of source code must retain the above copyright notice,

13 ** this list of conditions and the following disclaimer.

14 ** * Redistributions in binary form must reproduce the above copyright notice,

15 ** this list of conditions and the following disclaimer in the documentation

16 ** and/or other materials provided with the distribution.

17 ** * The name of the author may be used to endorse or promote products

18 ** derived from this software without specific prior written permission.

19 **

20 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

21 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

22 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

23 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

24 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

25 ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

26 ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

27 ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

28 ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

29 ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

30 ** THE POSSIBILITY OF SUCH DAMAGE.

31 */

33 #ifndef GLEW_INCLUDE

34 #include <GL/glew.h>

35 #else

36 #include GLEW_INCLUDE

37 #endif

39 #if defined(GLEW_OSMESA)

40 # define GLAPI extern

41 # include <GL/osmesa.h>

42 #elif defined(GLEW_EGL)

43 # include <GL/eglew.h>

44 #elif defined(_WIN32)

45 /*

46 * If NOGDI is defined, wingdi.h won't be included by windows.h, and thus

47 * wglGetProcAddress won't be declared. It will instead be implicitly declared,

48 * potentially incorrectly, which we don't want.

49 */

50 # if defined(NOGDI)

51 # undef NOGDI

52 # endif

53 # include <GL/wglew.h>

54 #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))

55 # include <GL/glxew.h>

56 #endif

58 #include <stddef.h> /* For size_t */

60 #if defined(GLEW_EGL)

61 #elif defined(GLEW_REGAL)

63 /* In GLEW_REGAL mode we call direcly into the linked

64 libRegal.so glGetProcAddressREGAL for looking up

65 the GL function pointers. */

67 # undef glGetProcAddressREGAL

68 # ifdef WIN32

69 extern void * __stdcall glGetProcAddressREGAL(const GLchar *name);

70 static void * (__stdcall * regalGetProcAddress) (const GLchar *) = glGetProcAddressREGAL;

71 # else

72 extern void * glGetProcAddressREGAL(const GLchar *name);

73 static void * (*regalGetProcAddress) (const GLchar *) = glGetProcAddressREGAL;

74 # endif

75 # define glGetProcAddressREGAL GLEW_GET_FUN(__glewGetProcAddressREGAL)

77 #elif defined(__sgi) || defined (__sun) || defined(__HAIKU__) || defined(GLEW_APPLE_GLX)

78 #include <dlfcn.h>

79 #include <stdio.h>

80 #include <stdlib.h>

82 void* dlGetProcAddress (const GLubyte* name)

83 {

84 static void* h = NULL;

85 static void* gpa;

87 if (h == NULL)

88 {

89 if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;

90 gpa = dlsym(h, "glXGetProcAddress");

91 }

93 if (gpa != NULL)

94 return ((void*(*)(const GLubyte*))gpa)(name);

95 else

96 return dlsym(h, (const char*)name);

97 }

98 #endif /* __sgi || __sun || GLEW_APPLE_GLX */

100 #if defined(__APPLE__)

101 #include <stdlib.h>

102 #include <string.h>

103 #include <AvailabilityMacros.h>

104

105 #ifdef MAC_OS_X_VERSION_10_3

106

107 #include <dlfcn.h>

108

109 void* NSGLGetProcAddress (const GLubyte *name)

110 {

111 static void* image = NULL;

112 void* addr;

113 if (NULL == image)

114 {

115 image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);

116 }

117 if( !image ) return NULL;

118 addr = dlsym(image, (const char*)name);

119 if( addr ) return addr;

120 #ifdef GLEW_APPLE_GLX

121 return dlGetProcAddress( name ); // try next for glx symbols

122 #else

123 return NULL;

124 #endif

125 }

126 #else

127

128 #include <mach-o/dyld.h>

129

130 void* NSGLGetProcAddress (const GLubyte *name)

131 {

132 static const struct mach_header* image = NULL;

133 NSSymbol symbol;

134 char* symbolName;

135 if (NULL == image)

136 {

137 image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);

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(GLEW_REGAL)

162 # define glewGetProcAddress(name) regalGetProcAddress((const GLchar *)name)

163 #elif defined(GLEW_OSMESA)

164 # define glewGetProcAddress(name) OSMesaGetProcAddress((const char *)name)

165 #elif defined(GLEW_EGL)

166 # define glewGetProcAddress(name) eglGetProcAddress((const char *)name)

167 #elif defined(_WIN32)

168 # define glewGetProcAddress(name) wglGetProcAddress((LPCSTR)name)

169 #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)

170 # define glewGetProcAddress(name) NSGLGetProcAddress(name)

171 #elif defined(__sgi) || defined(__sun) || defined(__HAIKU__)

172 # define glewGetProcAddress(name) dlGetProcAddress(name)

173 #elif defined(__ANDROID__)

174 # define glewGetProcAddress(name) NULL /* TODO */

175 #elif defined(__native_client__)

176 # define glewGetProcAddress(name) NULL /* TODO */

177 #else /* __linux */

178 # define glewGetProcAddress(name) (*glXGetProcAddressARB)(name)

179 #endif

180

181 /*

182 * Redefine GLEW_GET_VAR etc without const cast

183 */

184

185 #undef GLEW_GET_VAR

186 # define GLEW_GET_VAR(x) (x)

187

188 #ifdef WGLEW_GET_VAR

189 # undef WGLEW_GET_VAR

190 # define WGLEW_GET_VAR(x) (x)

191 #endif /* WGLEW_GET_VAR */

192

193 #ifdef GLXEW_GET_VAR

194 # undef GLXEW_GET_VAR

195 # define GLXEW_GET_VAR(x) (x)

196 #endif /* GLXEW_GET_VAR */

197

198 #ifdef EGLEW_GET_VAR

199 # undef EGLEW_GET_VAR

200 # define EGLEW_GET_VAR(x) (x)

201 #endif /* EGLEW_GET_VAR */

202

203 /*

204 * GLEW, just like OpenGL or GLU, does not rely on the standard C library.

205 * These functions implement the functionality required in this file.

206 */

207

208 static GLuint _glewStrLen (const GLubyte* s)

209 {

210 GLuint i=0;

211 if (s == NULL) return 0;

212 while (s[i] != '\0') i++;

213 return i;

214 }

215

216 static GLuint _glewStrCLen (const GLubyte* s, GLubyte c)

217 {

218 GLuint i=0;

219 if (s == NULL) return 0;

220 while (s[i] != '\0' && s[i] != c) i++;

221 return i;

222 }

223

224 static GLuint _glewStrCopy(char *d, const char *s, char c)

225 {

226 GLuint i=0;

227 if (s == NULL) return 0;

228 while (s[i] != '\0' && s[i] != c) { d[i] = s[i]; i++; }

229 d[i] = '\0';

230 return i;

231 }

232

233 #if !defined(GLEW_OSMESA)

234 #if !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

235 static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n)

236 {

237 GLuint i=0;

238 if(a == NULL || b == NULL)

239 return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE;

240 while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++;

241 return i == n ? GL_TRUE : GL_FALSE;

242 }

243 #endif

244 #endif

245

246 static GLboolean _glewStrSame1 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)

247 {

248 while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t'))

249 {

250 (*a)++;

251 (*na)--;

252 }

253 if(*na >= nb)

254 {

255 GLuint i=0;

256 while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;

257 if(i == nb)

258 {

259 *a = *a + nb;

260 *na = *na - nb;

261 return GL_TRUE;

262 }

263 }

264 return GL_FALSE;

265 }

266

267 static GLboolean _glewStrSame2 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)

268 {

269 if(*na >= nb)

270 {

271 GLuint i=0;

272 while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;

273 if(i == nb)

274 {

275 *a = *a + nb;

276 *na = *na - nb;

277 return GL_TRUE;

278 }

279 }

280 return GL_FALSE;

281 }

282

283 static GLboolean _glewStrSame3 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)

284 {

285 if(*na >= nb)

286 {

287 GLuint i=0;

288 while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;

289 if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t'))

290 {

291 *a = *a + nb;

292 *na = *na - nb;

293 return GL_TRUE;

294 }

295 }

296 return GL_FALSE;

297 }

298

299 /*

300 * Search for name in the extensions string. Use of strstr()

301 * is not sufficient because extension names can be prefixes of

302 * other extension names. Could use strtok() but the constant

303 * string returned by glGetString might be in read-only memory.

304 */

305 #if !defined(GLEW_OSMESA)

306 #if !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

307 static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end)

308 {

309 const GLubyte* p;

310 GLuint len = _glewStrLen((const GLubyte*)name);

311 p = start;

312 while (p < end)

313 {

314 GLuint n = _glewStrCLen(p, ' ');

315 if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE;

316 p += n+1;

317 }

318 return GL_FALSE;

319 }

320 #endif

321 #endif

322

323 PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;

324 PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;

325 PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;

326 PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;

327

328 PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;

329 PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;

330 PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;

331 PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;

332 PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;

333 PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;

334 PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;

335 PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;

336 PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;

337 PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;

338 PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;

339 PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;

340 PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;

341 PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;

342 PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;

343 PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;

344 PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;

345 PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;

346 PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;

347 PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;

348 PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;

349 PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;

350 PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;

351 PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;

352 PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;

353 PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;

354 PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;

355 PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;

356 PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;

357 PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;

358 PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;

359 PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;

360 PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;

361 PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;

362 PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;

363 PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;

364 PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;

365 PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;

366 PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;

367 PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;

368 PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;

369 PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;

370 PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;

371 PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;

372 PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;

373 PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;

374

375 PFNGLBLENDCOLORPROC __glewBlendColor = NULL;

376 PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;

377 PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;

378 PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;

379 PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;

380 PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;

381 PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;

382 PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;

383 PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;

384 PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;

385 PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;

386 PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;

387 PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL;

388 PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL;

389 PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;

390 PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;

391 PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;

392 PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;

393 PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;

394 PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;

395 PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;

396 PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;

397 PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;

398 PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;

399 PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;

400 PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;

401 PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;

402 PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;

403 PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;

404 PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;

405 PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;

406 PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;

407 PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;

408 PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;

409 PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;

410 PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;

411 PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;

412 PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;

413 PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;

414 PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;

415 PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;

416 PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;

417 PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;

418 PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;

419 PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;

420 PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;

421 PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;

422

423 PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;

424 PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;

425 PFNGLBUFFERDATAPROC __glewBufferData = NULL;

426 PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;

427 PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;

428 PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;

429 PFNGLENDQUERYPROC __glewEndQuery = NULL;

430 PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;

431 PFNGLGENQUERIESPROC __glewGenQueries = NULL;

432 PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;

433 PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;

434 PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;

435 PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;

436 PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;

437 PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;

438 PFNGLISBUFFERPROC __glewIsBuffer = NULL;

439 PFNGLISQUERYPROC __glewIsQuery = NULL;

440 PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;

441 PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;

442

443 PFNGLATTACHSHADERPROC __glewAttachShader = NULL;

444 PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;

445 PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;

446 PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;

447 PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;

448 PFNGLCREATESHADERPROC __glewCreateShader = NULL;

449 PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;

450 PFNGLDELETESHADERPROC __glewDeleteShader = NULL;

451 PFNGLDETACHSHADERPROC __glewDetachShader = NULL;

452 PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;

453 PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;

454 PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;

455 PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;

456 PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;

457 PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;

458 PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;

459 PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;

460 PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;

461 PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;

462 PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;

463 PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;

464 PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;

465 PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;

466 PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;

467 PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;

468 PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;

469 PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;

470 PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;

471 PFNGLISPROGRAMPROC __glewIsProgram = NULL;

472 PFNGLISSHADERPROC __glewIsShader = NULL;

473 PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;

474 PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;

475 PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;

476 PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;

477 PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;

478 PFNGLUNIFORM1FPROC __glewUniform1f = NULL;

479 PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;

480 PFNGLUNIFORM1IPROC __glewUniform1i = NULL;

481 PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;

482 PFNGLUNIFORM2FPROC __glewUniform2f = NULL;

483 PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;

484 PFNGLUNIFORM2IPROC __glewUniform2i = NULL;

485 PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;

486 PFNGLUNIFORM3FPROC __glewUniform3f = NULL;

487 PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;

488 PFNGLUNIFORM3IPROC __glewUniform3i = NULL;

489 PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;

490 PFNGLUNIFORM4FPROC __glewUniform4f = NULL;

491 PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;

492 PFNGLUNIFORM4IPROC __glewUniform4i = NULL;

493 PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;

494 PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;

495 PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;

496 PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;

497 PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;

498 PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;

499 PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;

500 PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;

501 PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;

502 PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;

503 PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;

504 PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;

505 PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;

506 PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;

507 PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;

508 PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;

509 PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;

510 PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;

511 PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;

512 PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;

513 PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;

514 PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;

515 PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;

516 PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;

517 PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;

518 PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;

519 PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;

520 PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;

521 PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;

522 PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;

523 PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;

524 PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;

525 PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;

526 PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;

527 PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;

528 PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;

529 PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;

530 PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;

531 PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;

532 PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;

533 PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;

534 PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;

535 PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;

536

537 PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;

538 PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;

539 PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;

540 PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;

541 PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;

542 PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;

543

544 PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL;

545 PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL;

546 PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL;

547 PFNGLCLAMPCOLORPROC __glewClampColor = NULL;

548 PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL;

549 PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL;

550 PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL;

551 PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL;

552 PFNGLCOLORMASKIPROC __glewColorMaski = NULL;

553 PFNGLDISABLEIPROC __glewDisablei = NULL;

554 PFNGLENABLEIPROC __glewEnablei = NULL;

555 PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL;

556 PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL;

557 PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL;

558 PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL;

559 PFNGLGETSTRINGIPROC __glewGetStringi = NULL;

560 PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL;

561 PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL;

562 PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL;

563 PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL;

564 PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL;

565 PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL;

566 PFNGLISENABLEDIPROC __glewIsEnabledi = NULL;

567 PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL;

568 PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL;

569 PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL;

570 PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL;

571 PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL;

572 PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL;

573 PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL;

574 PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL;

575 PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL;

576 PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL;

577 PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL;

578 PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL;

579 PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL;

580 PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL;

581 PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL;

582 PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL;

583 PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL;

584 PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL;

585 PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL;

586 PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL;

587 PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL;

588 PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL;

589 PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL;

590 PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL;

591 PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL;

592 PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL;

593 PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL;

594 PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL;

595 PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL;

596 PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL;

597 PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL;

598 PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL;

599

600 PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL;

601 PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL;

602 PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL;

603 PFNGLTEXBUFFERPROC __glewTexBuffer = NULL;

604

605 PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL;

606 PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL;

607 PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL;

608

609 PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL;

610

611 PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL;

612 PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL;

613 PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL;

614 PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL;

615 PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL;

616

617 PFNGLGETGRAPHICSRESETSTATUSPROC __glewGetGraphicsResetStatus = NULL;

618 PFNGLGETNCOMPRESSEDTEXIMAGEPROC __glewGetnCompressedTexImage = NULL;

619 PFNGLGETNTEXIMAGEPROC __glewGetnTexImage = NULL;

620 PFNGLGETNUNIFORMDVPROC __glewGetnUniformdv = NULL;

621

622 PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC __glewMultiDrawArraysIndirectCount = NULL;

623 PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC __glewMultiDrawElementsIndirectCount = NULL;

624 PFNGLSPECIALIZESHADERPROC __glewSpecializeShader = NULL;

625

626 PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;

627

628 PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL;

629 PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD = NULL;

630 PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD = NULL;

631 PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD = NULL;

632

633 PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL;

634 PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL;

635 PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL;

636 PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL;

637

638 PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewFramebufferSamplePositionsfvAMD = NULL;

639 PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC __glewGetFramebufferParameterfvAMD = NULL;

640 PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC __glewGetNamedFramebufferParameterfvAMD = NULL;

641 PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewNamedFramebufferSamplePositionsfvAMD = NULL;

642

643 PFNGLVERTEXATTRIBPARAMETERIAMDPROC __glewVertexAttribParameteriAMD = NULL;

644

645 PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL;

646 PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD = NULL;

647

648 PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD = NULL;

649 PFNGLGENNAMESAMDPROC __glewGenNamesAMD = NULL;

650 PFNGLISNAMEAMDPROC __glewIsNameAMD = NULL;

651

652 PFNGLQUERYOBJECTPARAMETERUIAMDPROC __glewQueryObjectParameteruiAMD = NULL;

653

654 PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL;

655 PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL;

656 PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL;

657 PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL;

658 PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL;

659 PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL;

660 PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL;

661 PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL;

662 PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL;

663 PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL;

664 PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL;

665

666 PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD = NULL;

667

668 PFNGLTEXSTORAGESPARSEAMDPROC __glewTexStorageSparseAMD = NULL;

669 PFNGLTEXTURESTORAGESPARSEAMDPROC __glewTextureStorageSparseAMD = NULL;

670

671 PFNGLSTENCILOPVALUEAMDPROC __glewStencilOpValueAMD = NULL;

672

673 PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL;

674 PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL;

675

676 PFNGLBLITFRAMEBUFFERANGLEPROC __glewBlitFramebufferANGLE = NULL;

677

678 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC __glewRenderbufferStorageMultisampleANGLE = NULL;

679

680 PFNGLDRAWARRAYSINSTANCEDANGLEPROC __glewDrawArraysInstancedANGLE = NULL;

681 PFNGLDRAWELEMENTSINSTANCEDANGLEPROC __glewDrawElementsInstancedANGLE = NULL;

682 PFNGLVERTEXATTRIBDIVISORANGLEPROC __glewVertexAttribDivisorANGLE = NULL;

683

684 PFNGLBEGINQUERYANGLEPROC __glewBeginQueryANGLE = NULL;

685 PFNGLDELETEQUERIESANGLEPROC __glewDeleteQueriesANGLE = NULL;

686 PFNGLENDQUERYANGLEPROC __glewEndQueryANGLE = NULL;

687 PFNGLGENQUERIESANGLEPROC __glewGenQueriesANGLE = NULL;

688 PFNGLGETQUERYOBJECTI64VANGLEPROC __glewGetQueryObjecti64vANGLE = NULL;

689 PFNGLGETQUERYOBJECTIVANGLEPROC __glewGetQueryObjectivANGLE = NULL;

690 PFNGLGETQUERYOBJECTUI64VANGLEPROC __glewGetQueryObjectui64vANGLE = NULL;

691 PFNGLGETQUERYOBJECTUIVANGLEPROC __glewGetQueryObjectuivANGLE = NULL;

692 PFNGLGETQUERYIVANGLEPROC __glewGetQueryivANGLE = NULL;

693 PFNGLISQUERYANGLEPROC __glewIsQueryANGLE = NULL;

694 PFNGLQUERYCOUNTERANGLEPROC __glewQueryCounterANGLE = NULL;

695

696 PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC __glewGetTranslatedShaderSourceANGLE = NULL;

697

698 PFNGLCOPYTEXTURELEVELSAPPLEPROC __glewCopyTextureLevelsAPPLE = NULL;

699

700 PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;

701 PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;

702 PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;

703 PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;

704 PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;

705

706 PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;

707 PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;

708 PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;

709 PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;

710 PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;

711 PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;

712 PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;

713 PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;

714

715 PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;

716 PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;

717

718 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC __glewRenderbufferStorageMultisampleAPPLE = NULL;

719 PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC __glewResolveMultisampleFramebufferAPPLE = NULL;

720

721 PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL;

722 PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL;

723 PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL;

724

725 PFNGLCLIENTWAITSYNCAPPLEPROC __glewClientWaitSyncAPPLE = NULL;

726 PFNGLDELETESYNCAPPLEPROC __glewDeleteSyncAPPLE = NULL;

727 PFNGLFENCESYNCAPPLEPROC __glewFenceSyncAPPLE = NULL;

728 PFNGLGETINTEGER64VAPPLEPROC __glewGetInteger64vAPPLE = NULL;

729 PFNGLGETSYNCIVAPPLEPROC __glewGetSyncivAPPLE = NULL;

730 PFNGLISSYNCAPPLEPROC __glewIsSyncAPPLE = NULL;

731 PFNGLWAITSYNCAPPLEPROC __glewWaitSyncAPPLE = NULL;

732

733 PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;

734 PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;

735

736 PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;

737 PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;

738 PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;

739 PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;

740

741 PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;

742 PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;

743 PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;

744

745 PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL;

746 PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL;

747 PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL;

748 PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL;

749 PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL;

750 PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL;

751 PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL;

752

753 PFNGLCLEARDEPTHFPROC __glewClearDepthf = NULL;

754 PFNGLDEPTHRANGEFPROC __glewDepthRangef = NULL;

755 PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat = NULL;

756 PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler = NULL;

757 PFNGLSHADERBINARYPROC __glewShaderBinary = NULL;

758

759 PFNGLMEMORYBARRIERBYREGIONPROC __glewMemoryBarrierByRegion = NULL;

760

761 PFNGLPRIMITIVEBOUNDINGBOXARBPROC __glewPrimitiveBoundingBoxARB = NULL;

762

763 PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance = NULL;

764 PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance = NULL;

765 PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance = NULL;

766

767 PFNGLGETIMAGEHANDLEARBPROC __glewGetImageHandleARB = NULL;

768 PFNGLGETTEXTUREHANDLEARBPROC __glewGetTextureHandleARB = NULL;

769 PFNGLGETTEXTURESAMPLERHANDLEARBPROC __glewGetTextureSamplerHandleARB = NULL;

770 PFNGLGETVERTEXATTRIBLUI64VARBPROC __glewGetVertexAttribLui64vARB = NULL;

771 PFNGLISIMAGEHANDLERESIDENTARBPROC __glewIsImageHandleResidentARB = NULL;

772 PFNGLISTEXTUREHANDLERESIDENTARBPROC __glewIsTextureHandleResidentARB = NULL;

773 PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC __glewMakeImageHandleNonResidentARB = NULL;

774 PFNGLMAKEIMAGEHANDLERESIDENTARBPROC __glewMakeImageHandleResidentARB = NULL;

775 PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC __glewMakeTextureHandleNonResidentARB = NULL;

776 PFNGLMAKETEXTUREHANDLERESIDENTARBPROC __glewMakeTextureHandleResidentARB = NULL;

777 PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC __glewProgramUniformHandleui64ARB = NULL;

778 PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC __glewProgramUniformHandleui64vARB = NULL;

779 PFNGLUNIFORMHANDLEUI64ARBPROC __glewUniformHandleui64ARB = NULL;

780 PFNGLUNIFORMHANDLEUI64VARBPROC __glewUniformHandleui64vARB = NULL;

781 PFNGLVERTEXATTRIBL1UI64ARBPROC __glewVertexAttribL1ui64ARB = NULL;

782 PFNGLVERTEXATTRIBL1UI64VARBPROC __glewVertexAttribL1ui64vARB = NULL;

783

784 PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL;

785 PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL;

786

787 PFNGLBUFFERSTORAGEPROC __glewBufferStorage = NULL;

788

789 PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL;

790

791 PFNGLCLEARBUFFERDATAPROC __glewClearBufferData = NULL;

792 PFNGLCLEARBUFFERSUBDATAPROC __glewClearBufferSubData = NULL;

793 PFNGLCLEARNAMEDBUFFERDATAEXTPROC __glewClearNamedBufferDataEXT = NULL;

794 PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC __glewClearNamedBufferSubDataEXT = NULL;

795

796 PFNGLCLEARTEXIMAGEPROC __glewClearTexImage = NULL;

797 PFNGLCLEARTEXSUBIMAGEPROC __glewClearTexSubImage = NULL;

798

799 PFNGLCLIPCONTROLPROC __glewClipControl = NULL;

800

801 PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;

802

803 PFNGLDISPATCHCOMPUTEPROC __glewDispatchCompute = NULL;

804 PFNGLDISPATCHCOMPUTEINDIRECTPROC __glewDispatchComputeIndirect = NULL;

805

806 PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC __glewDispatchComputeGroupSizeARB = NULL;

807

808 PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL;

809

810 PFNGLCOPYIMAGESUBDATAPROC __glewCopyImageSubData = NULL;

811

812 PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB = NULL;

813 PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB = NULL;

814 PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB = NULL;

815 PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB = NULL;

816

817 PFNGLBINDTEXTUREUNITPROC __glewBindTextureUnit = NULL;

818 PFNGLBLITNAMEDFRAMEBUFFERPROC __glewBlitNamedFramebuffer = NULL;

819 PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC __glewCheckNamedFramebufferStatus = NULL;

820 PFNGLCLEARNAMEDBUFFERDATAPROC __glewClearNamedBufferData = NULL;

821 PFNGLCLEARNAMEDBUFFERSUBDATAPROC __glewClearNamedBufferSubData = NULL;

822 PFNGLCLEARNAMEDFRAMEBUFFERFIPROC __glewClearNamedFramebufferfi = NULL;

823 PFNGLCLEARNAMEDFRAMEBUFFERFVPROC __glewClearNamedFramebufferfv = NULL;

824 PFNGLCLEARNAMEDFRAMEBUFFERIVPROC __glewClearNamedFramebufferiv = NULL;

825 PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC __glewClearNamedFramebufferuiv = NULL;

826 PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC __glewCompressedTextureSubImage1D = NULL;

827 PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC __glewCompressedTextureSubImage2D = NULL;

828 PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC __glewCompressedTextureSubImage3D = NULL;

829 PFNGLCOPYNAMEDBUFFERSUBDATAPROC __glewCopyNamedBufferSubData = NULL;

830 PFNGLCOPYTEXTURESUBIMAGE1DPROC __glewCopyTextureSubImage1D = NULL;

831 PFNGLCOPYTEXTURESUBIMAGE2DPROC __glewCopyTextureSubImage2D = NULL;

832 PFNGLCOPYTEXTURESUBIMAGE3DPROC __glewCopyTextureSubImage3D = NULL;

833 PFNGLCREATEBUFFERSPROC __glewCreateBuffers = NULL;

834 PFNGLCREATEFRAMEBUFFERSPROC __glewCreateFramebuffers = NULL;

835 PFNGLCREATEPROGRAMPIPELINESPROC __glewCreateProgramPipelines = NULL;

836 PFNGLCREATEQUERIESPROC __glewCreateQueries = NULL;

837 PFNGLCREATERENDERBUFFERSPROC __glewCreateRenderbuffers = NULL;

838 PFNGLCREATESAMPLERSPROC __glewCreateSamplers = NULL;

839 PFNGLCREATETEXTURESPROC __glewCreateTextures = NULL;

840 PFNGLCREATETRANSFORMFEEDBACKSPROC __glewCreateTransformFeedbacks = NULL;

841 PFNGLCREATEVERTEXARRAYSPROC __glewCreateVertexArrays = NULL;

842 PFNGLDISABLEVERTEXARRAYATTRIBPROC __glewDisableVertexArrayAttrib = NULL;

843 PFNGLENABLEVERTEXARRAYATTRIBPROC __glewEnableVertexArrayAttrib = NULL;

844 PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC __glewFlushMappedNamedBufferRange = NULL;

845 PFNGLGENERATETEXTUREMIPMAPPROC __glewGenerateTextureMipmap = NULL;

846 PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC __glewGetCompressedTextureImage = NULL;

847 PFNGLGETNAMEDBUFFERPARAMETERI64VPROC __glewGetNamedBufferParameteri64v = NULL;

848 PFNGLGETNAMEDBUFFERPARAMETERIVPROC __glewGetNamedBufferParameteriv = NULL;

849 PFNGLGETNAMEDBUFFERPOINTERVPROC __glewGetNamedBufferPointerv = NULL;

850 PFNGLGETNAMEDBUFFERSUBDATAPROC __glewGetNamedBufferSubData = NULL;

851 PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetNamedFramebufferAttachmentParameteriv = NULL;

852 PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC __glewGetNamedFramebufferParameteriv = NULL;

853 PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC __glewGetNamedRenderbufferParameteriv = NULL;

854 PFNGLGETQUERYBUFFEROBJECTI64VPROC __glewGetQueryBufferObjecti64v = NULL;

855 PFNGLGETQUERYBUFFEROBJECTIVPROC __glewGetQueryBufferObjectiv = NULL;

856 PFNGLGETQUERYBUFFEROBJECTUI64VPROC __glewGetQueryBufferObjectui64v = NULL;

857 PFNGLGETQUERYBUFFEROBJECTUIVPROC __glewGetQueryBufferObjectuiv = NULL;

858 PFNGLGETTEXTUREIMAGEPROC __glewGetTextureImage = NULL;

859 PFNGLGETTEXTURELEVELPARAMETERFVPROC __glewGetTextureLevelParameterfv = NULL;

860 PFNGLGETTEXTURELEVELPARAMETERIVPROC __glewGetTextureLevelParameteriv = NULL;

861 PFNGLGETTEXTUREPARAMETERIIVPROC __glewGetTextureParameterIiv = NULL;

862 PFNGLGETTEXTUREPARAMETERIUIVPROC __glewGetTextureParameterIuiv = NULL;

863 PFNGLGETTEXTUREPARAMETERFVPROC __glewGetTextureParameterfv = NULL;

864 PFNGLGETTEXTUREPARAMETERIVPROC __glewGetTextureParameteriv = NULL;

865 PFNGLGETTRANSFORMFEEDBACKI64_VPROC __glewGetTransformFeedbacki64_v = NULL;

866 PFNGLGETTRANSFORMFEEDBACKI_VPROC __glewGetTransformFeedbacki_v = NULL;

867 PFNGLGETTRANSFORMFEEDBACKIVPROC __glewGetTransformFeedbackiv = NULL;

868 PFNGLGETVERTEXARRAYINDEXED64IVPROC __glewGetVertexArrayIndexed64iv = NULL;

869 PFNGLGETVERTEXARRAYINDEXEDIVPROC __glewGetVertexArrayIndexediv = NULL;

870 PFNGLGETVERTEXARRAYIVPROC __glewGetVertexArrayiv = NULL;

871 PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC __glewInvalidateNamedFramebufferData = NULL;

872 PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC __glewInvalidateNamedFramebufferSubData = NULL;

873 PFNGLMAPNAMEDBUFFERPROC __glewMapNamedBuffer = NULL;

874 PFNGLMAPNAMEDBUFFERRANGEPROC __glewMapNamedBufferRange = NULL;

875 PFNGLNAMEDBUFFERDATAPROC __glewNamedBufferData = NULL;

876 PFNGLNAMEDBUFFERSTORAGEPROC __glewNamedBufferStorage = NULL;

877 PFNGLNAMEDBUFFERSUBDATAPROC __glewNamedBufferSubData = NULL;

878 PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC __glewNamedFramebufferDrawBuffer = NULL;

879 PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC __glewNamedFramebufferDrawBuffers = NULL;

880 PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC __glewNamedFramebufferParameteri = NULL;

881 PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC __glewNamedFramebufferReadBuffer = NULL;

882 PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC __glewNamedFramebufferRenderbuffer = NULL;

883 PFNGLNAMEDFRAMEBUFFERTEXTUREPROC __glewNamedFramebufferTexture = NULL;

884 PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC __glewNamedFramebufferTextureLayer = NULL;

885 PFNGLNAMEDRENDERBUFFERSTORAGEPROC __glewNamedRenderbufferStorage = NULL;

886 PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewNamedRenderbufferStorageMultisample = NULL;

887 PFNGLTEXTUREBUFFERPROC __glewTextureBuffer = NULL;

888 PFNGLTEXTUREBUFFERRANGEPROC __glewTextureBufferRange = NULL;

889 PFNGLTEXTUREPARAMETERIIVPROC __glewTextureParameterIiv = NULL;

890 PFNGLTEXTUREPARAMETERIUIVPROC __glewTextureParameterIuiv = NULL;

891 PFNGLTEXTUREPARAMETERFPROC __glewTextureParameterf = NULL;

892 PFNGLTEXTUREPARAMETERFVPROC __glewTextureParameterfv = NULL;

893 PFNGLTEXTUREPARAMETERIPROC __glewTextureParameteri = NULL;

894 PFNGLTEXTUREPARAMETERIVPROC __glewTextureParameteriv = NULL;

895 PFNGLTEXTURESTORAGE1DPROC __glewTextureStorage1D = NULL;

896 PFNGLTEXTURESTORAGE2DPROC __glewTextureStorage2D = NULL;

897 PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC __glewTextureStorage2DMultisample = NULL;

898 PFNGLTEXTURESTORAGE3DPROC __glewTextureStorage3D = NULL;

899 PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC __glewTextureStorage3DMultisample = NULL;

900 PFNGLTEXTURESUBIMAGE1DPROC __glewTextureSubImage1D = NULL;

901 PFNGLTEXTURESUBIMAGE2DPROC __glewTextureSubImage2D = NULL;

902 PFNGLTEXTURESUBIMAGE3DPROC __glewTextureSubImage3D = NULL;

903 PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC __glewTransformFeedbackBufferBase = NULL;

904 PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC __glewTransformFeedbackBufferRange = NULL;

905 PFNGLUNMAPNAMEDBUFFERPROC __glewUnmapNamedBuffer = NULL;

906 PFNGLVERTEXARRAYATTRIBBINDINGPROC __glewVertexArrayAttribBinding = NULL;

907 PFNGLVERTEXARRAYATTRIBFORMATPROC __glewVertexArrayAttribFormat = NULL;

908 PFNGLVERTEXARRAYATTRIBIFORMATPROC __glewVertexArrayAttribIFormat = NULL;

909 PFNGLVERTEXARRAYATTRIBLFORMATPROC __glewVertexArrayAttribLFormat = NULL;

910 PFNGLVERTEXARRAYBINDINGDIVISORPROC __glewVertexArrayBindingDivisor = NULL;

911 PFNGLVERTEXARRAYELEMENTBUFFERPROC __glewVertexArrayElementBuffer = NULL;

912 PFNGLVERTEXARRAYVERTEXBUFFERPROC __glewVertexArrayVertexBuffer = NULL;

913 PFNGLVERTEXARRAYVERTEXBUFFERSPROC __glewVertexArrayVertexBuffers = NULL;

914

915 PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;

916

917 PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL;

918 PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL;

919 PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL;

920 PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL;

921

922 PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL;

923 PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL;

924 PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL;

925 PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL;

926

927 PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL;

928 PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL;

929

930 PFNGLFRAMEBUFFERPARAMETERIPROC __glewFramebufferParameteri = NULL;

931 PFNGLGETFRAMEBUFFERPARAMETERIVPROC __glewGetFramebufferParameteriv = NULL;

932 PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC __glewGetNamedFramebufferParameterivEXT = NULL;

933 PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC __glewNamedFramebufferParameteriEXT = NULL;

934

935 PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL;

936 PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL;

937 PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL;

938 PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL;

939 PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL;

940 PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL;

941 PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL;

942 PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL;

943 PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL;

944 PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL;

945 PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL;

946 PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL;

947 PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL;

948 PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL;

949 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL;

950 PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL;

951 PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL;

952 PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL;

953 PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL;

954 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL;

955

956 PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL;

957 PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL;

958 PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL;

959 PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL;

960

961 PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary = NULL;

962 PFNGLPROGRAMBINARYPROC __glewProgramBinary = NULL;

963 PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri = NULL;

964

965 PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC __glewGetCompressedTextureSubImage = NULL;

966 PFNGLGETTEXTURESUBIMAGEPROC __glewGetTextureSubImage = NULL;

967

968 PFNGLSPECIALIZESHADERARBPROC __glewSpecializeShaderARB = NULL;

969

970 PFNGLGETUNIFORMDVPROC __glewGetUniformdv = NULL;

971 PFNGLUNIFORM1DPROC __glewUniform1d = NULL;

972 PFNGLUNIFORM1DVPROC __glewUniform1dv = NULL;

973 PFNGLUNIFORM2DPROC __glewUniform2d = NULL;

974 PFNGLUNIFORM2DVPROC __glewUniform2dv = NULL;

975 PFNGLUNIFORM3DPROC __glewUniform3d = NULL;

976 PFNGLUNIFORM3DVPROC __glewUniform3dv = NULL;

977 PFNGLUNIFORM4DPROC __glewUniform4d = NULL;

978 PFNGLUNIFORM4DVPROC __glewUniform4dv = NULL;

979 PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv = NULL;

980 PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv = NULL;

981 PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv = NULL;

982 PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv = NULL;

983 PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv = NULL;

984 PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv = NULL;

985 PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv = NULL;

986 PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv = NULL;

987 PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv = NULL;

988

989 PFNGLGETUNIFORMI64VARBPROC __glewGetUniformi64vARB = NULL;

990 PFNGLGETUNIFORMUI64VARBPROC __glewGetUniformui64vARB = NULL;

991 PFNGLGETNUNIFORMI64VARBPROC __glewGetnUniformi64vARB = NULL;

992 PFNGLGETNUNIFORMUI64VARBPROC __glewGetnUniformui64vARB = NULL;

993 PFNGLPROGRAMUNIFORM1I64ARBPROC __glewProgramUniform1i64ARB = NULL;

994 PFNGLPROGRAMUNIFORM1I64VARBPROC __glewProgramUniform1i64vARB = NULL;

995 PFNGLPROGRAMUNIFORM1UI64ARBPROC __glewProgramUniform1ui64ARB = NULL;

996 PFNGLPROGRAMUNIFORM1UI64VARBPROC __glewProgramUniform1ui64vARB = NULL;

997 PFNGLPROGRAMUNIFORM2I64ARBPROC __glewProgramUniform2i64ARB = NULL;

998 PFNGLPROGRAMUNIFORM2I64VARBPROC __glewProgramUniform2i64vARB = NULL;

999 PFNGLPROGRAMUNIFORM2UI64ARBPROC __glewProgramUniform2ui64ARB = NULL;

1000 PFNGLPROGRAMUNIFORM2UI64VARBPROC __glewProgramUniform2ui64vARB = NULL;

1001 PFNGLPROGRAMUNIFORM3I64ARBPROC __glewProgramUniform3i64ARB = NULL;

1002 PFNGLPROGRAMUNIFORM3I64VARBPROC __glewProgramUniform3i64vARB = NULL;

1003 PFNGLPROGRAMUNIFORM3UI64ARBPROC __glewProgramUniform3ui64ARB = NULL;

1004 PFNGLPROGRAMUNIFORM3UI64VARBPROC __glewProgramUniform3ui64vARB = NULL;

1005 PFNGLPROGRAMUNIFORM4I64ARBPROC __glewProgramUniform4i64ARB = NULL;

1006 PFNGLPROGRAMUNIFORM4I64VARBPROC __glewProgramUniform4i64vARB = NULL;

1007 PFNGLPROGRAMUNIFORM4UI64ARBPROC __glewProgramUniform4ui64ARB = NULL;

1008 PFNGLPROGRAMUNIFORM4UI64VARBPROC __glewProgramUniform4ui64vARB = NULL;

1009 PFNGLUNIFORM1I64ARBPROC __glewUniform1i64ARB = NULL;

1010 PFNGLUNIFORM1I64VARBPROC __glewUniform1i64vARB = NULL;

1011 PFNGLUNIFORM1UI64ARBPROC __glewUniform1ui64ARB = NULL;

1012 PFNGLUNIFORM1UI64VARBPROC __glewUniform1ui64vARB = NULL;

1013 PFNGLUNIFORM2I64ARBPROC __glewUniform2i64ARB = NULL;

1014 PFNGLUNIFORM2I64VARBPROC __glewUniform2i64vARB = NULL;

1015 PFNGLUNIFORM2UI64ARBPROC __glewUniform2ui64ARB = NULL;

1016 PFNGLUNIFORM2UI64VARBPROC __glewUniform2ui64vARB = NULL;

1017 PFNGLUNIFORM3I64ARBPROC __glewUniform3i64ARB = NULL;

1018 PFNGLUNIFORM3I64VARBPROC __glewUniform3i64vARB = NULL;

1019 PFNGLUNIFORM3UI64ARBPROC __glewUniform3ui64ARB = NULL;

1020 PFNGLUNIFORM3UI64VARBPROC __glewUniform3ui64vARB = NULL;

1021 PFNGLUNIFORM4I64ARBPROC __glewUniform4i64ARB = NULL;

1022 PFNGLUNIFORM4I64VARBPROC __glewUniform4i64vARB = NULL;

1023 PFNGLUNIFORM4UI64ARBPROC __glewUniform4ui64ARB = NULL;

1024 PFNGLUNIFORM4UI64VARBPROC __glewUniform4ui64vARB = NULL;

1025

1026 PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;

1027 PFNGLCOLORTABLEPROC __glewColorTable = NULL;

1028 PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;

1029 PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;

1030 PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;

1031 PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;

1032 PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;

1033 PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;

1034 PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;

1035 PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;

1036 PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;

1037 PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;

1038 PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;

1039 PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;

1040 PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;

1041 PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;

1042 PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;

1043 PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;

1044 PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;

1045 PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;

1046 PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;

1047 PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;

1048 PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;

1049 PFNGLGETMINMAXPROC __glewGetMinmax = NULL;

1050 PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;

1051 PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;

1052 PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;

1053 PFNGLHISTOGRAMPROC __glewHistogram = NULL;

1054 PFNGLMINMAXPROC __glewMinmax = NULL;

1055 PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;

1056 PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;

1057 PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;

1058

1059 PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC __glewMultiDrawArraysIndirectCountARB = NULL;

1060 PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC __glewMultiDrawElementsIndirectCountARB = NULL;

1061

1062 PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL;

1063 PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL;

1064 PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL;

1065

1066 PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ = NULL;

1067

1068 PFNGLGETINTERNALFORMATI64VPROC __glewGetInternalformati64v = NULL;

1069

1070 PFNGLINVALIDATEBUFFERDATAPROC __glewInvalidateBufferData = NULL;

1071 PFNGLINVALIDATEBUFFERSUBDATAPROC __glewInvalidateBufferSubData = NULL;

1072 PFNGLINVALIDATEFRAMEBUFFERPROC __glewInvalidateFramebuffer = NULL;

1073 PFNGLINVALIDATESUBFRAMEBUFFERPROC __glewInvalidateSubFramebuffer = NULL;

1074 PFNGLINVALIDATETEXIMAGEPROC __glewInvalidateTexImage = NULL;

1075 PFNGLINVALIDATETEXSUBIMAGEPROC __glewInvalidateTexSubImage = NULL;

1076

1077 PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL;

1078 PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL;

1079

1080 PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;

1081 PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;

1082 PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;

1083 PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;

1084 PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;

1085

1086 PFNGLBINDBUFFERSBASEPROC __glewBindBuffersBase = NULL;

1087 PFNGLBINDBUFFERSRANGEPROC __glewBindBuffersRange = NULL;

1088 PFNGLBINDIMAGETEXTURESPROC __glewBindImageTextures = NULL;

1089 PFNGLBINDSAMPLERSPROC __glewBindSamplers = NULL;

1090 PFNGLBINDTEXTURESPROC __glewBindTextures = NULL;

1091 PFNGLBINDVERTEXBUFFERSPROC __glewBindVertexBuffers = NULL;

1092

1093 PFNGLMULTIDRAWARRAYSINDIRECTPROC __glewMultiDrawArraysIndirect = NULL;

1094 PFNGLMULTIDRAWELEMENTSINDIRECTPROC __glewMultiDrawElementsIndirect = NULL;

1095

1096 PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;

1097

1098 PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;

1099 PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;

1100 PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;

1101 PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;

1102 PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;

1103 PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;

1104 PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;

1105 PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;

1106 PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;

1107 PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;

1108 PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;

1109 PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;

1110 PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;

1111 PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;

1112 PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;

1113 PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;

1114 PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;

1115 PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;

1116 PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;

1117 PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;

1118 PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;

1119 PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;

1120 PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;

1121 PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;

1122 PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;

1123 PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;

1124 PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;

1125 PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;

1126 PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;

1127 PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;

1128 PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;

1129 PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;

1130 PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;

1131 PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;

1132

1133 PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;

1134 PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;

1135 PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;

1136 PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;

1137 PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;

1138 PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;

1139 PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;

1140 PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;

1141

1142 PFNGLMAXSHADERCOMPILERTHREADSARBPROC __glewMaxShaderCompilerThreadsARB = NULL;

1143

1144 PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;

1145 PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;

1146

1147 PFNGLPOLYGONOFFSETCLAMPPROC __glewPolygonOffsetClamp = NULL;

1148

1149 PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv = NULL;

1150 PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex = NULL;

1151 PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation = NULL;

1152 PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC __glewGetProgramResourceLocationIndex = NULL;

1153 PFNGLGETPROGRAMRESOURCENAMEPROC __glewGetProgramResourceName = NULL;

1154 PFNGLGETPROGRAMRESOURCEIVPROC __glewGetProgramResourceiv = NULL;

1155

1156 PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL;

1157

1158 PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB = NULL;

1159 PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB = NULL;

1160 PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB = NULL;

1161 PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB = NULL;

1162 PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB = NULL;

1163 PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB = NULL;

1164 PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB = NULL;

1165 PFNGLGETNMAPIVARBPROC __glewGetnMapivARB = NULL;

1166 PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB = NULL;

1167 PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB = NULL;

1168 PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB = NULL;

1169 PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB = NULL;

1170 PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB = NULL;

1171 PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB = NULL;

1172 PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB = NULL;

1173 PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB = NULL;

1174 PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB = NULL;

1175 PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL;

1176 PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL;

1177 PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL;

1178

1179 PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB = NULL;

1180 PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB = NULL;

1181

1182 PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL;

1183

1184 PFNGLBINDSAMPLERPROC __glewBindSampler = NULL;

1185 PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL;

1186 PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL;

1187 PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL;

1188 PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL;

1189 PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL;

1190 PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL;

1191 PFNGLISSAMPLERPROC __glewIsSampler = NULL;

1192 PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL;

1193 PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL;

1194 PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL;

1195 PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL;

1196 PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL;

1197 PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL;

1198

1199 PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram = NULL;

1200 PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline = NULL;

1201 PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv = NULL;

1202 PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines = NULL;

1203 PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines = NULL;

1204 PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog = NULL;

1205 PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv = NULL;

1206 PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline = NULL;

1207 PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d = NULL;

1208 PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv = NULL;

1209 PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f = NULL;

1210 PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv = NULL;

1211 PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i = NULL;

1212 PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv = NULL;

1213 PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui = NULL;

1214 PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv = NULL;

1215 PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d = NULL;

1216 PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv = NULL;

1217 PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f = NULL;

1218 PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv = NULL;

1219 PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i = NULL;

1220 PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv = NULL;

1221 PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui = NULL;

1222 PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv = NULL;

1223 PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d = NULL;

1224 PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv = NULL;

1225 PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f = NULL;

1226 PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv = NULL;

1227 PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i = NULL;

1228 PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv = NULL;

1229 PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui = NULL;

1230 PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv = NULL;

1231 PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d = NULL;

1232 PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv = NULL;

1233 PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f = NULL;

1234 PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv = NULL;

1235 PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i = NULL;

1236 PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv = NULL;

1237 PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui = NULL;

1238 PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv = NULL;

1239 PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv = NULL;

1240 PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv = NULL;

1241 PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv = NULL;

1242 PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv = NULL;

1243 PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv = NULL;

1244 PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv = NULL;

1245 PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv = NULL;

1246 PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv = NULL;

1247 PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv = NULL;

1248 PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv = NULL;

1249 PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv = NULL;

1250 PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv = NULL;

1251 PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv = NULL;

1252 PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv = NULL;

1253 PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv = NULL;

1254 PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv = NULL;

1255 PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv = NULL;

1256 PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv = NULL;

1257 PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages = NULL;

1258 PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline = NULL;

1259

1260 PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv = NULL;

1261

1262 PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture = NULL;

1263 PFNGLMEMORYBARRIERPROC __glewMemoryBarrier = NULL;

1264

1265 PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;

1266 PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;

1267 PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;

1268 PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;

1269 PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;

1270 PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;

1271 PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;

1272 PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;

1273 PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;

1274 PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;

1275 PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;

1276 PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;

1277 PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;

1278 PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;

1279 PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;

1280 PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;

1281 PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;

1282 PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;

1283 PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;

1284 PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;

1285 PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;

1286 PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;

1287 PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;

1288 PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;

1289 PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;

1290 PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;

1291 PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;

1292 PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;

1293 PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;

1294 PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;

1295 PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;

1296 PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;

1297 PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;

1298 PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;

1299 PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;

1300 PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;

1301 PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;

1302 PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;

1303 PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;

1304

1305 PFNGLSHADERSTORAGEBLOCKBINDINGPROC __glewShaderStorageBlockBinding = NULL;

1306

1307 PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL;

1308 PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL;

1309 PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL;

1310 PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL;

1311 PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL;

1312 PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL;

1313 PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL;

1314 PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL;

1315

1316 PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL;

1317 PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL;

1318 PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL;

1319 PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL;

1320 PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL;

1321 PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL;

1322

1323 PFNGLBUFFERPAGECOMMITMENTARBPROC __glewBufferPageCommitmentARB = NULL;

1324

1325 PFNGLTEXPAGECOMMITMENTARBPROC __glewTexPageCommitmentARB = NULL;

1326

1327 PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL;

1328 PFNGLDELETESYNCPROC __glewDeleteSync = NULL;

1329 PFNGLFENCESYNCPROC __glewFenceSync = NULL;

1330 PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL;

1331 PFNGLGETSYNCIVPROC __glewGetSynciv = NULL;

1332 PFNGLISSYNCPROC __glewIsSync = NULL;

1333 PFNGLWAITSYNCPROC __glewWaitSync = NULL;

1334

1335 PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL;

1336 PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL;

1337

1338 PFNGLTEXTUREBARRIERPROC __glewTextureBarrier = NULL;

1339

1340 PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL;

1341

1342 PFNGLTEXBUFFERRANGEPROC __glewTexBufferRange = NULL;

1343 PFNGLTEXTUREBUFFERRANGEEXTPROC __glewTextureBufferRangeEXT = NULL;

1344

1345 PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;

1346 PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;

1347 PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;

1348 PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;

1349 PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;

1350 PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;

1351 PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;

1352

1353 PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL;

1354 PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL;

1355 PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL;

1356 PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL;

1357

1358 PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL;

1359 PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL;

1360 PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL;

1361

1362 PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample = NULL;

1363 PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample = NULL;

1364 PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC __glewTextureStorage2DMultisampleEXT = NULL;

1365 PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC __glewTextureStorage3DMultisampleEXT = NULL;

1366

1367 PFNGLTEXTUREVIEWPROC __glewTextureView = NULL;

1368

1369 PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL;

1370 PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL;

1371 PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL;

1372

1373 PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL;

1374 PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL;

1375 PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL;

1376 PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL;

1377 PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL;

1378 PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL;

1379 PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL;

1380

1381 PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL;

1382 PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL;

1383 PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL;

1384 PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL;

1385

1386 PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced = NULL;

1387 PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced = NULL;

1388

1389 PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;

1390 PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;

1391 PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;

1392 PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;

1393

1394 PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;

1395 PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;

1396 PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL;

1397 PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL;

1398 PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL;

1399 PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL;

1400 PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;

1401 PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL;

1402 PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL;

1403 PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL;

1404

1405 PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL;

1406 PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL;

1407 PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL;

1408 PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL;

1409

1410 PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv = NULL;

1411 PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d = NULL;

1412 PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv = NULL;

1413 PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d = NULL;

1414 PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv = NULL;

1415 PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d = NULL;

1416 PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv = NULL;

1417 PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d = NULL;

1418 PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv = NULL;

1419 PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer = NULL;

1420

1421 PFNGLBINDVERTEXBUFFERPROC __glewBindVertexBuffer = NULL;

1422 PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC __glewVertexArrayBindVertexBufferEXT = NULL;

1423 PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC __glewVertexArrayVertexAttribBindingEXT = NULL;

1424 PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC __glewVertexArrayVertexAttribFormatEXT = NULL;

1425 PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC __glewVertexArrayVertexAttribIFormatEXT = NULL;

1426 PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC __glewVertexArrayVertexAttribLFormatEXT = NULL;

1427 PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC __glewVertexArrayVertexBindingDivisorEXT = NULL;

1428 PFNGLVERTEXATTRIBBINDINGPROC __glewVertexAttribBinding = NULL;

1429 PFNGLVERTEXATTRIBFORMATPROC __glewVertexAttribFormat = NULL;

1430 PFNGLVERTEXATTRIBIFORMATPROC __glewVertexAttribIFormat = NULL;

1431 PFNGLVERTEXATTRIBLFORMATPROC __glewVertexAttribLFormat = NULL;

1432 PFNGLVERTEXBINDINGDIVISORPROC __glewVertexBindingDivisor = NULL;

1433

1434 PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;

1435 PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;

1436 PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;

1437 PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;

1438 PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;

1439 PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;

1440 PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;

1441 PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;

1442 PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;

1443 PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;

1444

1445 PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;

1446 PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;

1447 PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;

1448 PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;

1449 PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;

1450 PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;

1451 PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;

1452 PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;

1453 PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;

1454 PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;

1455 PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;

1456

1457 PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;

1458 PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;

1459 PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;

1460 PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;

1461 PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;

1462 PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;

1463 PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;

1464 PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;

1465 PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;

1466 PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;

1467 PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;

1468 PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;

1469 PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;

1470 PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;

1471 PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;

1472 PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;

1473 PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;

1474 PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;

1475 PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;

1476 PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;

1477 PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;

1478 PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;

1479 PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;

1480 PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;

1481 PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;

1482 PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;

1483 PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;

1484 PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;

1485 PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;

1486 PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;

1487 PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;

1488 PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;

1489 PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;

1490 PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;

1491 PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;

1492 PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;

1493 PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;

1494 PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;

1495 PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;

1496 PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;

1497 PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;

1498 PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;

1499 PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;

1500 PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;

1501 PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;

1502 PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;

1503 PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;

1504 PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;

1505 PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;

1506 PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;

1507 PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;

1508 PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;

1509 PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;

1510 PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;

1511 PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;

1512 PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;

1513 PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;

1514 PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;

1515 PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;

1516 PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;

1517 PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;

1518 PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;

1519

1520 PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;

1521 PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;

1522 PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;

1523

1524 PFNGLCOLORP3UIPROC __glewColorP3ui = NULL;

1525 PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL;

1526 PFNGLCOLORP4UIPROC __glewColorP4ui = NULL;

1527 PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL;

1528 PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL;

1529 PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL;

1530 PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL;

1531 PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL;

1532 PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL;

1533 PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL;

1534 PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL;

1535 PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL;

1536 PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL;

1537 PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL;

1538 PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL;

1539 PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL;

1540 PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL;

1541 PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL;

1542 PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL;

1543 PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL;

1544 PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL;

1545 PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL;

1546 PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL;

1547 PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL;

1548 PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL;

1549 PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL;

1550 PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL;

1551 PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL;

1552 PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL;

1553 PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL;

1554 PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL;

1555 PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL;

1556 PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL;

1557 PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL;

1558 PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL;

1559 PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL;

1560 PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL;

1561 PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL;

1562

1563 PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv = NULL;

1564 PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed = NULL;

1565 PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v = NULL;

1566 PFNGLGETFLOATI_VPROC __glewGetFloati_v = NULL;

1567 PFNGLSCISSORARRAYVPROC __glewScissorArrayv = NULL;

1568 PFNGLSCISSORINDEXEDPROC __glewScissorIndexed = NULL;

1569 PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv = NULL;

1570 PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv = NULL;

1571 PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf = NULL;

1572 PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv = NULL;

1573

1574 PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;

1575 PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;

1576 PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;

1577 PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;

1578 PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;

1579 PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;

1580 PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;

1581 PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;

1582 PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;

1583 PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;

1584 PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;

1585 PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;

1586 PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;

1587 PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;

1588 PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;

1589 PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;

1590

1591 PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;

1592

1593 PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;

1594 PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;

1595 PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;

1596

1597 PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;

1598 PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;

1599 PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;

1600 PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;

1601

1602 PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;

1603 PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;

1604 PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;

1605 PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;

1606 PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;

1607 PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;

1608 PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;

1609 PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;

1610 PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;

1611 PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;

1612 PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;

1613 PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;

1614 PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;

1615 PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;

1616

1617 PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;

1618 PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;

1619

1620 PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI = NULL;

1621 PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI = NULL;

1622

1623 PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;

1624 PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;

1625

1626 PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;

1627 PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;

1628 PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;

1629 PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;

1630 PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;

1631 PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;

1632 PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;

1633 PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;

1634 PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;

1635 PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;

1636 PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;

1637 PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;

1638

1639 PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;

1640 PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;

1641 PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;

1642

1643 PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;

1644 PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;

1645 PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;

1646 PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;

1647 PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;

1648 PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;

1649 PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;

1650 PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;

1651 PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;

1652 PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;

1653 PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;

1654 PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;

1655 PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;

1656 PFNGLVERTEXSTREAM1DATIPROC __glewVertexStream1dATI = NULL;

1657 PFNGLVERTEXSTREAM1DVATIPROC __glewVertexStream1dvATI = NULL;

1658 PFNGLVERTEXSTREAM1FATIPROC __glewVertexStream1fATI = NULL;

1659 PFNGLVERTEXSTREAM1FVATIPROC __glewVertexStream1fvATI = NULL;

1660 PFNGLVERTEXSTREAM1IATIPROC __glewVertexStream1iATI = NULL;

1661 PFNGLVERTEXSTREAM1IVATIPROC __glewVertexStream1ivATI = NULL;

1662 PFNGLVERTEXSTREAM1SATIPROC __glewVertexStream1sATI = NULL;

1663 PFNGLVERTEXSTREAM1SVATIPROC __glewVertexStream1svATI = NULL;

1664 PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;

1665 PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;

1666 PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;

1667 PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;

1668 PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;

1669 PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;

1670 PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;

1671 PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;

1672 PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;

1673 PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;

1674 PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;

1675 PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;

1676 PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;

1677 PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;

1678 PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;

1679 PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;

1680 PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;

1681 PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;

1682 PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;

1683 PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;

1684 PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;

1685 PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;

1686 PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;

1687 PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;

1688

1689 PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __glewDrawArraysInstancedBaseInstanceEXT = NULL;

1690 PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseInstanceEXT = NULL;

1691 PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseVertexBaseInstanceEXT = NULL;

1692

1693 PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL;

1694 PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL;

1695 PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL;

1696

1697 PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;

1698

1699 PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;

1700

1701 PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC __glewBindFragDataLocationIndexedEXT = NULL;

1702 PFNGLGETFRAGDATAINDEXEXTPROC __glewGetFragDataIndexEXT = NULL;

1703 PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC __glewGetProgramResourceLocationIndexEXT = NULL;

1704

1705 PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;

1706

1707 PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;

1708

1709 PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT = NULL;

1710 PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL;

1711

1712 PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT = NULL;

1713 PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT = NULL;

1714

1715 PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;

1716 PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;

1717

1718 PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;

1719 PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;

1720

1721 PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;

1722 PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;

1723 PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;

1724 PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;

1725 PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;

1726 PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;

1727 PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;

1728 PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;

1729 PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;

1730 PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;

1731 PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;

1732 PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;

1733 PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;

1734

1735 PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;

1736 PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;

1737

1738 PFNGLCOPYIMAGESUBDATAEXTPROC __glewCopyImageSubDataEXT = NULL;

1739

1740 PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;

1741 PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;

1742 PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;

1743 PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;

1744 PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;

1745

1746 PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;

1747 PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;

1748

1749 PFNGLGETOBJECTLABELEXTPROC __glewGetObjectLabelEXT = NULL;

1750 PFNGLLABELOBJECTEXTPROC __glewLabelObjectEXT = NULL;

1751

1752 PFNGLINSERTEVENTMARKEREXTPROC __glewInsertEventMarkerEXT = NULL;

1753 PFNGLPOPGROUPMARKEREXTPROC __glewPopGroupMarkerEXT = NULL;

1754 PFNGLPUSHGROUPMARKEREXTPROC __glewPushGroupMarkerEXT = NULL;

1755

1756 PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;

1757

1758 PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL;

1759 PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL;

1760 PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL;

1761 PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL;

1762 PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL;

1763 PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL;

1764 PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL;

1765 PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL;

1766 PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL;

1767 PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL;

1768 PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL;

1769 PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL;

1770 PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL;

1771 PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL;

1772 PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL;

1773 PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL;

1774 PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL;

1775 PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL;

1776 PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL;

1777 PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL;

1778 PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL;

1779 PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL;

1780 PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL;

1781 PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL;

1782 PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL;

1783 PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL;

1784 PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL;

1785 PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL;

1786 PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL;

1787 PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL;

1788 PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL;

1789 PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL;

1790 PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL;

1791 PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL;

1792 PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL;

1793 PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL;

1794 PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL;

1795 PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL;

1796 PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL;

1797 PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL;

1798 PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL;

1799 PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL;

1800 PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL;

1801 PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL;

1802 PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL;

1803 PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL;

1804 PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL;

1805 PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL;

1806 PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL;

1807 PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL;

1808 PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL;

1809 PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL;

1810 PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL;

1811 PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL;

1812 PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL;

1813 PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL;

1814 PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL;

1815 PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL;

1816 PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL;

1817 PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL;

1818 PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL;

1819 PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL;

1820 PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL;

1821 PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL;

1822 PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL;

1823 PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL;

1824 PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL;

1825 PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL;

1826 PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL;

1827 PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL;

1828 PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL;

1829 PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL;

1830 PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL;

1831 PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL;

1832 PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL;

1833 PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL;

1834 PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL;

1835 PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL;

1836 PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL;

1837 PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL;

1838 PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL;

1839 PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL;

1840 PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL;

1841 PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL;

1842 PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL;

1843 PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL;

1844 PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL;

1845 PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL;

1846 PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL;

1847 PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL;

1848 PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL;

1849 PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL;

1850 PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL;

1851 PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL;

1852 PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL;

1853 PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL;

1854 PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL;

1855 PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL;

1856 PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL;

1857 PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL;

1858 PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL;

1859 PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL;

1860 PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL;

1861 PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL;

1862 PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL;

1863 PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL;

1864 PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL;

1865 PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL;

1866 PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL;

1867 PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL;

1868 PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL;

1869 PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL;

1870 PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL;

1871 PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL;

1872 PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL;

1873 PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL;

1874 PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL;

1875 PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL;

1876 PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL;

1877 PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL;

1878 PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL;

1879 PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL;

1880 PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL;

1881 PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL;

1882 PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL;

1883 PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL;

1884 PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;

1885 PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;

1886 PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;

1887 PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;

1888 PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL;

1889 PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;

1890 PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL;

1891 PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL;

1892 PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL;

1893 PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL;

1894 PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL;

1895 PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL;

1896 PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL;

1897 PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL;

1898 PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL;

1899 PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL;

1900 PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL;

1901 PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL;

1902 PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL;

1903 PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL;

1904 PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL;

1905 PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL;

1906 PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL;

1907 PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL;

1908 PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL;

1909 PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL;

1910 PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL;

1911 PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL;

1912 PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL;

1913 PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL;

1914 PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL;

1915 PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL;

1916 PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL;

1917 PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL;

1918 PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL;

1919 PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL;

1920 PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL;

1921 PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL;

1922 PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL;

1923 PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL;

1924 PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL;

1925 PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL;

1926 PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL;

1927 PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL;

1928 PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL;

1929 PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL;

1930 PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL;

1931 PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL;

1932 PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL;

1933 PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL;

1934 PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL;

1935 PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL;

1936 PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL;

1937 PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL;

1938 PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL;

1939 PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL;

1940 PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL;

1941 PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL;

1942 PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL;

1943 PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL;

1944 PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL;

1945 PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL;

1946 PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL;

1947 PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL;

1948 PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL;

1949 PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL;

1950 PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL;

1951 PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL;

1952 PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL;

1953 PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL;

1954 PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL;

1955 PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL;

1956 PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL;

1957 PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL;

1958 PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL;

1959 PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL;

1960 PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL;

1961 PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL;

1962 PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL;

1963 PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL;

1964 PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL;

1965 PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL;

1966 PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL;

1967 PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL;

1968 PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC __glewVertexArrayVertexAttribDivisorEXT = NULL;

1969 PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL;

1970 PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL;

1971 PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL;

1972

1973 PFNGLDISCARDFRAMEBUFFEREXTPROC __glewDiscardFramebufferEXT = NULL;

1974

1975 PFNGLDRAWBUFFERSEXTPROC __glewDrawBuffersEXT = NULL;

1976

1977 PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;

1978 PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;

1979 PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL;

1980 PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL;

1981 PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL;

1982 PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL;

1983

1984 PFNGLBLENDEQUATIONSEPARATEIEXTPROC __glewBlendEquationSeparateiEXT = NULL;

1985 PFNGLBLENDEQUATIONIEXTPROC __glewBlendEquationiEXT = NULL;

1986 PFNGLBLENDFUNCSEPARATEIEXTPROC __glewBlendFuncSeparateiEXT = NULL;

1987 PFNGLBLENDFUNCIEXTPROC __glewBlendFunciEXT = NULL;

1988 PFNGLCOLORMASKIEXTPROC __glewColorMaskiEXT = NULL;

1989 PFNGLDISABLEIEXTPROC __glewDisableiEXT = NULL;

1990 PFNGLENABLEIEXTPROC __glewEnableiEXT = NULL;

1991 PFNGLISENABLEDIEXTPROC __glewIsEnablediEXT = NULL;

1992

1993 PFNGLDRAWELEMENTSBASEVERTEXEXTPROC __glewDrawElementsBaseVertexEXT = NULL;

1994 PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC __glewDrawElementsInstancedBaseVertexEXT = NULL;

1995 PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC __glewDrawRangeElementsBaseVertexEXT = NULL;

1996 PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC __glewMultiDrawElementsBaseVertexEXT = NULL;

1997

1998 PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL;

1999 PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL;

2000

2001 PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;

2002

2003 PFNGLBUFFERSTORAGEEXTERNALEXTPROC __glewBufferStorageExternalEXT = NULL;

2004 PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC __glewNamedBufferStorageExternalEXT = NULL;

2005

2006 PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;

2007 PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;

2008 PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;

2009 PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;

2010 PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;

2011

2012 PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;

2013 PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;

2014 PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;

2015 PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;

2016 PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;

2017 PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;

2018 PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;

2019 PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;

2020 PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;

2021 PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;

2022 PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;

2023 PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;

2024 PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;

2025 PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;

2026 PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;

2027 PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;

2028 PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;

2029 PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;

2030

2031 PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;

2032

2033 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;

2034

2035 PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;

2036 PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;

2037 PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;

2038 PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;

2039 PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;

2040 PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;

2041 PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;

2042 PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;

2043 PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;

2044 PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;

2045 PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;

2046 PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;

2047 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;

2048 PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;

2049 PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;

2050 PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;

2051 PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;

2052

2053 PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL;

2054 PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL;

2055 PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL;

2056

2057 PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL;

2058 PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL;

2059

2060 PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL;

2061 PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL;

2062 PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL;

2063 PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL;

2064 PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL;

2065 PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL;

2066 PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL;

2067 PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL;

2068 PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL;

2069 PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL;

2070 PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL;

2071 PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL;

2072 PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL;

2073 PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL;

2074 PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL;

2075 PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL;

2076 PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL;

2077 PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL;

2078 PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL;

2079 PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL;

2080 PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL;

2081 PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL;

2082 PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL;

2083 PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL;

2084 PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL;

2085 PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL;

2086 PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL;

2087 PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL;

2088 PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL;

2089 PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL;

2090 PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL;

2091 PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL;

2092 PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL;

2093 PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL;

2094

2095 PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;

2096 PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;

2097 PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;

2098 PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;

2099 PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;

2100 PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;

2101 PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;

2102 PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;

2103 PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;

2104 PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;

2105

2106 PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;

2107

2108 PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;

2109

2110 PFNGLVERTEXATTRIBDIVISOREXTPROC __glewVertexAttribDivisorEXT = NULL;

2111

2112 PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;

2113 PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;

2114 PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;

2115

2116 PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC __glewFlushMappedBufferRangeEXT = NULL;

2117 PFNGLMAPBUFFERRANGEEXTPROC __glewMapBufferRangeEXT = NULL;

2118

2119 PFNGLBUFFERSTORAGEMEMEXTPROC __glewBufferStorageMemEXT = NULL;

2120 PFNGLCREATEMEMORYOBJECTSEXTPROC __glewCreateMemoryObjectsEXT = NULL;

2121 PFNGLDELETEMEMORYOBJECTSEXTPROC __glewDeleteMemoryObjectsEXT = NULL;

2122 PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC __glewGetMemoryObjectParameterivEXT = NULL;

2123 PFNGLGETUNSIGNEDBYTEI_VEXTPROC __glewGetUnsignedBytei_vEXT = NULL;

2124 PFNGLGETUNSIGNEDBYTEVEXTPROC __glewGetUnsignedBytevEXT = NULL;

2125 PFNGLISMEMORYOBJECTEXTPROC __glewIsMemoryObjectEXT = NULL;

2126 PFNGLMEMORYOBJECTPARAMETERIVEXTPROC __glewMemoryObjectParameterivEXT = NULL;

2127 PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC __glewNamedBufferStorageMemEXT = NULL;

2128 PFNGLTEXSTORAGEMEM1DEXTPROC __glewTexStorageMem1DEXT = NULL;

2129 PFNGLTEXSTORAGEMEM2DEXTPROC __glewTexStorageMem2DEXT = NULL;

2130 PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC __glewTexStorageMem2DMultisampleEXT = NULL;

2131 PFNGLTEXSTORAGEMEM3DEXTPROC __glewTexStorageMem3DEXT = NULL;

2132 PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC __glewTexStorageMem3DMultisampleEXT = NULL;

2133 PFNGLTEXTURESTORAGEMEM1DEXTPROC __glewTextureStorageMem1DEXT = NULL;

2134 PFNGLTEXTURESTORAGEMEM2DEXTPROC __glewTextureStorageMem2DEXT = NULL;

2135 PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC __glewTextureStorageMem2DMultisampleEXT = NULL;

2136 PFNGLTEXTURESTORAGEMEM3DEXTPROC __glewTextureStorageMem3DEXT = NULL;

2137 PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC __glewTextureStorageMem3DMultisampleEXT = NULL;

2138

2139 PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT = NULL;

2140

2141 PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT = NULL;

2142 PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT = NULL;

2143

2144 PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;

2145 PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;

2146

2147 PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC __glewMultiDrawArraysIndirectEXT = NULL;

2148 PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC __glewMultiDrawElementsIndirectEXT = NULL;

2149

2150 PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;

2151 PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;

2152

2153 PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC __glewFramebufferTexture2DMultisampleEXT = NULL;

2154

2155 PFNGLDRAWBUFFERSINDEXEDEXTPROC __glewDrawBuffersIndexedEXT = NULL;

2156 PFNGLGETINTEGERI_VEXTPROC __glewGetIntegeri_vEXT = NULL;

2157 PFNGLREADBUFFERINDEXEDEXTPROC __glewReadBufferIndexedEXT = NULL;

2158

2159 PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;

2160 PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;

2161 PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;

2162 PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;

2163

2164 PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;

2165 PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;

2166 PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;

2167 PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;

2168 PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;

2169 PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;

2170

2171 PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;

2172 PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;

2173

2174 PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;

2175

2176 PFNGLPOLYGONOFFSETCLAMPEXTPROC __glewPolygonOffsetClampEXT = NULL;

2177

2178 PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL;

2179

2180 PFNGLCOVERAGEMODULATIONNVPROC __glewCoverageModulationNV = NULL;

2181 PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTableNV = NULL;

2182 PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV = NULL;

2183 PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT = NULL;

2184

2185 PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;

2186 PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;

2187

2188 PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;

2189 PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;

2190 PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;

2191 PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;

2192 PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;

2193 PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;

2194 PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;

2195 PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;

2196 PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;

2197 PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;

2198 PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;

2199 PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;

2200 PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;

2201 PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;

2202 PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;

2203 PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;

2204 PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;

2205

2206 PFNGLDELETESEMAPHORESEXTPROC __glewDeleteSemaphoresEXT = NULL;

2207 PFNGLGENSEMAPHORESEXTPROC __glewGenSemaphoresEXT = NULL;

2208 PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC __glewGetSemaphoreParameterui64vEXT = NULL;

2209 PFNGLISSEMAPHOREEXTPROC __glewIsSemaphoreEXT = NULL;

2210 PFNGLSEMAPHOREPARAMETERUI64VEXTPROC __glewSemaphoreParameterui64vEXT = NULL;

2211 PFNGLSIGNALSEMAPHOREEXTPROC __glewSignalSemaphoreEXT = NULL;

2212 PFNGLWAITSEMAPHOREEXTPROC __glewWaitSemaphoreEXT = NULL;

2213

2214 PFNGLIMPORTSEMAPHOREFDEXTPROC __glewImportSemaphoreFdEXT = NULL;

2215

2216 PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC __glewImportSemaphoreWin32HandleEXT = NULL;

2217 PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC __glewImportSemaphoreWin32NameEXT = NULL;

2218

2219 PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL;

2220 PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL;

2221 PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL;

2222

2223 PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL;

2224 PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL;

2225

2226 PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC __glewClearPixelLocalStorageuiEXT = NULL;

2227 PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPixelLocalStorageSizeEXT = NULL;

2228 PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT = NULL;

2229

2230 PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT = NULL;

2231 PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL;

2232

2233 PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;

2234

2235 PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;

2236 PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;

2237 PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;

2238

2239 PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;

2240

2241 PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL;

2242

2243 PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL;

2244

2245 PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL;

2246 PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL;

2247 PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL;

2248 PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL;

2249 PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL;

2250 PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL;

2251

2252 PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;

2253 PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;

2254 PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;

2255 PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;

2256 PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;

2257 PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;

2258

2259 PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;

2260

2261 PFNGLTEXSTORAGE1DEXTPROC __glewTexStorage1DEXT = NULL;

2262 PFNGLTEXSTORAGE2DEXTPROC __glewTexStorage2DEXT = NULL;

2263 PFNGLTEXSTORAGE3DEXTPROC __glewTexStorage3DEXT = NULL;

2264 PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL;

2265 PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL;

2266 PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL;

2267

2268 PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT = NULL;

2269

2270 PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;

2271 PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL;

2272

2273 PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL;

2274 PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL;

2275 PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL;

2276 PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL;

2277 PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL;

2278 PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL;

2279 PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL;

2280

2281 PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;

2282 PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;

2283 PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;

2284 PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;

2285 PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;

2286 PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;

2287 PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;

2288 PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;

2289

2290 PFNGLBINDARRAYSETEXTPROC __glewBindArraySetEXT = NULL;

2291 PFNGLCREATEARRAYSETEXTPROC __glewCreateArraySetExt = NULL;

2292 PFNGLDELETEARRAYSETSEXTPROC __glewDeleteArraySetsEXT = NULL;

2293

2294 PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL;

2295 PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL;

2296 PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL;

2297 PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL;

2298 PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL;

2299 PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL;

2300 PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL;

2301 PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL;

2302 PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL;

2303 PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL;

2304 PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL;

2305

2306 PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;

2307 PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;

2308 PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;

2309 PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;

2310 PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;

2311 PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;

2312 PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;

2313 PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;

2314 PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;

2315 PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;

2316 PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;

2317 PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;

2318 PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;

2319 PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;

2320 PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;

2321 PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;

2322 PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;

2323 PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;

2324 PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;

2325 PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;

2326 PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;

2327 PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;

2328 PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;

2329 PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;

2330 PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;

2331 PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;

2332 PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;

2333 PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;

2334 PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;

2335 PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;

2336 PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;

2337 PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;

2338 PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;

2339 PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;

2340 PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;

2341 PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;

2342 PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;

2343 PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;

2344 PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;

2345 PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;

2346 PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;

2347 PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;

2348

2349 PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;

2350 PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;

2351 PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;

2352

2353 PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC __glewAcquireKeyedMutexWin32EXT = NULL;

2354 PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC __glewReleaseKeyedMutexWin32EXT = NULL;

2355

2356 PFNGLWINDOWRECTANGLESEXTPROC __glewWindowRectanglesEXT = NULL;

2357

2358 PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL;

2359

2360 PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL;

2361

2362 PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL;

2363

2364 PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;

2365 PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;

2366 PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;

2367 PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;

2368 PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;

2369 PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;

2370

2371 PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;

2372 PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;

2373

2374 PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;

2375 PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;

2376 PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;

2377 PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;

2378 PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;

2379 PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;

2380 PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;

2381 PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;

2382

2383 PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL = NULL;

2384 PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL = NULL;

2385 PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL = NULL;

2386

2387 PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;

2388 PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;

2389 PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;

2390 PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;

2391

2392 PFNGLBEGINPERFQUERYINTELPROC __glewBeginPerfQueryINTEL = NULL;

2393 PFNGLCREATEPERFQUERYINTELPROC __glewCreatePerfQueryINTEL = NULL;

2394 PFNGLDELETEPERFQUERYINTELPROC __glewDeletePerfQueryINTEL = NULL;

2395 PFNGLENDPERFQUERYINTELPROC __glewEndPerfQueryINTEL = NULL;

2396 PFNGLGETFIRSTPERFQUERYIDINTELPROC __glewGetFirstPerfQueryIdINTEL = NULL;

2397 PFNGLGETNEXTPERFQUERYIDINTELPROC __glewGetNextPerfQueryIdINTEL = NULL;

2398 PFNGLGETPERFCOUNTERINFOINTELPROC __glewGetPerfCounterInfoINTEL = NULL;

2399 PFNGLGETPERFQUERYDATAINTELPROC __glewGetPerfQueryDataINTEL = NULL;

2400 PFNGLGETPERFQUERYIDBYNAMEINTELPROC __glewGetPerfQueryIdByNameINTEL = NULL;

2401 PFNGLGETPERFQUERYINFOINTELPROC __glewGetPerfQueryInfoINTEL = NULL;

2402

2403 PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;

2404 PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;

2405

2406 PFNGLBLENDBARRIERKHRPROC __glewBlendBarrierKHR = NULL;

2407

2408 PFNGLDEBUGMESSAGECALLBACKPROC __glewDebugMessageCallback = NULL;

2409 PFNGLDEBUGMESSAGECONTROLPROC __glewDebugMessageControl = NULL;

2410 PFNGLDEBUGMESSAGEINSERTPROC __glewDebugMessageInsert = NULL;

2411 PFNGLGETDEBUGMESSAGELOGPROC __glewGetDebugMessageLog = NULL;

2412 PFNGLGETOBJECTLABELPROC __glewGetObjectLabel = NULL;

2413 PFNGLGETOBJECTPTRLABELPROC __glewGetObjectPtrLabel = NULL;

2414 PFNGLOBJECTLABELPROC __glewObjectLabel = NULL;

2415 PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel = NULL;

2416 PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup = NULL;

2417 PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup = NULL;

2418

2419 PFNGLMAXSHADERCOMPILERTHREADSKHRPROC __glewMaxShaderCompilerThreadsKHR = NULL;

2420

2421 PFNGLGETNUNIFORMFVPROC __glewGetnUniformfv = NULL;

2422 PFNGLGETNUNIFORMIVPROC __glewGetnUniformiv = NULL;

2423 PFNGLGETNUNIFORMUIVPROC __glewGetnUniformuiv = NULL;

2424 PFNGLREADNPIXELSPROC __glewReadnPixels = NULL;

2425

2426 PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled = NULL;

2427 PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion = NULL;

2428 PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion = NULL;

2429 PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion = NULL;

2430 PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion = NULL;

2431

2432 PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;

2433

2434 PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;

2435 PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;

2436 PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;

2437 PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;

2438 PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;

2439 PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;

2440 PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;

2441 PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;

2442 PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;

2443 PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;

2444 PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;

2445 PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;

2446 PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;

2447 PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;

2448 PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;

2449 PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;

2450 PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;

2451 PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;

2452 PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;

2453 PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;

2454 PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;

2455 PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;

2456 PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;

2457 PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;

2458

2459 PFNGLBEGINCONDITIONALRENDERNVXPROC __glewBeginConditionalRenderNVX = NULL;

2460 PFNGLENDCONDITIONALRENDERNVXPROC __glewEndConditionalRenderNVX = NULL;

2461

2462 PFNGLLGPUCOPYIMAGESUBDATANVXPROC __glewLGPUCopyImageSubDataNVX = NULL;

2463 PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX = NULL;

2464 PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX = NULL;

2465

2466 PFNGLSTEREOPARAMETERFNVPROC __glewStereoParameterfNV = NULL;

2467 PFNGLSTEREOPARAMETERINVPROC __glewStereoParameteriNV = NULL;

2468

2469 PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC __glewMultiDrawArraysIndirectBindlessNV = NULL;

2470 PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC __glewMultiDrawElementsIndirectBindlessNV = NULL;

2471

2472 PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC __glewMultiDrawArraysIndirectBindlessCountNV = NULL;

2473 PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC __glewMultiDrawElementsIndirectBindlessCountNV = NULL;

2474

2475 PFNGLGETIMAGEHANDLENVPROC __glewGetImageHandleNV = NULL;

2476 PFNGLGETTEXTUREHANDLENVPROC __glewGetTextureHandleNV = NULL;

2477 PFNGLGETTEXTURESAMPLERHANDLENVPROC __glewGetTextureSamplerHandleNV = NULL;

2478 PFNGLISIMAGEHANDLERESIDENTNVPROC __glewIsImageHandleResidentNV = NULL;

2479 PFNGLISTEXTUREHANDLERESIDENTNVPROC __glewIsTextureHandleResidentNV = NULL;

2480 PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC __glewMakeImageHandleNonResidentNV = NULL;

2481 PFNGLMAKEIMAGEHANDLERESIDENTNVPROC __glewMakeImageHandleResidentNV = NULL;

2482 PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC __glewMakeTextureHandleNonResidentNV = NULL;

2483 PFNGLMAKETEXTUREHANDLERESIDENTNVPROC __glewMakeTextureHandleResidentNV = NULL;

2484 PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC __glewProgramUniformHandleui64NV = NULL;

2485 PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC __glewProgramUniformHandleui64vNV = NULL;

2486 PFNGLUNIFORMHANDLEUI64NVPROC __glewUniformHandleui64NV = NULL;

2487 PFNGLUNIFORMHANDLEUI64VNVPROC __glewUniformHandleui64vNV = NULL;

2488

2489 PFNGLBLENDBARRIERNVPROC __glewBlendBarrierNV = NULL;

2490 PFNGLBLENDPARAMETERINVPROC __glewBlendParameteriNV = NULL;

2491

2492 PFNGLVIEWPORTPOSITIONWSCALENVPROC __glewViewportPositionWScaleNV = NULL;

2493

2494 PFNGLCALLCOMMANDLISTNVPROC __glewCallCommandListNV = NULL;

2495 PFNGLCOMMANDLISTSEGMENTSNVPROC __glewCommandListSegmentsNV = NULL;

2496 PFNGLCOMPILECOMMANDLISTNVPROC __glewCompileCommandListNV = NULL;

2497 PFNGLCREATECOMMANDLISTSNVPROC __glewCreateCommandListsNV = NULL;

2498 PFNGLCREATESTATESNVPROC __glewCreateStatesNV = NULL;

2499 PFNGLDELETECOMMANDLISTSNVPROC __glewDeleteCommandListsNV = NULL;

2500 PFNGLDELETESTATESNVPROC __glewDeleteStatesNV = NULL;

2501 PFNGLDRAWCOMMANDSADDRESSNVPROC __glewDrawCommandsAddressNV = NULL;

2502 PFNGLDRAWCOMMANDSNVPROC __glewDrawCommandsNV = NULL;

2503 PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC __glewDrawCommandsStatesAddressNV = NULL;

2504 PFNGLDRAWCOMMANDSSTATESNVPROC __glewDrawCommandsStatesNV = NULL;

2505 PFNGLGETCOMMANDHEADERNVPROC __glewGetCommandHeaderNV = NULL;

2506 PFNGLGETSTAGEINDEXNVPROC __glewGetStageIndexNV = NULL;

2507 PFNGLISCOMMANDLISTNVPROC __glewIsCommandListNV = NULL;

2508 PFNGLISSTATENVPROC __glewIsStateNV = NULL;

2509 PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC __glewListDrawCommandsStatesClientNV = NULL;

2510 PFNGLSTATECAPTURENVPROC __glewStateCaptureNV = NULL;

2511

2512 PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL;

2513 PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL;

2514

2515 PFNGLSUBPIXELPRECISIONBIASNVPROC __glewSubpixelPrecisionBiasNV = NULL;

2516

2517 PFNGLCONSERVATIVERASTERPARAMETERFNVPROC __glewConservativeRasterParameterfNV = NULL;

2518

2519 PFNGLCONSERVATIVERASTERPARAMETERINVPROC __glewConservativeRasterParameteriNV = NULL;

2520

2521 PFNGLCOPYBUFFERSUBDATANVPROC __glewCopyBufferSubDataNV = NULL;

2522

2523 PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL;

2524

2525 PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;

2526 PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;

2527 PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;

2528

2529 PFNGLDRAWBUFFERSNVPROC __glewDrawBuffersNV = NULL;

2530

2531 PFNGLDRAWARRAYSINSTANCEDNVPROC __glewDrawArraysInstancedNV = NULL;

2532 PFNGLDRAWELEMENTSINSTANCEDNVPROC __glewDrawElementsInstancedNV = NULL;

2533

2534 PFNGLDRAWTEXTURENVPROC __glewDrawTextureNV = NULL;

2535

2536 PFNGLDRAWVKIMAGENVPROC __glewDrawVkImageNV = NULL;

2537 PFNGLGETVKPROCADDRNVPROC __glewGetVkProcAddrNV = NULL;

2538 PFNGLSIGNALVKFENCENVPROC __glewSignalVkFenceNV = NULL;

2539 PFNGLSIGNALVKSEMAPHORENVPROC __glewSignalVkSemaphoreNV = NULL;

2540 PFNGLWAITVKSEMAPHORENVPROC __glewWaitVkSemaphoreNV = NULL;

2541

2542 PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;

2543 PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;

2544 PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;

2545 PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;

2546 PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;

2547 PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;

2548 PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;

2549 PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;

2550 PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;

2551

2552 PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL;

2553 PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL;

2554 PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL;

2555

2556 PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;

2557 PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;

2558 PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;

2559 PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;

2560 PFNGLISFENCENVPROC __glewIsFenceNV = NULL;

2561 PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;

2562 PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;

2563

2564 PFNGLFRAGMENTCOVERAGECOLORNVPROC __glewFragmentCoverageColorNV = NULL;

2565

2566 PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;

2567 PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;

2568 PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;

2569 PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;

2570 PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;

2571 PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;

2572

2573 PFNGLBLITFRAMEBUFFERNVPROC __glewBlitFramebufferNV = NULL;

2574

2575 PFNGLRENDERBUFFERSTORAGEMULTISAMPLENVPROC __glewRenderbufferStorageMultisampleNV = NULL;

2576

2577 PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL;

2578

2579 PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL;

2580

2581 PFNGLMULTICASTBARRIERNVPROC __glewMulticastBarrierNV = NULL;

2582 PFNGLMULTICASTBLITFRAMEBUFFERNVPROC __glewMulticastBlitFramebufferNV = NULL;

2583 PFNGLMULTICASTBUFFERSUBDATANVPROC __glewMulticastBufferSubDataNV = NULL;

2584 PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC __glewMulticastCopyBufferSubDataNV = NULL;

2585 PFNGLMULTICASTCOPYIMAGESUBDATANVPROC __glewMulticastCopyImageSubDataNV = NULL;

2586 PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewMulticastFramebufferSampleLocationsfvNV = NULL;

2587 PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC __glewMulticastGetQueryObjecti64vNV = NULL;

2588 PFNGLMULTICASTGETQUERYOBJECTIVNVPROC __glewMulticastGetQueryObjectivNV = NULL;

2589 PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC __glewMulticastGetQueryObjectui64vNV = NULL;

2590 PFNGLMULTICASTGETQUERYOBJECTUIVNVPROC __glewMulticastGetQueryObjectuivNV = NULL;

2591 PFNGLMULTICASTWAITSYNCNVPROC __glewMulticastWaitSyncNV = NULL;

2592 PFNGLRENDERGPUMASKNVPROC __glewRenderGpuMaskNV = NULL;

2593

2594 PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL;

2595 PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL;

2596 PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL;

2597 PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL;

2598 PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL;

2599 PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL;

2600 PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL;

2601 PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL;

2602 PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL;

2603 PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;

2604 PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;

2605 PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;

2606

2607 PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL;

2608 PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL;

2609 PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL;

2610 PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL;

2611 PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL;

2612 PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL;

2613 PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL;

2614 PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL;

2615 PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL;

2616 PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL;

2617 PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL;

2618 PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL;

2619 PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL;

2620 PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL;

2621 PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL;

2622 PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL;

2623 PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL;

2624 PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL;

2625 PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL;

2626 PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL;

2627 PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL;

2628 PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL;

2629 PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL;

2630 PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL;

2631 PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL;

2632 PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL;

2633 PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL;

2634 PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL;

2635 PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL;

2636 PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL;

2637 PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL;

2638 PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL;

2639 PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL;

2640 PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL;

2641

2642 PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;

2643 PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;

2644 PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;

2645 PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;

2646 PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;

2647 PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;

2648 PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;

2649 PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;

2650 PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;

2651 PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;

2652 PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;

2653 PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;

2654 PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;

2655 PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;

2656 PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;

2657 PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;

2658 PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;

2659 PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;

2660 PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;

2661 PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;

2662 PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;

2663 PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;

2664 PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;

2665 PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;

2666 PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;

2667 PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;

2668 PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;

2669 PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;

2670 PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;

2671 PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;

2672 PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;

2673 PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;

2674 PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;

2675 PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;

2676 PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;

2677 PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;

2678 PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;

2679 PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;

2680 PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;

2681 PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;

2682 PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;

2683 PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;

2684 PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;

2685 PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;

2686 PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;

2687 PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;

2688

2689 PFNGLVERTEXATTRIBDIVISORNVPROC __glewVertexAttribDivisorNV = NULL;

2690

2691 PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV = NULL;

2692

2693 PFNGLUNIFORMMATRIX2X3FVNVPROC __glewUniformMatrix2x3fvNV = NULL;

2694 PFNGLUNIFORMMATRIX2X4FVNVPROC __glewUniformMatrix2x4fvNV = NULL;

2695 PFNGLUNIFORMMATRIX3X2FVNVPROC __glewUniformMatrix3x2fvNV = NULL;

2696 PFNGLUNIFORMMATRIX3X4FVNVPROC __glewUniformMatrix3x4fvNV = NULL;

2697 PFNGLUNIFORMMATRIX4X2FVNVPROC __glewUniformMatrix4x2fvNV = NULL;

2698 PFNGLUNIFORMMATRIX4X3FVNVPROC __glewUniformMatrix4x3fvNV = NULL;

2699

2700 PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;

2701 PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;

2702 PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;

2703 PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;

2704 PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;

2705 PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;

2706 PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;

2707

2708 PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL;

2709 PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL;

2710 PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL;

2711

2712 PFNGLCOPYPATHNVPROC __glewCopyPathNV = NULL;

2713 PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV = NULL;

2714 PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV = NULL;

2715 PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV = NULL;

2716 PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV = NULL;

2717 PFNGLDELETEPATHSNVPROC __glewDeletePathsNV = NULL;

2718 PFNGLGENPATHSNVPROC __glewGenPathsNV = NULL;

2719 PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV = NULL;

2720 PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV = NULL;

2721 PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV = NULL;

2722 PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV = NULL;

2723 PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV = NULL;

2724 PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV = NULL;

2725 PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV = NULL;

2726 PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV = NULL;

2727 PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV = NULL;

2728 PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV = NULL;

2729 PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV = NULL;

2730 PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV = NULL;

2731 PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV = NULL;

2732 PFNGLGETPROGRAMRESOURCEFVNVPROC __glewGetProgramResourcefvNV = NULL;

2733 PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV = NULL;

2734 PFNGLISPATHNVPROC __glewIsPathNV = NULL;

2735 PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV = NULL;

2736 PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV = NULL;

2737 PFNGLMATRIXLOAD3X2FNVPROC __glewMatrixLoad3x2fNV = NULL;

2738 PFNGLMATRIXLOAD3X3FNVPROC __glewMatrixLoad3x3fNV = NULL;

2739 PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC __glewMatrixLoadTranspose3x3fNV = NULL;

2740 PFNGLMATRIXMULT3X2FNVPROC __glewMatrixMult3x2fNV = NULL;

2741 PFNGLMATRIXMULT3X3FNVPROC __glewMatrixMult3x3fNV = NULL;

2742 PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC __glewMatrixMultTranspose3x3fNV = NULL;

2743 PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV = NULL;

2744 PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV = NULL;

2745 PFNGLPATHCOORDSNVPROC __glewPathCoordsNV = NULL;

2746 PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV = NULL;

2747 PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV = NULL;

2748 PFNGLPATHFOGGENNVPROC __glewPathFogGenNV = NULL;

2749 PFNGLPATHGLYPHINDEXARRAYNVPROC __glewPathGlyphIndexArrayNV = NULL;

2750 PFNGLPATHGLYPHINDEXRANGENVPROC __glewPathGlyphIndexRangeNV = NULL;

2751 PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV = NULL;

2752 PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV = NULL;

2753 PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC __glewPathMemoryGlyphIndexArrayNV = NULL;

2754 PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV = NULL;

2755 PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV = NULL;

2756 PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV = NULL;

2757 PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV = NULL;

2758 PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV = NULL;

2759 PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV = NULL;

2760 PFNGLPATHSTRINGNVPROC __glewPathStringNV = NULL;

2761 PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV = NULL;

2762 PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV = NULL;

2763 PFNGLPATHTEXGENNVPROC __glewPathTexGenNV = NULL;

2764 PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV = NULL;

2765 PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC __glewProgramPathFragmentInputGenNV = NULL;

2766 PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV = NULL;

2767 PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV = NULL;

2768 PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV = NULL;

2769 PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV = NULL;

2770 PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC __glewStencilThenCoverFillPathInstancedNV = NULL;

2771 PFNGLSTENCILTHENCOVERFILLPATHNVPROC __glewStencilThenCoverFillPathNV = NULL;

2772 PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC __glewStencilThenCoverStrokePathInstancedNV = NULL;

2773 PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC __glewStencilThenCoverStrokePathNV = NULL;

2774 PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV = NULL;

2775 PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV = NULL;

2776

2777 PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;

2778 PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;

2779

2780 PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;

2781 PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;

2782

2783 PFNGLPOLYGONMODENVPROC __glewPolygonModeNV = NULL;

2784

2785 PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL;

2786 PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL;

2787 PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL;

2788 PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL;

2789 PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL;

2790 PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL;

2791

2792 PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;

2793 PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;

2794

2795 PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;

2796 PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;

2797 PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;

2798 PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;

2799 PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;

2800 PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;

2801 PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;

2802 PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;

2803 PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;

2804 PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;

2805 PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;

2806 PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;

2807 PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;

2808

2809 PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;

2810 PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;

2811

2812 PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewFramebufferSampleLocationsfvNV = NULL;

2813 PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewNamedFramebufferSampleLocationsfvNV = NULL;

2814

2815 PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL;

2816 PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL;

2817 PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL;

2818 PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL;

2819 PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL;

2820 PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL;

2821 PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL;

2822 PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL;

2823 PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL;

2824 PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL;

2825 PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL;

2826 PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL;

2827 PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL;

2828

2829 PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV = NULL;

2830 PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV = NULL;

2831 PFNGLCOPYTEXSUBIMAGE3DNVPROC __glewCopyTexSubImage3DNV = NULL;

2832 PFNGLFRAMEBUFFERTEXTURELAYERNVPROC __glewFramebufferTextureLayerNV = NULL;

2833 PFNGLTEXIMAGE3DNVPROC __glewTexImage3DNV = NULL;

2834 PFNGLTEXSUBIMAGE3DNVPROC __glewTexSubImage3DNV = NULL;

2835

2836 PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL;

2837

2838 PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL;

2839 PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV = NULL;

2840 PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV = NULL;

2841 PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL;

2842 PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL;

2843 PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL;

2844

2845 PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;

2846 PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;

2847 PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;

2848 PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL;

2849 PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL;

2850 PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL;

2851 PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL;

2852 PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL;

2853 PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;

2854 PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;

2855 PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;

2856

2857 PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL;

2858 PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL;

2859 PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL;

2860 PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL;

2861 PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL;

2862 PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL;

2863 PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL;

2864

2865 PFNGLVDPAUFININVPROC __glewVDPAUFiniNV = NULL;

2866 PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV = NULL;

2867 PFNGLVDPAUINITNVPROC __glewVDPAUInitNV = NULL;

2868 PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV = NULL;

2869 PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV = NULL;

2870 PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV = NULL;

2871 PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV = NULL;

2872 PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV = NULL;

2873 PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV = NULL;

2874 PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV = NULL;

2875

2876 PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;

2877 PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;

2878

2879 PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL;

2880 PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL;

2881 PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL;

2882 PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL;

2883 PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL;

2884 PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL;

2885 PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL;

2886 PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL;

2887 PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL;

2888 PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL;

2889 PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL;

2890 PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL;

2891 PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL;

2892 PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL;

2893 PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL;

2894 PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL;

2895 PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL;

2896 PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL;

2897 PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL;

2898

2899 PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL;

2900 PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL;

2901 PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL;

2902 PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL;

2903 PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL;

2904 PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL;

2905 PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL;

2906 PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL;

2907 PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL;

2908 PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL;

2909 PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL;

2910 PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL;

2911

2912 PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;

2913 PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;

2914 PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;

2915 PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;

2916 PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;

2917 PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;

2918 PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;

2919 PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;

2920 PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;

2921 PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;

2922 PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;

2923 PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;

2924 PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;

2925 PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;

2926 PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;

2927 PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;

2928 PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;

2929 PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;

2930 PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;

2931 PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;

2932 PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;

2933 PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;

2934 PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;

2935 PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;

2936 PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;

2937 PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;

2938 PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;

2939 PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;

2940 PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;

2941 PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;

2942 PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;

2943 PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;

2944 PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;

2945 PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;

2946 PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;

2947 PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;

2948 PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;

2949 PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;

2950 PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;

2951 PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;

2952 PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;

2953 PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;

2954 PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;

2955 PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;

2956 PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;

2957 PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;

2958 PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;

2959 PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;

2960 PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;

2961 PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;

2962 PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;

2963 PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;

2964 PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;

2965 PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;

2966 PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;

2967 PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;

2968 PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;

2969 PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;

2970 PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;

2971 PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;

2972 PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;

2973 PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;

2974 PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;

2975 PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;

2976

2977 PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV = NULL;

2978 PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV = NULL;

2979 PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV = NULL;

2980 PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV = NULL;

2981 PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV = NULL;

2982 PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV = NULL;

2983 PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV = NULL;

2984 PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV = NULL;

2985 PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV = NULL;

2986 PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = NULL;

2987 PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL;

2988 PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL;

2989

2990 PFNGLDEPTHRANGEARRAYFVNVPROC __glewDepthRangeArrayfvNV = NULL;

2991 PFNGLDEPTHRANGEINDEXEDFNVPROC __glewDepthRangeIndexedfNV = NULL;

2992 PFNGLDISABLEINVPROC __glewDisableiNV = NULL;

2993 PFNGLENABLEINVPROC __glewEnableiNV = NULL;

2994 PFNGLGETFLOATI_VNVPROC __glewGetFloati_vNV = NULL;

2995 PFNGLISENABLEDINVPROC __glewIsEnablediNV = NULL;

2996 PFNGLSCISSORARRAYVNVPROC __glewScissorArrayvNV = NULL;

2997 PFNGLSCISSORINDEXEDNVPROC __glewScissorIndexedNV = NULL;

2998 PFNGLSCISSORINDEXEDVNVPROC __glewScissorIndexedvNV = NULL;

2999 PFNGLVIEWPORTARRAYVNVPROC __glewViewportArrayvNV = NULL;

3000 PFNGLVIEWPORTINDEXEDFNVPROC __glewViewportIndexedfNV = NULL;

3001 PFNGLVIEWPORTINDEXEDFVNVPROC __glewViewportIndexedfvNV = NULL;

3002

3003 PFNGLVIEWPORTSWIZZLENVPROC __glewViewportSwizzleNV = NULL;

3004

3005 PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR = NULL;

3006

3007 PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __glewFramebufferTextureMultisampleMultiviewOVR = NULL;

3008

3009 PFNGLALPHAFUNCQCOMPROC __glewAlphaFuncQCOM = NULL;

3010

3011 PFNGLDISABLEDRIVERCONTROLQCOMPROC __glewDisableDriverControlQCOM = NULL;

3012 PFNGLENABLEDRIVERCONTROLQCOMPROC __glewEnableDriverControlQCOM = NULL;

3013 PFNGLGETDRIVERCONTROLSTRINGQCOMPROC __glewGetDriverControlStringQCOM = NULL;

3014 PFNGLGETDRIVERCONTROLSQCOMPROC __glewGetDriverControlsQCOM = NULL;

3015

3016 PFNGLEXTGETBUFFERPOINTERVQCOMPROC __glewExtGetBufferPointervQCOM = NULL;

3017 PFNGLEXTGETBUFFERSQCOMPROC __glewExtGetBuffersQCOM = NULL;

3018 PFNGLEXTGETFRAMEBUFFERSQCOMPROC __glewExtGetFramebuffersQCOM = NULL;

3019 PFNGLEXTGETRENDERBUFFERSQCOMPROC __glewExtGetRenderbuffersQCOM = NULL;

3020 PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC __glewExtGetTexLevelParameterivQCOM = NULL;

3021 PFNGLEXTGETTEXSUBIMAGEQCOMPROC __glewExtGetTexSubImageQCOM = NULL;

3022 PFNGLEXTGETTEXTURESQCOMPROC __glewExtGetTexturesQCOM = NULL;

3023 PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC __glewExtTexObjectStateOverrideiQCOM = NULL;

3024

3025 PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC __glewExtGetProgramBinarySourceQCOM = NULL;

3026 PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM = NULL;

3027 PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM = NULL;

3028 PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM = NULL;

3029

3030 PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM = NULL;

3031 PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM = NULL;

3032

3033 PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM = NULL;

3034

3035 PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM = NULL;

3036 PFNGLSTARTTILINGQCOMPROC __glewStartTilingQCOM = NULL;

3037

3038 PFNGLALPHAFUNCXPROC __glewAlphaFuncx = NULL;

3039 PFNGLCLEARCOLORXPROC __glewClearColorx = NULL;

3040 PFNGLCLEARDEPTHXPROC __glewClearDepthx = NULL;

3041 PFNGLCOLOR4XPROC __glewColor4x = NULL;

3042 PFNGLDEPTHRANGEXPROC __glewDepthRangex = NULL;

3043 PFNGLFOGXPROC __glewFogx = NULL;

3044 PFNGLFOGXVPROC __glewFogxv = NULL;

3045 PFNGLFRUSTUMFPROC __glewFrustumf = NULL;

3046 PFNGLFRUSTUMXPROC __glewFrustumx = NULL;

3047 PFNGLLIGHTMODELXPROC __glewLightModelx = NULL;

3048 PFNGLLIGHTMODELXVPROC __glewLightModelxv = NULL;

3049 PFNGLLIGHTXPROC __glewLightx = NULL;

3050 PFNGLLIGHTXVPROC __glewLightxv = NULL;

3051 PFNGLLINEWIDTHXPROC __glewLineWidthx = NULL;

3052 PFNGLLOADMATRIXXPROC __glewLoadMatrixx = NULL;

3053 PFNGLMATERIALXPROC __glewMaterialx = NULL;

3054 PFNGLMATERIALXVPROC __glewMaterialxv = NULL;

3055 PFNGLMULTMATRIXXPROC __glewMultMatrixx = NULL;

3056 PFNGLMULTITEXCOORD4XPROC __glewMultiTexCoord4x = NULL;

3057 PFNGLNORMAL3XPROC __glewNormal3x = NULL;

3058 PFNGLORTHOFPROC __glewOrthof = NULL;

3059 PFNGLORTHOXPROC __glewOrthox = NULL;

3060 PFNGLPOINTSIZEXPROC __glewPointSizex = NULL;

3061 PFNGLPOLYGONOFFSETXPROC __glewPolygonOffsetx = NULL;

3062 PFNGLROTATEXPROC __glewRotatex = NULL;

3063 PFNGLSAMPLECOVERAGEXPROC __glewSampleCoveragex = NULL;

3064 PFNGLSCALEXPROC __glewScalex = NULL;

3065 PFNGLTEXENVXPROC __glewTexEnvx = NULL;

3066 PFNGLTEXENVXVPROC __glewTexEnvxv = NULL;

3067 PFNGLTEXPARAMETERXPROC __glewTexParameterx = NULL;

3068 PFNGLTRANSLATEXPROC __glewTranslatex = NULL;

3069

3070 PFNGLCLIPPLANEFPROC __glewClipPlanef = NULL;

3071 PFNGLCLIPPLANEXPROC __glewClipPlanex = NULL;

3072 PFNGLGETCLIPPLANEFPROC __glewGetClipPlanef = NULL;

3073 PFNGLGETCLIPPLANEXPROC __glewGetClipPlanex = NULL;

3074 PFNGLGETFIXEDVPROC __glewGetFixedv = NULL;

3075 PFNGLGETLIGHTXVPROC __glewGetLightxv = NULL;

3076 PFNGLGETMATERIALXVPROC __glewGetMaterialxv = NULL;

3077 PFNGLGETTEXENVXVPROC __glewGetTexEnvxv = NULL;

3078 PFNGLGETTEXPARAMETERXVPROC __glewGetTexParameterxv = NULL;

3079 PFNGLPOINTPARAMETERXPROC __glewPointParameterx = NULL;

3080 PFNGLPOINTPARAMETERXVPROC __glewPointParameterxv = NULL;

3081 PFNGLPOINTSIZEPOINTEROESPROC __glewPointSizePointerOES = NULL;

3082 PFNGLTEXPARAMETERXVPROC __glewTexParameterxv = NULL;

3083

3084 PFNGLERRORSTRINGREGALPROC __glewErrorStringREGAL = NULL;

3085

3086 PFNGLGETEXTENSIONREGALPROC __glewGetExtensionREGAL = NULL;

3087 PFNGLISSUPPORTEDREGALPROC __glewIsSupportedREGAL = NULL;

3088

3089 PFNGLLOGMESSAGECALLBACKREGALPROC __glewLogMessageCallbackREGAL = NULL;

3090

3091 PFNGLGETPROCADDRESSREGALPROC __glewGetProcAddressREGAL = NULL;

3092

3093 PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;

3094 PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;

3095

3096 PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;

3097 PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;

3098

3099 PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;

3100 PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;

3101

3102 PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC __glewInterleavedTextureCoordSetsSGIS = NULL;

3103 PFNGLSELECTTEXTURECOORDSETSGISPROC __glewSelectTextureCoordSetSGIS = NULL;

3104 PFNGLSELECTTEXTURESGISPROC __glewSelectTextureSGIS = NULL;

3105 PFNGLSELECTTEXTURETRANSFORMSGISPROC __glewSelectTextureTransformSGIS = NULL;

3106

3107 PFNGLMULTISAMPLESUBRECTPOSSGISPROC __glewMultisampleSubRectPosSGIS = NULL;

3108

3109 PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;

3110 PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;

3111

3112 PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;

3113 PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;

3114

3115 PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;

3116 PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;

3117

3118 PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;

3119 PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;

3120 PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;

3121 PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;

3122 PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;

3123 PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;

3124

3125 PFNGLADDRESSSPACEPROC __glewAddressSpace = NULL;

3126 PFNGLDATAPIPEPROC __glewDataPipe = NULL;

3127

3128 PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;

3129

3130 PFNGLFOGLAYERSSGIXPROC __glewFogLayersSGIX = NULL;

3131 PFNGLGETFOGLAYERSSGIXPROC __glewGetFogLayersSGIX = NULL;

3132

3133 PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;

3134

3135 PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;

3136 PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;

3137 PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;

3138 PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;

3139 PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;

3140 PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;

3141 PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;

3142 PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;

3143 PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;

3144 PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;

3145 PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;

3146 PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;

3147 PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;

3148 PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;

3149 PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;

3150 PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;

3151 PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;

3152

3153 PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;

3154

3155 PFNGLIGLOOINTERFACESGIXPROC __glewIglooInterfaceSGIX = NULL;

3156

3157 PFNGLALLOCMPEGPREDICTORSSGIXPROC __glewAllocMPEGPredictorsSGIX = NULL;

3158 PFNGLDELETEMPEGPREDICTORSSGIXPROC __glewDeleteMPEGPredictorsSGIX = NULL;

3159 PFNGLGENMPEGPREDICTORSSGIXPROC __glewGenMPEGPredictorsSGIX = NULL;

3160 PFNGLGETMPEGPARAMETERFVSGIXPROC __glewGetMPEGParameterfvSGIX = NULL;

3161 PFNGLGETMPEGPARAMETERIVSGIXPROC __glewGetMPEGParameterivSGIX = NULL;

3162 PFNGLGETMPEGPREDICTORSGIXPROC __glewGetMPEGPredictorSGIX = NULL;

3163 PFNGLGETMPEGQUANTTABLEUBVPROC __glewGetMPEGQuantTableubv = NULL;

3164 PFNGLISMPEGPREDICTORSGIXPROC __glewIsMPEGPredictorSGIX = NULL;

3165 PFNGLMPEGPREDICTORSGIXPROC __glewMPEGPredictorSGIX = NULL;

3166 PFNGLMPEGQUANTTABLEUBVPROC __glewMPEGQuantTableubv = NULL;

3167 PFNGLSWAPMPEGPREDICTORSSGIXPROC __glewSwapMPEGPredictorsSGIX = NULL;

3168

3169 PFNGLGETNONLINLIGHTFVSGIXPROC __glewGetNonlinLightfvSGIX = NULL;

3170 PFNGLGETNONLINMATERIALFVSGIXPROC __glewGetNonlinMaterialfvSGIX = NULL;

3171 PFNGLNONLINLIGHTFVSGIXPROC __glewNonlinLightfvSGIX = NULL;

3172 PFNGLNONLINMATERIALFVSGIXPROC __glewNonlinMaterialfvSGIX = NULL;

3173

3174 PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;

3175

3176 PFNGLDEFORMSGIXPROC __glewDeformSGIX = NULL;

3177 PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC __glewLoadIdentityDeformationMapSGIX = NULL;

3178

3179 PFNGLMESHBREADTHSGIXPROC __glewMeshBreadthSGIX = NULL;

3180 PFNGLMESHSTRIDESGIXPROC __glewMeshStrideSGIX = NULL;

3181

3182 PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;

3183

3184 PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;

3185 PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;

3186 PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;

3187 PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;

3188

3189 PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;

3190

3191 PFNGLGETVECTOROPERATIONSGIXPROC __glewGetVectorOperationSGIX = NULL;

3192 PFNGLVECTOROPERATIONSGIXPROC __glewVectorOperationSGIX = NULL;

3193

3194 PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC __glewAreVertexArraysResidentSGIX = NULL;

3195 PFNGLBINDVERTEXARRAYSGIXPROC __glewBindVertexArraySGIX = NULL;

3196 PFNGLDELETEVERTEXARRAYSSGIXPROC __glewDeleteVertexArraysSGIX = NULL;

3197 PFNGLGENVERTEXARRAYSSGIXPROC __glewGenVertexArraysSGIX = NULL;

3198 PFNGLISVERTEXARRAYSGIXPROC __glewIsVertexArraySGIX = NULL;

3199 PFNGLPRIORITIZEVERTEXARRAYSSGIXPROC __glewPrioritizeVertexArraysSGIX = NULL;

3200

3201 PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;

3202 PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;

3203 PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;

3204 PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;

3205 PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;

3206 PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;

3207 PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;

3208

3209 PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC __glewGetPixelTransformParameterfvSGI = NULL;

3210 PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC __glewGetPixelTransformParameterivSGI = NULL;

3211 PFNGLPIXELTRANSFORMPARAMETERFSGIPROC __glewPixelTransformParameterfSGI = NULL;

3212 PFNGLPIXELTRANSFORMPARAMETERFVSGIPROC __glewPixelTransformParameterfvSGI = NULL;

3213 PFNGLPIXELTRANSFORMPARAMETERISGIPROC __glewPixelTransformParameteriSGI = NULL;

3214 PFNGLPIXELTRANSFORMPARAMETERIVSGIPROC __glewPixelTransformParameterivSGI = NULL;

3215 PFNGLPIXELTRANSFORMSGIPROC __glewPixelTransformSGI = NULL;

3216

3217 PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;

3218

3219 PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;

3220 PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;

3221 PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;

3222 PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;

3223 PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;

3224 PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;

3225 PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;

3226 PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;

3227

3228 PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;

3229

3230 PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;

3231 PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;

3232 PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;

3233 PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;

3234 PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;

3235 PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;

3236 PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;

3237

3238 PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;

3239 PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;

3240 PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;

3241 PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;

3242 PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;

3243 PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;

3244 PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;

3245 PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;

3246 PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;

3247 PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;

3248 PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;

3249 PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;

3250 PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;

3251 PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;

3252 PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;

3253 PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;

3254 PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;

3255 PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;

3256 PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

3257 PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

3258 PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;

3259 PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;

3260 PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;

3261 PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;

3262 PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;

3263 PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;

3264 PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;

3265 PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;

3266 PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

3267 PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

3268 PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;

3269 PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;

3270 PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;

3271 PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;

3272 PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;

3273 PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;

3274 PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;

3275 PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;

3276 PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;

3277 PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;

3278

3279 PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;

3280

3281 GLboolean __GLEW_VERSION_1_1 = GL_FALSE;

3282 GLboolean __GLEW_VERSION_1_2 = GL_FALSE;

3283 GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE;

3284 GLboolean __GLEW_VERSION_1_3 = GL_FALSE;

3285 GLboolean __GLEW_VERSION_1_4 = GL_FALSE;

3286 GLboolean __GLEW_VERSION_1_5 = GL_FALSE;

3287 GLboolean __GLEW_VERSION_2_0 = GL_FALSE;

3288 GLboolean __GLEW_VERSION_2_1 = GL_FALSE;

3289 GLboolean __GLEW_VERSION_3_0 = GL_FALSE;

3290 GLboolean __GLEW_VERSION_3_1 = GL_FALSE;

3291 GLboolean __GLEW_VERSION_3_2 = GL_FALSE;

3292 GLboolean __GLEW_VERSION_3_3 = GL_FALSE;

3293 GLboolean __GLEW_VERSION_4_0 = GL_FALSE;

3294 GLboolean __GLEW_VERSION_4_1 = GL_FALSE;

3295 GLboolean __GLEW_VERSION_4_2 = GL_FALSE;

3296 GLboolean __GLEW_VERSION_4_3 = GL_FALSE;

3297 GLboolean __GLEW_VERSION_4_4 = GL_FALSE;

3298 GLboolean __GLEW_VERSION_4_5 = GL_FALSE;

3299 GLboolean __GLEW_VERSION_4_6 = GL_FALSE;

3300 GLboolean __GLEW_3DFX_multisample = GL_FALSE;

3301 GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;

3302 GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;

3303 GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE;

3304 GLboolean __GLEW_AMD_compressed_3DC_texture = GL_FALSE;

3305 GLboolean __GLEW_AMD_compressed_ATC_texture = GL_FALSE;

3306 GLboolean __GLEW_AMD_conservative_depth = GL_FALSE;

3307 GLboolean __GLEW_AMD_debug_output = GL_FALSE;

3308 GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE;

3309 GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE;

3310 GLboolean __GLEW_AMD_framebuffer_sample_positions = GL_FALSE;

3311 GLboolean __GLEW_AMD_gcn_shader = GL_FALSE;

3312 GLboolean __GLEW_AMD_gpu_shader_half_float = GL_FALSE;

3313 GLboolean __GLEW_AMD_gpu_shader_int16 = GL_FALSE;

3314 GLboolean __GLEW_AMD_gpu_shader_int64 = GL_FALSE;

3315 GLboolean __GLEW_AMD_interleaved_elements = GL_FALSE;

3316 GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE;

3317 GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE;

3318 GLboolean __GLEW_AMD_occlusion_query_event = GL_FALSE;

3319 GLboolean __GLEW_AMD_performance_monitor = GL_FALSE;

3320 GLboolean __GLEW_AMD_pinned_memory = GL_FALSE;

3321 GLboolean __GLEW_AMD_program_binary_Z400 = GL_FALSE;

3322 GLboolean __GLEW_AMD_query_buffer_object = GL_FALSE;

3323 GLboolean __GLEW_AMD_sample_positions = GL_FALSE;

3324 GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE;

3325 GLboolean __GLEW_AMD_shader_atomic_counter_ops = GL_FALSE;

3326 GLboolean __GLEW_AMD_shader_ballot = GL_FALSE;

3327 GLboolean __GLEW_AMD_shader_explicit_vertex_parameter = GL_FALSE;

3328 GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE;

3329 GLboolean __GLEW_AMD_shader_stencil_value_export = GL_FALSE;

3330 GLboolean __GLEW_AMD_shader_trinary_minmax = GL_FALSE;

3331 GLboolean __GLEW_AMD_sparse_texture = GL_FALSE;

3332 GLboolean __GLEW_AMD_stencil_operation_extended = GL_FALSE;

3333 GLboolean __GLEW_AMD_texture_gather_bias_lod = GL_FALSE;

3334 GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE;

3335 GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE;

3336 GLboolean __GLEW_AMD_transform_feedback4 = GL_FALSE;

3337 GLboolean __GLEW_AMD_vertex_shader_layer = GL_FALSE;

3338 GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE;

3339 GLboolean __GLEW_AMD_vertex_shader_viewport_index = GL_FALSE;

3340 GLboolean __GLEW_ANDROID_extension_pack_es31a = GL_FALSE;

3341 GLboolean __GLEW_ANGLE_depth_texture = GL_FALSE;

3342 GLboolean __GLEW_ANGLE_framebuffer_blit = GL_FALSE;

3343 GLboolean __GLEW_ANGLE_framebuffer_multisample = GL_FALSE;

3344 GLboolean __GLEW_ANGLE_instanced_arrays = GL_FALSE;

3345 GLboolean __GLEW_ANGLE_pack_reverse_row_order = GL_FALSE;

3346 GLboolean __GLEW_ANGLE_program_binary = GL_FALSE;

3347 GLboolean __GLEW_ANGLE_texture_compression_dxt1 = GL_FALSE;

3348 GLboolean __GLEW_ANGLE_texture_compression_dxt3 = GL_FALSE;

3349 GLboolean __GLEW_ANGLE_texture_compression_dxt5 = GL_FALSE;

3350 GLboolean __GLEW_ANGLE_texture_usage = GL_FALSE;

3351 GLboolean __GLEW_ANGLE_timer_query = GL_FALSE;

3352 GLboolean __GLEW_ANGLE_translated_shader_source = GL_FALSE;

3353 GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE;

3354 GLboolean __GLEW_APPLE_client_storage = GL_FALSE;

3355 GLboolean __GLEW_APPLE_clip_distance = GL_FALSE;

3356 GLboolean __GLEW_APPLE_color_buffer_packed_float = GL_FALSE;

3357 GLboolean __GLEW_APPLE_copy_texture_levels = GL_FALSE;

3358 GLboolean __GLEW_APPLE_element_array = GL_FALSE;

3359 GLboolean __GLEW_APPLE_fence = GL_FALSE;

3360 GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;

3361 GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;

3362 GLboolean __GLEW_APPLE_framebuffer_multisample = GL_FALSE;

3363 GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE;

3364 GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;

3365 GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE;

3366 GLboolean __GLEW_APPLE_row_bytes = GL_FALSE;

3367 GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;

3368 GLboolean __GLEW_APPLE_sync = GL_FALSE;

3369 GLboolean __GLEW_APPLE_texture_2D_limited_npot = GL_FALSE;

3370 GLboolean __GLEW_APPLE_texture_format_BGRA8888 = GL_FALSE;

3371 GLboolean __GLEW_APPLE_texture_max_level = GL_FALSE;

3372 GLboolean __GLEW_APPLE_texture_packed_float = GL_FALSE;

3373 GLboolean __GLEW_APPLE_texture_range = GL_FALSE;

3374 GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;

3375 GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;

3376 GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;

3377 GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE;

3378 GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;

3379 GLboolean __GLEW_ARB_ES2_compatibility = GL_FALSE;

3380 GLboolean __GLEW_ARB_ES3_1_compatibility = GL_FALSE;

3381 GLboolean __GLEW_ARB_ES3_2_compatibility = GL_FALSE;

3382 GLboolean __GLEW_ARB_ES3_compatibility = GL_FALSE;

3383 GLboolean __GLEW_ARB_arrays_of_arrays = GL_FALSE;

3384 GLboolean __GLEW_ARB_base_instance = GL_FALSE;

3385 GLboolean __GLEW_ARB_bindless_texture = GL_FALSE;

3386 GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE;

3387 GLboolean __GLEW_ARB_buffer_storage = GL_FALSE;

3388 GLboolean __GLEW_ARB_cl_event = GL_FALSE;

3389 GLboolean __GLEW_ARB_clear_buffer_object = GL_FALSE;

3390 GLboolean __GLEW_ARB_clear_texture = GL_FALSE;

3391 GLboolean __GLEW_ARB_clip_control = GL_FALSE;

3392 GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;

3393 GLboolean __GLEW_ARB_compatibility = GL_FALSE;

3394 GLboolean __GLEW_ARB_compressed_texture_pixel_storage = GL_FALSE;

3395 GLboolean __GLEW_ARB_compute_shader = GL_FALSE;

3396 GLboolean __GLEW_ARB_compute_variable_group_size = GL_FALSE;

3397 GLboolean __GLEW_ARB_conditional_render_inverted = GL_FALSE;

3398 GLboolean __GLEW_ARB_conservative_depth = GL_FALSE;

3399 GLboolean __GLEW_ARB_copy_buffer = GL_FALSE;

3400 GLboolean __GLEW_ARB_copy_image = GL_FALSE;

3401 GLboolean __GLEW_ARB_cull_distance = GL_FALSE;

3402 GLboolean __GLEW_ARB_debug_output = GL_FALSE;

3403 GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE;

3404 GLboolean __GLEW_ARB_depth_clamp = GL_FALSE;

3405 GLboolean __GLEW_ARB_depth_texture = GL_FALSE;

3406 GLboolean __GLEW_ARB_derivative_control = GL_FALSE;

3407 GLboolean __GLEW_ARB_direct_state_access = GL_FALSE;

3408 GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;

3409 GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE;

3410 GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE;

3411 GLboolean __GLEW_ARB_draw_indirect = GL_FALSE;

3412 GLboolean __GLEW_ARB_draw_instanced = GL_FALSE;

3413 GLboolean __GLEW_ARB_enhanced_layouts = GL_FALSE;

3414 GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE;

3415 GLboolean __GLEW_ARB_explicit_uniform_location = GL_FALSE;

3416 GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE;

3417 GLboolean __GLEW_ARB_fragment_layer_viewport = GL_FALSE;

3418 GLboolean __GLEW_ARB_fragment_program = GL_FALSE;

3419 GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;

3420 GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;

3421 GLboolean __GLEW_ARB_fragment_shader_interlock = GL_FALSE;

3422 GLboolean __GLEW_ARB_framebuffer_no_attachments = GL_FALSE;

3423 GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE;

3424 GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE;

3425 GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE;

3426 GLboolean __GLEW_ARB_get_program_binary = GL_FALSE;

3427 GLboolean __GLEW_ARB_get_texture_sub_image = GL_FALSE;

3428 GLboolean __GLEW_ARB_gl_spirv = GL_FALSE;

3429 GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE;

3430 GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE;

3431 GLboolean __GLEW_ARB_gpu_shader_int64 = GL_FALSE;

3432 GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;

3433 GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE;

3434 GLboolean __GLEW_ARB_imaging = GL_FALSE;

3435 GLboolean __GLEW_ARB_indirect_parameters = GL_FALSE;

3436 GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE;

3437 GLboolean __GLEW_ARB_internalformat_query = GL_FALSE;

3438 GLboolean __GLEW_ARB_internalformat_query2 = GL_FALSE;

3439 GLboolean __GLEW_ARB_invalidate_subdata = GL_FALSE;

3440 GLboolean __GLEW_ARB_map_buffer_alignment = GL_FALSE;

3441 GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE;

3442 GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;

3443 GLboolean __GLEW_ARB_multi_bind = GL_FALSE;

3444 GLboolean __GLEW_ARB_multi_draw_indirect = GL_FALSE;

3445 GLboolean __GLEW_ARB_multisample = GL_FALSE;

3446 GLboolean __GLEW_ARB_multitexture = GL_FALSE;

3447 GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;

3448 GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE;

3449 GLboolean __GLEW_ARB_parallel_shader_compile = GL_FALSE;

3450 GLboolean __GLEW_ARB_pipeline_statistics_query = GL_FALSE;

3451 GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;

3452 GLboolean __GLEW_ARB_point_parameters = GL_FALSE;

3453 GLboolean __GLEW_ARB_point_sprite = GL_FALSE;

3454 GLboolean __GLEW_ARB_polygon_offset_clamp = GL_FALSE;

3455 GLboolean __GLEW_ARB_post_depth_coverage = GL_FALSE;

3456 GLboolean __GLEW_ARB_program_interface_query = GL_FALSE;

3457 GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE;

3458 GLboolean __GLEW_ARB_query_buffer_object = GL_FALSE;

3459 GLboolean __GLEW_ARB_robust_buffer_access_behavior = GL_FALSE;

3460 GLboolean __GLEW_ARB_robustness = GL_FALSE;

3461 GLboolean __GLEW_ARB_robustness_application_isolation = GL_FALSE;

3462 GLboolean __GLEW_ARB_robustness_share_group_isolation = GL_FALSE;

3463 GLboolean __GLEW_ARB_sample_locations = GL_FALSE;

3464 GLboolean __GLEW_ARB_sample_shading = GL_FALSE;

3465 GLboolean __GLEW_ARB_sampler_objects = GL_FALSE;

3466 GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE;

3467 GLboolean __GLEW_ARB_seamless_cubemap_per_texture = GL_FALSE;

3468 GLboolean __GLEW_ARB_separate_shader_objects = GL_FALSE;

3469 GLboolean __GLEW_ARB_shader_atomic_counter_ops = GL_FALSE;

3470 GLboolean __GLEW_ARB_shader_atomic_counters = GL_FALSE;

3471 GLboolean __GLEW_ARB_shader_ballot = GL_FALSE;

3472 GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE;

3473 GLboolean __GLEW_ARB_shader_clock = GL_FALSE;

3474 GLboolean __GLEW_ARB_shader_draw_parameters = GL_FALSE;

3475 GLboolean __GLEW_ARB_shader_group_vote = GL_FALSE;

3476 GLboolean __GLEW_ARB_shader_image_load_store = GL_FALSE;

3477 GLboolean __GLEW_ARB_shader_image_size = GL_FALSE;

3478 GLboolean __GLEW_ARB_shader_objects = GL_FALSE;

3479 GLboolean __GLEW_ARB_shader_precision = GL_FALSE;

3480 GLboolean __GLEW_ARB_shader_stencil_export = GL_FALSE;

3481 GLboolean __GLEW_ARB_shader_storage_buffer_object = GL_FALSE;

3482 GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE;

3483 GLboolean __GLEW_ARB_shader_texture_image_samples = GL_FALSE;

3484 GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE;

3485 GLboolean __GLEW_ARB_shader_viewport_layer_array = GL_FALSE;

3486 GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;

3487 GLboolean __GLEW_ARB_shading_language_420pack = GL_FALSE;

3488 GLboolean __GLEW_ARB_shading_language_include = GL_FALSE;

3489 GLboolean __GLEW_ARB_shading_language_packing = GL_FALSE;

3490 GLboolean __GLEW_ARB_shadow = GL_FALSE;

3491 GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;

3492 GLboolean __GLEW_ARB_sparse_buffer = GL_FALSE;

3493 GLboolean __GLEW_ARB_sparse_texture = GL_FALSE;

3494 GLboolean __GLEW_ARB_sparse_texture2 = GL_FALSE;

3495 GLboolean __GLEW_ARB_sparse_texture_clamp = GL_FALSE;

3496 GLboolean __GLEW_ARB_spirv_extensions = GL_FALSE;

3497 GLboolean __GLEW_ARB_stencil_texturing = GL_FALSE;

3498 GLboolean __GLEW_ARB_sync = GL_FALSE;

3499 GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE;

3500 GLboolean __GLEW_ARB_texture_barrier = GL_FALSE;

3501 GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;

3502 GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE;

3503 GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE;

3504 GLboolean __GLEW_ARB_texture_buffer_range = GL_FALSE;

3505 GLboolean __GLEW_ARB_texture_compression = GL_FALSE;

3506 GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE;

3507 GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE;

3508 GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;

3509 GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE;

3510 GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;

3511 GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;

3512 GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;

3513 GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;

3514 GLboolean __GLEW_ARB_texture_filter_anisotropic = GL_FALSE;

3515 GLboolean __GLEW_ARB_texture_filter_minmax = GL_FALSE;

3516 GLboolean __GLEW_ARB_texture_float = GL_FALSE;

3517 GLboolean __GLEW_ARB_texture_gather = GL_FALSE;

3518 GLboolean __GLEW_ARB_texture_mirror_clamp_to_edge = GL_FALSE;

3519 GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;

3520 GLboolean __GLEW_ARB_texture_multisample = GL_FALSE;

3521 GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;

3522 GLboolean __GLEW_ARB_texture_query_levels = GL_FALSE;

3523 GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE;

3524 GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;

3525 GLboolean __GLEW_ARB_texture_rg = GL_FALSE;

3526 GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE;

3527 GLboolean __GLEW_ARB_texture_stencil8 = GL_FALSE;

3528 GLboolean __GLEW_ARB_texture_storage = GL_FALSE;

3529 GLboolean __GLEW_ARB_texture_storage_multisample = GL_FALSE;

3530 GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE;

3531 GLboolean __GLEW_ARB_texture_view = GL_FALSE;

3532 GLboolean __GLEW_ARB_timer_query = GL_FALSE;

3533 GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE;

3534 GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE;

3535 GLboolean __GLEW_ARB_transform_feedback_instanced = GL_FALSE;

3536 GLboolean __GLEW_ARB_transform_feedback_overflow_query = GL_FALSE;

3537 GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;

3538 GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE;

3539 GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE;

3540 GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE;

3541 GLboolean __GLEW_ARB_vertex_attrib_64bit = GL_FALSE;

3542 GLboolean __GLEW_ARB_vertex_attrib_binding = GL_FALSE;

3543 GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;

3544 GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;

3545 GLboolean __GLEW_ARB_vertex_program = GL_FALSE;

3546 GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;

3547 GLboolean __GLEW_ARB_vertex_type_10f_11f_11f_rev = GL_FALSE;

3548 GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE;

3549 GLboolean __GLEW_ARB_viewport_array = GL_FALSE;

3550 GLboolean __GLEW_ARB_window_pos = GL_FALSE;

3551 GLboolean __GLEW_ARM_mali_program_binary = GL_FALSE;

3552 GLboolean __GLEW_ARM_mali_shader_binary = GL_FALSE;

3553 GLboolean __GLEW_ARM_rgba8 = GL_FALSE;

3554 GLboolean __GLEW_ARM_shader_framebuffer_fetch = GL_FALSE;

3555 GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil = GL_FALSE;

3556 GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;

3557 GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;

3558 GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;

3559 GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;

3560 GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;

3561 GLboolean __GLEW_ATI_element_array = GL_FALSE;

3562 GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;

3563 GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;

3564 GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;

3565 GLboolean __GLEW_ATI_meminfo = GL_FALSE;

3566 GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;

3567 GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;

3568 GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;

3569 GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;

3570 GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;

3571 GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;

3572 GLboolean __GLEW_ATI_texture_float = GL_FALSE;

3573 GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;

3574 GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;

3575 GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;

3576 GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;

3577 GLboolean __GLEW_EGL_KHR_context_flush_control = GL_FALSE;

3578 GLboolean __GLEW_EGL_NV_robustness_video_memory_purge = GL_FALSE;

3579 GLboolean __GLEW_EXT_422_pixels = GL_FALSE;

3580 GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;

3581 GLboolean __GLEW_EXT_EGL_image_array = GL_FALSE;

3582 GLboolean __GLEW_EXT_YUV_target = GL_FALSE;

3583 GLboolean __GLEW_EXT_abgr = GL_FALSE;

3584 GLboolean __GLEW_EXT_base_instance = GL_FALSE;

3585 GLboolean __GLEW_EXT_bgra = GL_FALSE;

3586 GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE;

3587 GLboolean __GLEW_EXT_blend_color = GL_FALSE;

3588 GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;

3589 GLboolean __GLEW_EXT_blend_func_extended = GL_FALSE;

3590 GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;

3591 GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;

3592 GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;

3593 GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;

3594 GLboolean __GLEW_EXT_buffer_storage = GL_FALSE;

3595 GLboolean __GLEW_EXT_clear_texture = GL_FALSE;

3596 GLboolean __GLEW_EXT_clip_cull_distance = GL_FALSE;

3597 GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;

3598 GLboolean __GLEW_EXT_cmyka = GL_FALSE;

3599 GLboolean __GLEW_EXT_color_buffer_float = GL_FALSE;

3600 GLboolean __GLEW_EXT_color_buffer_half_float = GL_FALSE;

3601 GLboolean __GLEW_EXT_color_subtable = GL_FALSE;

3602 GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;

3603 GLboolean __GLEW_EXT_compressed_ETC1_RGB8_sub_texture = GL_FALSE;

3604 GLboolean __GLEW_EXT_conservative_depth = GL_FALSE;

3605 GLboolean __GLEW_EXT_convolution = GL_FALSE;

3606 GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;

3607 GLboolean __GLEW_EXT_copy_image = GL_FALSE;

3608 GLboolean __GLEW_EXT_copy_texture = GL_FALSE;

3609 GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;

3610 GLboolean __GLEW_EXT_debug_label = GL_FALSE;

3611 GLboolean __GLEW_EXT_debug_marker = GL_FALSE;

3612 GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;

3613 GLboolean __GLEW_EXT_direct_state_access = GL_FALSE;

3614 GLboolean __GLEW_EXT_discard_framebuffer = GL_FALSE;

3615 GLboolean __GLEW_EXT_draw_buffers = GL_FALSE;

3616 GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE;

3617 GLboolean __GLEW_EXT_draw_buffers_indexed = GL_FALSE;

3618 GLboolean __GLEW_EXT_draw_elements_base_vertex = GL_FALSE;

3619 GLboolean __GLEW_EXT_draw_instanced = GL_FALSE;

3620 GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;

3621 GLboolean __GLEW_EXT_external_buffer = GL_FALSE;

3622 GLboolean __GLEW_EXT_float_blend = GL_FALSE;

3623 GLboolean __GLEW_EXT_fog_coord = GL_FALSE;

3624 GLboolean __GLEW_EXT_frag_depth = GL_FALSE;

3625 GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;

3626 GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;

3627 GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;

3628 GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE;

3629 GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;

3630 GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE;

3631 GLboolean __GLEW_EXT_geometry_point_size = GL_FALSE;

3632 GLboolean __GLEW_EXT_geometry_shader = GL_FALSE;

3633 GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE;

3634 GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE;

3635 GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE;

3636 GLboolean __GLEW_EXT_gpu_shader5 = GL_FALSE;

3637 GLboolean __GLEW_EXT_histogram = GL_FALSE;

3638 GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;

3639 GLboolean __GLEW_EXT_index_func = GL_FALSE;

3640 GLboolean __GLEW_EXT_index_material = GL_FALSE;

3641 GLboolean __GLEW_EXT_index_texture = GL_FALSE;

3642 GLboolean __GLEW_EXT_instanced_arrays = GL_FALSE;

3643 GLboolean __GLEW_EXT_light_texture = GL_FALSE;

3644 GLboolean __GLEW_EXT_map_buffer_range = GL_FALSE;

3645 GLboolean __GLEW_EXT_memory_object = GL_FALSE;

3646 GLboolean __GLEW_EXT_memory_object_fd = GL_FALSE;

3647 GLboolean __GLEW_EXT_memory_object_win32 = GL_FALSE;

3648 GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;

3649 GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;

3650 GLboolean __GLEW_EXT_multi_draw_indirect = GL_FALSE;

3651 GLboolean __GLEW_EXT_multiple_textures = GL_FALSE;

3652 GLboolean __GLEW_EXT_multisample = GL_FALSE;

3653 GLboolean __GLEW_EXT_multisample_compatibility = GL_FALSE;

3654 GLboolean __GLEW_EXT_multisampled_render_to_texture = GL_FALSE;

3655 GLboolean __GLEW_EXT_multisampled_render_to_texture2 = GL_FALSE;

3656 GLboolean __GLEW_EXT_multiview_draw_buffers = GL_FALSE;

3657 GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE;

3658 GLboolean __GLEW_EXT_packed_float = GL_FALSE;

3659 GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;

3660 GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;

3661 GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;

3662 GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;

3663 GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;

3664 GLboolean __GLEW_EXT_point_parameters = GL_FALSE;

3665 GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;

3666 GLboolean __GLEW_EXT_polygon_offset_clamp = GL_FALSE;

3667 GLboolean __GLEW_EXT_post_depth_coverage = GL_FALSE;

3668 GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE;

3669 GLboolean __GLEW_EXT_pvrtc_sRGB = GL_FALSE;

3670 GLboolean __GLEW_EXT_raster_multisample = GL_FALSE;

3671 GLboolean __GLEW_EXT_read_format_bgra = GL_FALSE;

3672 GLboolean __GLEW_EXT_render_snorm = GL_FALSE;

3673 GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;

3674 GLboolean __GLEW_EXT_sRGB = GL_FALSE;

3675 GLboolean __GLEW_EXT_sRGB_write_control = GL_FALSE;

3676 GLboolean __GLEW_EXT_scene_marker = GL_FALSE;

3677 GLboolean __GLEW_EXT_secondary_color = GL_FALSE;

3678 GLboolean __GLEW_EXT_semaphore = GL_FALSE;

3679 GLboolean __GLEW_EXT_semaphore_fd = GL_FALSE;

3680 GLboolean __GLEW_EXT_semaphore_win32 = GL_FALSE;

3681 GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE;

3682 GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;

3683 GLboolean __GLEW_EXT_shader_framebuffer_fetch = GL_FALSE;

3684 GLboolean __GLEW_EXT_shader_group_vote = GL_FALSE;

3685 GLboolean __GLEW_EXT_shader_image_load_formatted = GL_FALSE;

3686 GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE;

3687 GLboolean __GLEW_EXT_shader_implicit_conversions = GL_FALSE;

3688 GLboolean __GLEW_EXT_shader_integer_mix = GL_FALSE;

3689 GLboolean __GLEW_EXT_shader_io_blocks = GL_FALSE;

3690 GLboolean __GLEW_EXT_shader_non_constant_global_initializers = GL_FALSE;

3691 GLboolean __GLEW_EXT_shader_pixel_local_storage = GL_FALSE;

3692 GLboolean __GLEW_EXT_shader_pixel_local_storage2 = GL_FALSE;

3693 GLboolean __GLEW_EXT_shader_texture_lod = GL_FALSE;

3694 GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;

3695 GLboolean __GLEW_EXT_shadow_samplers = GL_FALSE;

3696 GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;

3697 GLboolean __GLEW_EXT_sparse_texture = GL_FALSE;

3698 GLboolean __GLEW_EXT_sparse_texture2 = GL_FALSE;

3699 GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;

3700 GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;

3701 GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;

3702 GLboolean __GLEW_EXT_subtexture = GL_FALSE;

3703 GLboolean __GLEW_EXT_texture = GL_FALSE;

3704 GLboolean __GLEW_EXT_texture3D = GL_FALSE;

3705 GLboolean __GLEW_EXT_texture_array = GL_FALSE;

3706 GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE;

3707 GLboolean __GLEW_EXT_texture_compression_astc_decode_mode = GL_FALSE;

3708 GLboolean __GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5 = GL_FALSE;

3709 GLboolean __GLEW_EXT_texture_compression_bptc = GL_FALSE;

3710 GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;

3711 GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE;

3712 GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE;

3713 GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;

3714 GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;

3715 GLboolean __GLEW_EXT_texture_cube_map_array = GL_FALSE;

3716 GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;

3717 GLboolean __GLEW_EXT_texture_env = GL_FALSE;

3718 GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;

3719 GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;

3720 GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;

3721 GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;

3722 GLboolean __GLEW_EXT_texture_filter_minmax = GL_FALSE;

3723 GLboolean __GLEW_EXT_texture_format_BGRA8888 = GL_FALSE;

3724 GLboolean __GLEW_EXT_texture_integer = GL_FALSE;

3725 GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;

3726 GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;

3727 GLboolean __GLEW_EXT_texture_norm16 = GL_FALSE;

3728 GLboolean __GLEW_EXT_texture_object = GL_FALSE;

3729 GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;

3730 GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;

3731 GLboolean __GLEW_EXT_texture_rg = GL_FALSE;

3732 GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;

3733 GLboolean __GLEW_EXT_texture_sRGB_R8 = GL_FALSE;

3734 GLboolean __GLEW_EXT_texture_sRGB_RG8 = GL_FALSE;

3735 GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE;

3736 GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;

3737 GLboolean __GLEW_EXT_texture_snorm = GL_FALSE;

3738 GLboolean __GLEW_EXT_texture_storage = GL_FALSE;

3739 GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;

3740 GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV = GL_FALSE;

3741 GLboolean __GLEW_EXT_texture_view = GL_FALSE;

3742 GLboolean __GLEW_EXT_timer_query = GL_FALSE;

3743 GLboolean __GLEW_EXT_transform_feedback = GL_FALSE;

3744 GLboolean __GLEW_EXT_unpack_subimage = GL_FALSE;

3745 GLboolean __GLEW_EXT_vertex_array = GL_FALSE;

3746 GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE;

3747 GLboolean __GLEW_EXT_vertex_array_setXXX = GL_FALSE;

3748 GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE;

3749 GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;

3750 GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;

3751 GLboolean __GLEW_EXT_win32_keyed_mutex = GL_FALSE;

3752 GLboolean __GLEW_EXT_window_rectangles = GL_FALSE;

3753 GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE;

3754 GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;

3755 GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE;

3756 GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;

3757 GLboolean __GLEW_HP_image_transform = GL_FALSE;

3758 GLboolean __GLEW_HP_occlusion_test = GL_FALSE;

3759 GLboolean __GLEW_HP_texture_lighting = GL_FALSE;

3760 GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;

3761 GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;

3762 GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;

3763 GLboolean __GLEW_IBM_static_data = GL_FALSE;

3764 GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;

3765 GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;

3766 GLboolean __GLEW_INGR_color_clamp = GL_FALSE;

3767 GLboolean __GLEW_INGR_interlace_read = GL_FALSE;

3768 GLboolean __GLEW_INTEL_conservative_rasterization = GL_FALSE;

3769 GLboolean __GLEW_INTEL_fragment_shader_ordering = GL_FALSE;

3770 GLboolean __GLEW_INTEL_framebuffer_CMAA = GL_FALSE;

3771 GLboolean __GLEW_INTEL_map_texture = GL_FALSE;

3772 GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;

3773 GLboolean __GLEW_INTEL_performance_query = GL_FALSE;

3774 GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;

3775 GLboolean __GLEW_KHR_blend_equation_advanced = GL_FALSE;

3776 GLboolean __GLEW_KHR_blend_equation_advanced_coherent = GL_FALSE;

3777 GLboolean __GLEW_KHR_context_flush_control = GL_FALSE;

3778 GLboolean __GLEW_KHR_debug = GL_FALSE;

3779 GLboolean __GLEW_KHR_no_error = GL_FALSE;

3780 GLboolean __GLEW_KHR_parallel_shader_compile = GL_FALSE;

3781 GLboolean __GLEW_KHR_robust_buffer_access_behavior = GL_FALSE;

3782 GLboolean __GLEW_KHR_robustness = GL_FALSE;

3783 GLboolean __GLEW_KHR_texture_compression_astc_hdr = GL_FALSE;

3784 GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE;

3785 GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d = GL_FALSE;

3786 GLboolean __GLEW_KTX_buffer_region = GL_FALSE;

3787 GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;

3788 GLboolean __GLEW_MESA_pack_invert = GL_FALSE;

3789 GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;

3790 GLboolean __GLEW_MESA_shader_integer_functions = GL_FALSE;

3791 GLboolean __GLEW_MESA_window_pos = GL_FALSE;

3792 GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;

3793 GLboolean __GLEW_NVX_blend_equation_advanced_multi_draw_buffers = GL_FALSE;

3794 GLboolean __GLEW_NVX_conditional_render = GL_FALSE;

3795 GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE;

3796 GLboolean __GLEW_NVX_linked_gpu_multicast = GL_FALSE;

3797 GLboolean __GLEW_NV_3dvision_settings = GL_FALSE;

3798 GLboolean __GLEW_NV_EGL_stream_consumer_external = GL_FALSE;

3799 GLboolean __GLEW_NV_alpha_to_coverage_dither_control = GL_FALSE;

3800 GLboolean __GLEW_NV_bgr = GL_FALSE;

3801 GLboolean __GLEW_NV_bindless_multi_draw_indirect = GL_FALSE;

3802 GLboolean __GLEW_NV_bindless_multi_draw_indirect_count = GL_FALSE;

3803 GLboolean __GLEW_NV_bindless_texture = GL_FALSE;

3804 GLboolean __GLEW_NV_blend_equation_advanced = GL_FALSE;

3805 GLboolean __GLEW_NV_blend_equation_advanced_coherent = GL_FALSE;

3806 GLboolean __GLEW_NV_blend_minmax_factor = GL_FALSE;

3807 GLboolean __GLEW_NV_blend_square = GL_FALSE;

3808 GLboolean __GLEW_NV_clip_space_w_scaling = GL_FALSE;

3809 GLboolean __GLEW_NV_command_list = GL_FALSE;

3810 GLboolean __GLEW_NV_compute_program5 = GL_FALSE;

3811 GLboolean __GLEW_NV_conditional_render = GL_FALSE;

3812 GLboolean __GLEW_NV_conservative_raster = GL_FALSE;

3813 GLboolean __GLEW_NV_conservative_raster_dilate = GL_FALSE;

3814 GLboolean __GLEW_NV_conservative_raster_pre_snap_triangles = GL_FALSE;

3815 GLboolean __GLEW_NV_copy_buffer = GL_FALSE;

3816 GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;

3817 GLboolean __GLEW_NV_copy_image = GL_FALSE;

3818 GLboolean __GLEW_NV_deep_texture3D = GL_FALSE;

3819 GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;

3820 GLboolean __GLEW_NV_depth_clamp = GL_FALSE;

3821 GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;

3822 GLboolean __GLEW_NV_draw_buffers = GL_FALSE;

3823 GLboolean __GLEW_NV_draw_instanced = GL_FALSE;

3824 GLboolean __GLEW_NV_draw_texture = GL_FALSE;

3825 GLboolean __GLEW_NV_draw_vulkan_image = GL_FALSE;

3826 GLboolean __GLEW_NV_evaluators = GL_FALSE;

3827 GLboolean __GLEW_NV_explicit_attrib_location = GL_FALSE;

3828 GLboolean __GLEW_NV_explicit_multisample = GL_FALSE;

3829 GLboolean __GLEW_NV_fbo_color_attachments = GL_FALSE;

3830 GLboolean __GLEW_NV_fence = GL_FALSE;

3831 GLboolean __GLEW_NV_fill_rectangle = GL_FALSE;

3832 GLboolean __GLEW_NV_float_buffer = GL_FALSE;

3833 GLboolean __GLEW_NV_fog_distance = GL_FALSE;

3834 GLboolean __GLEW_NV_fragment_coverage_to_color = GL_FALSE;

3835 GLboolean __GLEW_NV_fragment_program = GL_FALSE;

3836 GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;

3837 GLboolean __GLEW_NV_fragment_program4 = GL_FALSE;

3838 GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;

3839 GLboolean __GLEW_NV_fragment_shader_interlock = GL_FALSE;

3840 GLboolean __GLEW_NV_framebuffer_blit = GL_FALSE;

3841 GLboolean __GLEW_NV_framebuffer_mixed_samples = GL_FALSE;

3842 GLboolean __GLEW_NV_framebuffer_multisample = GL_FALSE;

3843 GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;

3844 GLboolean __GLEW_NV_generate_mipmap_sRGB = GL_FALSE;

3845 GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;

3846 GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;

3847 GLboolean __GLEW_NV_geometry_shader_passthrough = GL_FALSE;

3848 GLboolean __GLEW_NV_gpu_multicast = GL_FALSE;

3849 GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;

3850 GLboolean __GLEW_NV_gpu_program5 = GL_FALSE;

3851 GLboolean __GLEW_NV_gpu_program5_mem_extended = GL_FALSE;

3852 GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE;

3853 GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE;

3854 GLboolean __GLEW_NV_half_float = GL_FALSE;

3855 GLboolean __GLEW_NV_image_formats = GL_FALSE;

3856 GLboolean __GLEW_NV_instanced_arrays = GL_FALSE;

3857 GLboolean __GLEW_NV_internalformat_sample_query = GL_FALSE;

3858 GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;

3859 GLboolean __GLEW_NV_multisample_coverage = GL_FALSE;

3860 GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;

3861 GLboolean __GLEW_NV_non_square_matrices = GL_FALSE;

3862 GLboolean __GLEW_NV_occlusion_query = GL_FALSE;

3863 GLboolean __GLEW_NV_pack_subimage = GL_FALSE;

3864 GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;

3865 GLboolean __GLEW_NV_packed_float = GL_FALSE;

3866 GLboolean __GLEW_NV_packed_float_linear = GL_FALSE;

3867 GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;

3868 GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE;

3869 GLboolean __GLEW_NV_path_rendering = GL_FALSE;

3870 GLboolean __GLEW_NV_path_rendering_shared_edge = GL_FALSE;

3871 GLboolean __GLEW_NV_pixel_buffer_object = GL_FALSE;

3872 GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;

3873 GLboolean __GLEW_NV_platform_binary = GL_FALSE;

3874 GLboolean __GLEW_NV_point_sprite = GL_FALSE;

3875 GLboolean __GLEW_NV_polygon_mode = GL_FALSE;

3876 GLboolean __GLEW_NV_present_video = GL_FALSE;

3877 GLboolean __GLEW_NV_primitive_restart = GL_FALSE;

3878 GLboolean __GLEW_NV_read_depth = GL_FALSE;

3879 GLboolean __GLEW_NV_read_depth_stencil = GL_FALSE;

3880 GLboolean __GLEW_NV_read_stencil = GL_FALSE;

3881 GLboolean __GLEW_NV_register_combiners = GL_FALSE;

3882 GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;

3883 GLboolean __GLEW_NV_robustness_video_memory_purge = GL_FALSE;

3884 GLboolean __GLEW_NV_sRGB_formats = GL_FALSE;

3885 GLboolean __GLEW_NV_sample_locations = GL_FALSE;

3886 GLboolean __GLEW_NV_sample_mask_override_coverage = GL_FALSE;

3887 GLboolean __GLEW_NV_shader_atomic_counters = GL_FALSE;

3888 GLboolean __GLEW_NV_shader_atomic_float = GL_FALSE;

3889 GLboolean __GLEW_NV_shader_atomic_float64 = GL_FALSE;

3890 GLboolean __GLEW_NV_shader_atomic_fp16_vector = GL_FALSE;

3891 GLboolean __GLEW_NV_shader_atomic_int64 = GL_FALSE;

3892 GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE;

3893 GLboolean __GLEW_NV_shader_noperspective_interpolation = GL_FALSE;

3894 GLboolean __GLEW_NV_shader_storage_buffer_object = GL_FALSE;

3895 GLboolean __GLEW_NV_shader_thread_group = GL_FALSE;

3896 GLboolean __GLEW_NV_shader_thread_shuffle = GL_FALSE;

3897 GLboolean __GLEW_NV_shadow_samplers_array = GL_FALSE;

3898 GLboolean __GLEW_NV_shadow_samplers_cube = GL_FALSE;

3899 GLboolean __GLEW_NV_stereo_view_rendering = GL_FALSE;

3900 GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE;

3901 GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;

3902 GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;

3903 GLboolean __GLEW_NV_texture_array = GL_FALSE;

3904 GLboolean __GLEW_NV_texture_barrier = GL_FALSE;

3905 GLboolean __GLEW_NV_texture_border_clamp = GL_FALSE;

3906 GLboolean __GLEW_NV_texture_compression_latc = GL_FALSE;

3907 GLboolean __GLEW_NV_texture_compression_s3tc = GL_FALSE;

3908 GLboolean __GLEW_NV_texture_compression_s3tc_update = GL_FALSE;

3909 GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;

3910 GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;

3911 GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;

3912 GLboolean __GLEW_NV_texture_multisample = GL_FALSE;

3913 GLboolean __GLEW_NV_texture_npot_2D_mipmap = GL_FALSE;

3914 GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;

3915 GLboolean __GLEW_NV_texture_rectangle_compressed = GL_FALSE;

3916 GLboolean __GLEW_NV_texture_shader = GL_FALSE;

3917 GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;

3918 GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;

3919 GLboolean __GLEW_NV_transform_feedback = GL_FALSE;

3920 GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE;

3921 GLboolean __GLEW_NV_uniform_buffer_unified_memory = GL_FALSE;

3922 GLboolean __GLEW_NV_vdpau_interop = GL_FALSE;

3923 GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;

3924 GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;

3925 GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE;

3926 GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE;

3927 GLboolean __GLEW_NV_vertex_program = GL_FALSE;

3928 GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;

3929 GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;

3930 GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;

3931 GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;

3932 GLboolean __GLEW_NV_vertex_program4 = GL_FALSE;

3933 GLboolean __GLEW_NV_video_capture = GL_FALSE;

3934 GLboolean __GLEW_NV_viewport_array = GL_FALSE;

3935 GLboolean __GLEW_NV_viewport_array2 = GL_FALSE;

3936 GLboolean __GLEW_NV_viewport_swizzle = GL_FALSE;

3937 GLboolean __GLEW_OES_byte_coordinates = GL_FALSE;

3938 GLboolean __GLEW_OML_interlace = GL_FALSE;

3939 GLboolean __GLEW_OML_resample = GL_FALSE;

3940 GLboolean __GLEW_OML_subsample = GL_FALSE;

3941 GLboolean __GLEW_OVR_multiview = GL_FALSE;

3942 GLboolean __GLEW_OVR_multiview2 = GL_FALSE;

3943 GLboolean __GLEW_OVR_multiview_multisampled_render_to_texture = GL_FALSE;

3944 GLboolean __GLEW_PGI_misc_hints = GL_FALSE;

3945 GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;

3946 GLboolean __GLEW_QCOM_alpha_test = GL_FALSE;

3947 GLboolean __GLEW_QCOM_binning_control = GL_FALSE;

3948 GLboolean __GLEW_QCOM_driver_control = GL_FALSE;

3949 GLboolean __GLEW_QCOM_extended_get = GL_FALSE;

3950 GLboolean __GLEW_QCOM_extended_get2 = GL_FALSE;

3951 GLboolean __GLEW_QCOM_framebuffer_foveated = GL_FALSE;

3952 GLboolean __GLEW_QCOM_perfmon_global_mode = GL_FALSE;

3953 GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent = GL_FALSE;

3954 GLboolean __GLEW_QCOM_tiled_rendering = GL_FALSE;

3955 GLboolean __GLEW_QCOM_writeonly_rendering = GL_FALSE;

3956 GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE;

3957 GLboolean __GLEW_REGAL_ES1_1_compatibility = GL_FALSE;

3958 GLboolean __GLEW_REGAL_enable = GL_FALSE;

3959 GLboolean __GLEW_REGAL_error_string = GL_FALSE;

3960 GLboolean __GLEW_REGAL_extension_query = GL_FALSE;

3961 GLboolean __GLEW_REGAL_log = GL_FALSE;

3962 GLboolean __GLEW_REGAL_proc_address = GL_FALSE;

3963 GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;

3964 GLboolean __GLEW_S3_s3tc = GL_FALSE;

3965 GLboolean __GLEW_SGIS_clip_band_hint = GL_FALSE;

3966 GLboolean __GLEW_SGIS_color_range = GL_FALSE;

3967 GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;

3968 GLboolean __GLEW_SGIS_fog_function = GL_FALSE;

3969 GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;

3970 GLboolean __GLEW_SGIS_line_texgen = GL_FALSE;

3971 GLboolean __GLEW_SGIS_multisample = GL_FALSE;

3972 GLboolean __GLEW_SGIS_multitexture = GL_FALSE;

3973 GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;

3974 GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE;

3975 GLboolean __GLEW_SGIS_shared_multisample = GL_FALSE;

3976 GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;

3977 GLboolean __GLEW_SGIS_texture4D = GL_FALSE;

3978 GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;

3979 GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;

3980 GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;

3981 GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;

3982 GLboolean __GLEW_SGIS_texture_select = GL_FALSE;

3983 GLboolean __GLEW_SGIX_async = GL_FALSE;

3984 GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;

3985 GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;

3986 GLboolean __GLEW_SGIX_bali_g_instruments = GL_FALSE;

3987 GLboolean __GLEW_SGIX_bali_r_instruments = GL_FALSE;

3988 GLboolean __GLEW_SGIX_bali_timer_instruments = GL_FALSE;

3989 GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;

3990 GLboolean __GLEW_SGIX_blend_cadd = GL_FALSE;

3991 GLboolean __GLEW_SGIX_blend_cmultiply = GL_FALSE;

3992 GLboolean __GLEW_SGIX_calligraphic_fragment = GL_FALSE;

3993 GLboolean __GLEW_SGIX_clipmap = GL_FALSE;

3994 GLboolean __GLEW_SGIX_color_matrix_accuracy = GL_FALSE;

3995 GLboolean __GLEW_SGIX_color_table_index_mode = GL_FALSE;

3996 GLboolean __GLEW_SGIX_complex_polar = GL_FALSE;

3997 GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE;

3998 GLboolean __GLEW_SGIX_cube_map = GL_FALSE;

3999 GLboolean __GLEW_SGIX_cylinder_texgen = GL_FALSE;

4000 GLboolean __GLEW_SGIX_datapipe = GL_FALSE;

4001 GLboolean __GLEW_SGIX_decimation = GL_FALSE;

4002 GLboolean __GLEW_SGIX_depth_pass_instrument = GL_FALSE;

4003 GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;

4004 GLboolean __GLEW_SGIX_dvc = GL_FALSE;

4005 GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;

4006 GLboolean __GLEW_SGIX_fog_blend = GL_FALSE;

4007 GLboolean __GLEW_SGIX_fog_factor_to_alpha = GL_FALSE;

4008 GLboolean __GLEW_SGIX_fog_layers = GL_FALSE;

4009 GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;

4010 GLboolean __GLEW_SGIX_fog_patchy = GL_FALSE;

4011 GLboolean __GLEW_SGIX_fog_scale = GL_FALSE;

4012 GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;

4013 GLboolean __GLEW_SGIX_fragment_lighting_space = GL_FALSE;

4014 GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;

4015 GLboolean __GLEW_SGIX_fragments_instrument = GL_FALSE;

4016 GLboolean __GLEW_SGIX_framezoom = GL_FALSE;

4017 GLboolean __GLEW_SGIX_icc_texture = GL_FALSE;

4018 GLboolean __GLEW_SGIX_igloo_interface = GL_FALSE;

4019 GLboolean __GLEW_SGIX_image_compression = GL_FALSE;

4020 GLboolean __GLEW_SGIX_impact_pixel_texture = GL_FALSE;

4021 GLboolean __GLEW_SGIX_instrument_error = GL_FALSE;

4022 GLboolean __GLEW_SGIX_interlace = GL_FALSE;

4023 GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;

4024 GLboolean __GLEW_SGIX_line_quality_hint = GL_FALSE;

4025 GLboolean __GLEW_SGIX_list_priority = GL_FALSE;

4026 GLboolean __GLEW_SGIX_mpeg1 = GL_FALSE;

4027 GLboolean __GLEW_SGIX_mpeg2 = GL_FALSE;

4028 GLboolean __GLEW_SGIX_nonlinear_lighting_pervertex = GL_FALSE;

4029 GLboolean __GLEW_SGIX_nurbs_eval = GL_FALSE;

4030 GLboolean __GLEW_SGIX_occlusion_instrument = GL_FALSE;

4031 GLboolean __GLEW_SGIX_packed_6bytes = GL_FALSE;

4032 GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;

4033 GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;

4034 GLboolean __GLEW_SGIX_pixel_texture_lod = GL_FALSE;

4035 GLboolean __GLEW_SGIX_pixel_tiles = GL_FALSE;

4036 GLboolean __GLEW_SGIX_polynomial_ffd = GL_FALSE;

4037 GLboolean __GLEW_SGIX_quad_mesh = GL_FALSE;

4038 GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;

4039 GLboolean __GLEW_SGIX_resample = GL_FALSE;

4040 GLboolean __GLEW_SGIX_scalebias_hint = GL_FALSE;

4041 GLboolean __GLEW_SGIX_shadow = GL_FALSE;

4042 GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;

4043 GLboolean __GLEW_SGIX_slim = GL_FALSE;

4044 GLboolean __GLEW_SGIX_spotlight_cutoff = GL_FALSE;

4045 GLboolean __GLEW_SGIX_sprite = GL_FALSE;

4046 GLboolean __GLEW_SGIX_subdiv_patch = GL_FALSE;

4047 GLboolean __GLEW_SGIX_subsample = GL_FALSE;

4048 GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;

4049 GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;

4050 GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;

4051 GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;

4052 GLboolean __GLEW_SGIX_texture_mipmap_anisotropic = GL_FALSE;

4053 GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;

4054 GLboolean __GLEW_SGIX_texture_phase = GL_FALSE;

4055 GLboolean __GLEW_SGIX_texture_range = GL_FALSE;

4056 GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;

4057 GLboolean __GLEW_SGIX_texture_supersample = GL_FALSE;

4058 GLboolean __GLEW_SGIX_vector_ops = GL_FALSE;

4059 GLboolean __GLEW_SGIX_vertex_array_object = GL_FALSE;

4060 GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;

4061 GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;

4062 GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;

4063 GLboolean __GLEW_SGIX_ycrcb_subsample = GL_FALSE;

4064 GLboolean __GLEW_SGIX_ycrcba = GL_FALSE;

4065 GLboolean __GLEW_SGI_color_matrix = GL_FALSE;

4066 GLboolean __GLEW_SGI_color_table = GL_FALSE;

4067 GLboolean __GLEW_SGI_complex = GL_FALSE;

4068 GLboolean __GLEW_SGI_complex_type = GL_FALSE;

4069 GLboolean __GLEW_SGI_fft = GL_FALSE;

4070 GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;

4071 GLboolean __GLEW_SUNX_constant_data = GL_FALSE;

4072 GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;

4073 GLboolean __GLEW_SUN_global_alpha = GL_FALSE;

4074 GLboolean __GLEW_SUN_mesh_array = GL_FALSE;

4075 GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;

4076 GLboolean __GLEW_SUN_slice_accum = GL_FALSE;

4077 GLboolean __GLEW_SUN_triangle_list = GL_FALSE;

4078 GLboolean __GLEW_SUN_vertex = GL_FALSE;

4079 GLboolean __GLEW_WIN_phong_shading = GL_FALSE;

4080 GLboolean __GLEW_WIN_scene_markerXXX = GL_FALSE;

4081 GLboolean __GLEW_WIN_specular_fog = GL_FALSE;

4082 GLboolean __GLEW_WIN_swap_hint = GL_FALSE;

4083

4084 static const char * _glewExtensionLookup[] = {

4085 #ifdef GL_VERSION_1_2

4086 "GL_VERSION_1_2",

4087 #endif

4088 #ifdef GL_VERSION_1_2_1

4089 "GL_VERSION_1_2_1",

4090 #endif

4091 #ifdef GL_VERSION_1_3

4092 "GL_VERSION_1_3",

4093 #endif

4094 #ifdef GL_VERSION_1_4

4095 "GL_VERSION_1_4",

4096 #endif

4097 #ifdef GL_VERSION_1_5

4098 "GL_VERSION_1_5",

4099 #endif

4100 #ifdef GL_VERSION_2_0

4101 "GL_VERSION_2_0",

4102 #endif

4103 #ifdef GL_VERSION_2_1

4104 "GL_VERSION_2_1",

4105 #endif

4106 #ifdef GL_VERSION_3_0

4107 "GL_VERSION_3_0",

4108 #endif

4109 #ifdef GL_VERSION_3_1

4110 "GL_VERSION_3_1",

4111 #endif

4112 #ifdef GL_VERSION_3_2

4113 "GL_VERSION_3_2",

4114 #endif

4115 #ifdef GL_VERSION_3_3

4116 "GL_VERSION_3_3",

4117 #endif

4118 #ifdef GL_VERSION_4_0

4119 "GL_VERSION_4_0",

4120 #endif

4121 #ifdef GL_VERSION_4_1

4122 "GL_VERSION_4_1",

4123 #endif

4124 #ifdef GL_VERSION_4_2

4125 "GL_VERSION_4_2",

4126 #endif

4127 #ifdef GL_VERSION_4_3

4128 "GL_VERSION_4_3",

4129 #endif

4130 #ifdef GL_VERSION_4_4

4131 "GL_VERSION_4_4",

4132 #endif

4133 #ifdef GL_VERSION_4_5

4134 "GL_VERSION_4_5",

4135 #endif

4136 #ifdef GL_VERSION_4_6

4137 "GL_VERSION_4_6",

4138 #endif

4139 #ifdef GL_3DFX_multisample

4140 "GL_3DFX_multisample",

4141 #endif

4142 #ifdef GL_3DFX_tbuffer

4143 "GL_3DFX_tbuffer",

4144 #endif

4145 #ifdef GL_3DFX_texture_compression_FXT1

4146 "GL_3DFX_texture_compression_FXT1",

4147 #endif

4148 #ifdef GL_AMD_blend_minmax_factor

4149 "GL_AMD_blend_minmax_factor",

4150 #endif

4151 #ifdef GL_AMD_compressed_3DC_texture

4152 "GL_AMD_compressed_3DC_texture",

4153 #endif

4154 #ifdef GL_AMD_compressed_ATC_texture

4155 "GL_AMD_compressed_ATC_texture",

4156 #endif

4157 #ifdef GL_AMD_conservative_depth

4158 "GL_AMD_conservative_depth",

4159 #endif

4160 #ifdef GL_AMD_debug_output

4161 "GL_AMD_debug_output",

4162 #endif

4163 #ifdef GL_AMD_depth_clamp_separate

4164 "GL_AMD_depth_clamp_separate",

4165 #endif

4166 #ifdef GL_AMD_draw_buffers_blend

4167 "GL_AMD_draw_buffers_blend",

4168 #endif

4169 #ifdef GL_AMD_framebuffer_sample_positions

4170 "GL_AMD_framebuffer_sample_positions",

4171 #endif

4172 #ifdef GL_AMD_gcn_shader

4173 "GL_AMD_gcn_shader",

4174 #endif

4175 #ifdef GL_AMD_gpu_shader_half_float

4176 "GL_AMD_gpu_shader_half_float",

4177 #endif

4178 #ifdef GL_AMD_gpu_shader_int16

4179 "GL_AMD_gpu_shader_int16",

4180 #endif

4181 #ifdef GL_AMD_gpu_shader_int64

4182 "GL_AMD_gpu_shader_int64",

4183 #endif

4184 #ifdef GL_AMD_interleaved_elements

4185 "GL_AMD_interleaved_elements",

4186 #endif

4187 #ifdef GL_AMD_multi_draw_indirect

4188 "GL_AMD_multi_draw_indirect",

4189 #endif

4190 #ifdef GL_AMD_name_gen_delete

4191 "GL_AMD_name_gen_delete",

4192 #endif

4193 #ifdef GL_AMD_occlusion_query_event

4194 "GL_AMD_occlusion_query_event",

4195 #endif

4196 #ifdef GL_AMD_performance_monitor

4197 "GL_AMD_performance_monitor",

4198 #endif

4199 #ifdef GL_AMD_pinned_memory

4200 "GL_AMD_pinned_memory",

4201 #endif

4202 #ifdef GL_AMD_program_binary_Z400

4203 "GL_AMD_program_binary_Z400",

4204 #endif

4205 #ifdef GL_AMD_query_buffer_object

4206 "GL_AMD_query_buffer_object",

4207 #endif

4208 #ifdef GL_AMD_sample_positions

4209 "GL_AMD_sample_positions",

4210 #endif

4211 #ifdef GL_AMD_seamless_cubemap_per_texture

4212 "GL_AMD_seamless_cubemap_per_texture",

4213 #endif

4214 #ifdef GL_AMD_shader_atomic_counter_ops

4215 "GL_AMD_shader_atomic_counter_ops",

4216 #endif

4217 #ifdef GL_AMD_shader_ballot

4218 "GL_AMD_shader_ballot",

4219 #endif

4220 #ifdef GL_AMD_shader_explicit_vertex_parameter

4221 "GL_AMD_shader_explicit_vertex_parameter",

4222 #endif

4223 #ifdef GL_AMD_shader_stencil_export

4224 "GL_AMD_shader_stencil_export",

4225 #endif

4226 #ifdef GL_AMD_shader_stencil_value_export

4227 "GL_AMD_shader_stencil_value_export",

4228 #endif

4229 #ifdef GL_AMD_shader_trinary_minmax

4230 "GL_AMD_shader_trinary_minmax",

4231 #endif

4232 #ifdef GL_AMD_sparse_texture

4233 "GL_AMD_sparse_texture",

4234 #endif

4235 #ifdef GL_AMD_stencil_operation_extended

4236 "GL_AMD_stencil_operation_extended",

4237 #endif

4238 #ifdef GL_AMD_texture_gather_bias_lod

4239 "GL_AMD_texture_gather_bias_lod",

4240 #endif

4241 #ifdef GL_AMD_texture_texture4

4242 "GL_AMD_texture_texture4",

4243 #endif

4244 #ifdef GL_AMD_transform_feedback3_lines_triangles

4245 "GL_AMD_transform_feedback3_lines_triangles",

4246 #endif

4247 #ifdef GL_AMD_transform_feedback4

4248 "GL_AMD_transform_feedback4",

4249 #endif

4250 #ifdef GL_AMD_vertex_shader_layer

4251 "GL_AMD_vertex_shader_layer",

4252 #endif

4253 #ifdef GL_AMD_vertex_shader_tessellator

4254 "GL_AMD_vertex_shader_tessellator",

4255 #endif

4256 #ifdef GL_AMD_vertex_shader_viewport_index

4257 "GL_AMD_vertex_shader_viewport_index",

4258 #endif

4259 #ifdef GL_ANDROID_extension_pack_es31a

4260 "GL_ANDROID_extension_pack_es31a",

4261 #endif

4262 #ifdef GL_ANGLE_depth_texture

4263 "GL_ANGLE_depth_texture",

4264 #endif

4265 #ifdef GL_ANGLE_framebuffer_blit

4266 "GL_ANGLE_framebuffer_blit",

4267 #endif

4268 #ifdef GL_ANGLE_framebuffer_multisample

4269 "GL_ANGLE_framebuffer_multisample",

4270 #endif

4271 #ifdef GL_ANGLE_instanced_arrays

4272 "GL_ANGLE_instanced_arrays",

4273 #endif

4274 #ifdef GL_ANGLE_pack_reverse_row_order

4275 "GL_ANGLE_pack_reverse_row_order",

4276 #endif

4277 #ifdef GL_ANGLE_program_binary

4278 "GL_ANGLE_program_binary",

4279 #endif

4280 #ifdef GL_ANGLE_texture_compression_dxt1

4281 "GL_ANGLE_texture_compression_dxt1",

4282 #endif

4283 #ifdef GL_ANGLE_texture_compression_dxt3

4284 "GL_ANGLE_texture_compression_dxt3",

4285 #endif

4286 #ifdef GL_ANGLE_texture_compression_dxt5

4287 "GL_ANGLE_texture_compression_dxt5",

4288 #endif

4289 #ifdef GL_ANGLE_texture_usage

4290 "GL_ANGLE_texture_usage",

4291 #endif

4292 #ifdef GL_ANGLE_timer_query

4293 "GL_ANGLE_timer_query",

4294 #endif

4295 #ifdef GL_ANGLE_translated_shader_source

4296 "GL_ANGLE_translated_shader_source",

4297 #endif

4298 #ifdef GL_APPLE_aux_depth_stencil

4299 "GL_APPLE_aux_depth_stencil",

4300 #endif

4301 #ifdef GL_APPLE_client_storage

4302 "GL_APPLE_client_storage",

4303 #endif

4304 #ifdef GL_APPLE_clip_distance

4305 "GL_APPLE_clip_distance",

4306 #endif

4307 #ifdef GL_APPLE_color_buffer_packed_float

4308 "GL_APPLE_color_buffer_packed_float",

4309 #endif

4310 #ifdef GL_APPLE_copy_texture_levels

4311 "GL_APPLE_copy_texture_levels",

4312 #endif

4313 #ifdef GL_APPLE_element_array

4314 "GL_APPLE_element_array",

4315 #endif

4316 #ifdef GL_APPLE_fence

4317 "GL_APPLE_fence",

4318 #endif

4319 #ifdef GL_APPLE_float_pixels

4320 "GL_APPLE_float_pixels",

4321 #endif

4322 #ifdef GL_APPLE_flush_buffer_range

4323 "GL_APPLE_flush_buffer_range",

4324 #endif

4325 #ifdef GL_APPLE_framebuffer_multisample

4326 "GL_APPLE_framebuffer_multisample",

4327 #endif

4328 #ifdef GL_APPLE_object_purgeable

4329 "GL_APPLE_object_purgeable",

4330 #endif

4331 #ifdef GL_APPLE_pixel_buffer

4332 "GL_APPLE_pixel_buffer",

4333 #endif

4334 #ifdef GL_APPLE_rgb_422

4335 "GL_APPLE_rgb_422",

4336 #endif

4337 #ifdef GL_APPLE_row_bytes

4338 "GL_APPLE_row_bytes",

4339 #endif

4340 #ifdef GL_APPLE_specular_vector

4341 "GL_APPLE_specular_vector",

4342 #endif

4343 #ifdef GL_APPLE_sync

4344 "GL_APPLE_sync",

4345 #endif

4346 #ifdef GL_APPLE_texture_2D_limited_npot

4347 "GL_APPLE_texture_2D_limited_npot",

4348 #endif

4349 #ifdef GL_APPLE_texture_format_BGRA8888

4350 "GL_APPLE_texture_format_BGRA8888",

4351 #endif

4352 #ifdef GL_APPLE_texture_max_level

4353 "GL_APPLE_texture_max_level",

4354 #endif

4355 #ifdef GL_APPLE_texture_packed_float

4356 "GL_APPLE_texture_packed_float",

4357 #endif

4358 #ifdef GL_APPLE_texture_range

4359 "GL_APPLE_texture_range",

4360 #endif

4361 #ifdef GL_APPLE_transform_hint

4362 "GL_APPLE_transform_hint",

4363 #endif

4364 #ifdef GL_APPLE_vertex_array_object

4365 "GL_APPLE_vertex_array_object",

4366 #endif

4367 #ifdef GL_APPLE_vertex_array_range

4368 "GL_APPLE_vertex_array_range",

4369 #endif

4370 #ifdef GL_APPLE_vertex_program_evaluators

4371 "GL_APPLE_vertex_program_evaluators",

4372 #endif

4373 #ifdef GL_APPLE_ycbcr_422

4374 "GL_APPLE_ycbcr_422",

4375 #endif

4376 #ifdef GL_ARB_ES2_compatibility

4377 "GL_ARB_ES2_compatibility",

4378 #endif

4379 #ifdef GL_ARB_ES3_1_compatibility

4380 "GL_ARB_ES3_1_compatibility",

4381 #endif

4382 #ifdef GL_ARB_ES3_2_compatibility

4383 "GL_ARB_ES3_2_compatibility",

4384 #endif

4385 #ifdef GL_ARB_ES3_compatibility

4386 "GL_ARB_ES3_compatibility",

4387 #endif

4388 #ifdef GL_ARB_arrays_of_arrays

4389 "GL_ARB_arrays_of_arrays",

4390 #endif

4391 #ifdef GL_ARB_base_instance

4392 "GL_ARB_base_instance",

4393 #endif

4394 #ifdef GL_ARB_bindless_texture

4395 "GL_ARB_bindless_texture",

4396 #endif

4397 #ifdef GL_ARB_blend_func_extended

4398 "GL_ARB_blend_func_extended",

4399 #endif

4400 #ifdef GL_ARB_buffer_storage

4401 "GL_ARB_buffer_storage",

4402 #endif

4403 #ifdef GL_ARB_cl_event

4404 "GL_ARB_cl_event",

4405 #endif

4406 #ifdef GL_ARB_clear_buffer_object

4407 "GL_ARB_clear_buffer_object",

4408 #endif

4409 #ifdef GL_ARB_clear_texture

4410 "GL_ARB_clear_texture",

4411 #endif

4412 #ifdef GL_ARB_clip_control

4413 "GL_ARB_clip_control",

4414 #endif

4415 #ifdef GL_ARB_color_buffer_float

4416 "GL_ARB_color_buffer_float",

4417 #endif

4418 #ifdef GL_ARB_compatibility

4419 "GL_ARB_compatibility",

4420 #endif

4421 #ifdef GL_ARB_compressed_texture_pixel_storage

4422 "GL_ARB_compressed_texture_pixel_storage",

4423 #endif

4424 #ifdef GL_ARB_compute_shader

4425 "GL_ARB_compute_shader",

4426 #endif

4427 #ifdef GL_ARB_compute_variable_group_size

4428 "GL_ARB_compute_variable_group_size",

4429 #endif

4430 #ifdef GL_ARB_conditional_render_inverted

4431 "GL_ARB_conditional_render_inverted",

4432 #endif

4433 #ifdef GL_ARB_conservative_depth

4434 "GL_ARB_conservative_depth",

4435 #endif

4436 #ifdef GL_ARB_copy_buffer

4437 "GL_ARB_copy_buffer",

4438 #endif

4439 #ifdef GL_ARB_copy_image

4440 "GL_ARB_copy_image",

4441 #endif

4442 #ifdef GL_ARB_cull_distance

4443 "GL_ARB_cull_distance",

4444 #endif

4445 #ifdef GL_ARB_debug_output

4446 "GL_ARB_debug_output",

4447 #endif

4448 #ifdef GL_ARB_depth_buffer_float

4449 "GL_ARB_depth_buffer_float",

4450 #endif

4451 #ifdef GL_ARB_depth_clamp

4452 "GL_ARB_depth_clamp",

4453 #endif

4454 #ifdef GL_ARB_depth_texture

4455 "GL_ARB_depth_texture",

4456 #endif

4457 #ifdef GL_ARB_derivative_control

4458 "GL_ARB_derivative_control",

4459 #endif

4460 #ifdef GL_ARB_direct_state_access

4461 "GL_ARB_direct_state_access",

4462 #endif

4463 #ifdef GL_ARB_draw_buffers

4464 "GL_ARB_draw_buffers",

4465 #endif

4466 #ifdef GL_ARB_draw_buffers_blend

4467 "GL_ARB_draw_buffers_blend",

4468 #endif

4469 #ifdef GL_ARB_draw_elements_base_vertex

4470 "GL_ARB_draw_elements_base_vertex",

4471 #endif

4472 #ifdef GL_ARB_draw_indirect

4473 "GL_ARB_draw_indirect",

4474 #endif

4475 #ifdef GL_ARB_draw_instanced

4476 "GL_ARB_draw_instanced",

4477 #endif

4478 #ifdef GL_ARB_enhanced_layouts

4479 "GL_ARB_enhanced_layouts",

4480 #endif

4481 #ifdef GL_ARB_explicit_attrib_location

4482 "GL_ARB_explicit_attrib_location",

4483 #endif

4484 #ifdef GL_ARB_explicit_uniform_location

4485 "GL_ARB_explicit_uniform_location",

4486 #endif

4487 #ifdef GL_ARB_fragment_coord_conventions

4488 "GL_ARB_fragment_coord_conventions",

4489 #endif

4490 #ifdef GL_ARB_fragment_layer_viewport

4491 "GL_ARB_fragment_layer_viewport",

4492 #endif

4493 #ifdef GL_ARB_fragment_program

4494 "GL_ARB_fragment_program",

4495 #endif

4496 #ifdef GL_ARB_fragment_program_shadow

4497 "GL_ARB_fragment_program_shadow",

4498 #endif

4499 #ifdef GL_ARB_fragment_shader

4500 "GL_ARB_fragment_shader",

4501 #endif

4502 #ifdef GL_ARB_fragment_shader_interlock

4503 "GL_ARB_fragment_shader_interlock",

4504 #endif

4505 #ifdef GL_ARB_framebuffer_no_attachments

4506 "GL_ARB_framebuffer_no_attachments",

4507 #endif

4508 #ifdef GL_ARB_framebuffer_object

4509 "GL_ARB_framebuffer_object",

4510 #endif

4511 #ifdef GL_ARB_framebuffer_sRGB

4512 "GL_ARB_framebuffer_sRGB",

4513 #endif

4514 #ifdef GL_ARB_geometry_shader4

4515 "GL_ARB_geometry_shader4",

4516 #endif

4517 #ifdef GL_ARB_get_program_binary

4518 "GL_ARB_get_program_binary",

4519 #endif

4520 #ifdef GL_ARB_get_texture_sub_image

4521 "GL_ARB_get_texture_sub_image",

4522 #endif

4523 #ifdef GL_ARB_gl_spirv

4524 "GL_ARB_gl_spirv",

4525 #endif

4526 #ifdef GL_ARB_gpu_shader5

4527 "GL_ARB_gpu_shader5",

4528 #endif

4529 #ifdef GL_ARB_gpu_shader_fp64

4530 "GL_ARB_gpu_shader_fp64",

4531 #endif

4532 #ifdef GL_ARB_gpu_shader_int64

4533 "GL_ARB_gpu_shader_int64",

4534 #endif

4535 #ifdef GL_ARB_half_float_pixel

4536 "GL_ARB_half_float_pixel",

4537 #endif

4538 #ifdef GL_ARB_half_float_vertex

4539 "GL_ARB_half_float_vertex",

4540 #endif

4541 #ifdef GL_ARB_imaging

4542 "GL_ARB_imaging",

4543 #endif

4544 #ifdef GL_ARB_indirect_parameters

4545 "GL_ARB_indirect_parameters",

4546 #endif

4547 #ifdef GL_ARB_instanced_arrays

4548 "GL_ARB_instanced_arrays",

4549 #endif

4550 #ifdef GL_ARB_internalformat_query

4551 "GL_ARB_internalformat_query",

4552 #endif

4553 #ifdef GL_ARB_internalformat_query2

4554 "GL_ARB_internalformat_query2",

4555 #endif

4556 #ifdef GL_ARB_invalidate_subdata

4557 "GL_ARB_invalidate_subdata",

4558 #endif

4559 #ifdef GL_ARB_map_buffer_alignment

4560 "GL_ARB_map_buffer_alignment",

4561 #endif

4562 #ifdef GL_ARB_map_buffer_range

4563 "GL_ARB_map_buffer_range",

4564 #endif

4565 #ifdef GL_ARB_matrix_palette

4566 "GL_ARB_matrix_palette",

4567 #endif

4568 #ifdef GL_ARB_multi_bind

4569 "GL_ARB_multi_bind",

4570 #endif

4571 #ifdef GL_ARB_multi_draw_indirect

4572 "GL_ARB_multi_draw_indirect",

4573 #endif

4574 #ifdef GL_ARB_multisample

4575 "GL_ARB_multisample",

4576 #endif

4577 #ifdef GL_ARB_multitexture

4578 "GL_ARB_multitexture",

4579 #endif

4580 #ifdef GL_ARB_occlusion_query

4581 "GL_ARB_occlusion_query",

4582 #endif

4583 #ifdef GL_ARB_occlusion_query2

4584 "GL_ARB_occlusion_query2",

4585 #endif

4586 #ifdef GL_ARB_parallel_shader_compile

4587 "GL_ARB_parallel_shader_compile",

4588 #endif

4589 #ifdef GL_ARB_pipeline_statistics_query

4590 "GL_ARB_pipeline_statistics_query",

4591 #endif

4592 #ifdef GL_ARB_pixel_buffer_object

4593 "GL_ARB_pixel_buffer_object",

4594 #endif

4595 #ifdef GL_ARB_point_parameters

4596 "GL_ARB_point_parameters",

4597 #endif

4598 #ifdef GL_ARB_point_sprite

4599 "GL_ARB_point_sprite",

4600 #endif

4601 #ifdef GL_ARB_polygon_offset_clamp

4602 "GL_ARB_polygon_offset_clamp",

4603 #endif

4604 #ifdef GL_ARB_post_depth_coverage

4605 "GL_ARB_post_depth_coverage",

4606 #endif

4607 #ifdef GL_ARB_program_interface_query

4608 "GL_ARB_program_interface_query",

4609 #endif

4610 #ifdef GL_ARB_provoking_vertex

4611 "GL_ARB_provoking_vertex",

4612 #endif

4613 #ifdef GL_ARB_query_buffer_object

4614 "GL_ARB_query_buffer_object",

4615 #endif

4616 #ifdef GL_ARB_robust_buffer_access_behavior

4617 "GL_ARB_robust_buffer_access_behavior",

4618 #endif

4619 #ifdef GL_ARB_robustness

4620 "GL_ARB_robustness",

4621 #endif

4622 #ifdef GL_ARB_robustness_application_isolation

4623 "GL_ARB_robustness_application_isolation",

4624 #endif

4625 #ifdef GL_ARB_robustness_share_group_isolation

4626 "GL_ARB_robustness_share_group_isolation",

4627 #endif

4628 #ifdef GL_ARB_sample_locations

4629 "GL_ARB_sample_locations",

4630 #endif

4631 #ifdef GL_ARB_sample_shading

4632 "GL_ARB_sample_shading",

4633 #endif

4634 #ifdef GL_ARB_sampler_objects

4635 "GL_ARB_sampler_objects",

4636 #endif

4637 #ifdef GL_ARB_seamless_cube_map

4638 "GL_ARB_seamless_cube_map",

4639 #endif

4640 #ifdef GL_ARB_seamless_cubemap_per_texture

4641 "GL_ARB_seamless_cubemap_per_texture",

4642 #endif

4643 #ifdef GL_ARB_separate_shader_objects

4644 "GL_ARB_separate_shader_objects",

4645 #endif

4646 #ifdef GL_ARB_shader_atomic_counter_ops

4647 "GL_ARB_shader_atomic_counter_ops",

4648 #endif

4649 #ifdef GL_ARB_shader_atomic_counters

4650 "GL_ARB_shader_atomic_counters",

4651 #endif

4652 #ifdef GL_ARB_shader_ballot

4653 "GL_ARB_shader_ballot",

4654 #endif

4655 #ifdef GL_ARB_shader_bit_encoding

4656 "GL_ARB_shader_bit_encoding",

4657 #endif

4658 #ifdef GL_ARB_shader_clock

4659 "GL_ARB_shader_clock",

4660 #endif

4661 #ifdef GL_ARB_shader_draw_parameters

4662 "GL_ARB_shader_draw_parameters",

4663 #endif

4664 #ifdef GL_ARB_shader_group_vote

4665 "GL_ARB_shader_group_vote",

4666 #endif

4667 #ifdef GL_ARB_shader_image_load_store

4668 "GL_ARB_shader_image_load_store",

4669 #endif

4670 #ifdef GL_ARB_shader_image_size

4671 "GL_ARB_shader_image_size",

4672 #endif

4673 #ifdef GL_ARB_shader_objects

4674 "GL_ARB_shader_objects",

4675 #endif

4676 #ifdef GL_ARB_shader_precision

4677 "GL_ARB_shader_precision",

4678 #endif

4679 #ifdef GL_ARB_shader_stencil_export

4680 "GL_ARB_shader_stencil_export",

4681 #endif

4682 #ifdef GL_ARB_shader_storage_buffer_object

4683 "GL_ARB_shader_storage_buffer_object",

4684 #endif

4685 #ifdef GL_ARB_shader_subroutine

4686 "GL_ARB_shader_subroutine",

4687 #endif

4688 #ifdef GL_ARB_shader_texture_image_samples

4689 "GL_ARB_shader_texture_image_samples",

4690 #endif

4691 #ifdef GL_ARB_shader_texture_lod

4692 "GL_ARB_shader_texture_lod",

4693 #endif

4694 #ifdef GL_ARB_shader_viewport_layer_array

4695 "GL_ARB_shader_viewport_layer_array",

4696 #endif

4697 #ifdef GL_ARB_shading_language_100

4698 "GL_ARB_shading_language_100",

4699 #endif

4700 #ifdef GL_ARB_shading_language_420pack

4701 "GL_ARB_shading_language_420pack",

4702 #endif

4703 #ifdef GL_ARB_shading_language_include

4704 "GL_ARB_shading_language_include",

4705 #endif

4706 #ifdef GL_ARB_shading_language_packing

4707 "GL_ARB_shading_language_packing",

4708 #endif

4709 #ifdef GL_ARB_shadow

4710 "GL_ARB_shadow",

4711 #endif

4712 #ifdef GL_ARB_shadow_ambient

4713 "GL_ARB_shadow_ambient",

4714 #endif

4715 #ifdef GL_ARB_sparse_buffer

4716 "GL_ARB_sparse_buffer",

4717 #endif

4718 #ifdef GL_ARB_sparse_texture

4719 "GL_ARB_sparse_texture",

4720 #endif

4721 #ifdef GL_ARB_sparse_texture2

4722 "GL_ARB_sparse_texture2",

4723 #endif

4724 #ifdef GL_ARB_sparse_texture_clamp

4725 "GL_ARB_sparse_texture_clamp",

4726 #endif

4727 #ifdef GL_ARB_spirv_extensions

4728 "GL_ARB_spirv_extensions",

4729 #endif

4730 #ifdef GL_ARB_stencil_texturing

4731 "GL_ARB_stencil_texturing",

4732 #endif

4733 #ifdef GL_ARB_sync

4734 "GL_ARB_sync",

4735 #endif

4736 #ifdef GL_ARB_tessellation_shader

4737 "GL_ARB_tessellation_shader",

4738 #endif

4739 #ifdef GL_ARB_texture_barrier

4740 "GL_ARB_texture_barrier",

4741 #endif

4742 #ifdef GL_ARB_texture_border_clamp

4743 "GL_ARB_texture_border_clamp",

4744 #endif

4745 #ifdef GL_ARB_texture_buffer_object

4746 "GL_ARB_texture_buffer_object",

4747 #endif

4748 #ifdef GL_ARB_texture_buffer_object_rgb32

4749 "GL_ARB_texture_buffer_object_rgb32",

4750 #endif

4751 #ifdef GL_ARB_texture_buffer_range

4752 "GL_ARB_texture_buffer_range",

4753 #endif

4754 #ifdef GL_ARB_texture_compression

4755 "GL_ARB_texture_compression",

4756 #endif

4757 #ifdef GL_ARB_texture_compression_bptc

4758 "GL_ARB_texture_compression_bptc",

4759 #endif

4760 #ifdef GL_ARB_texture_compression_rgtc

4761 "GL_ARB_texture_compression_rgtc",

4762 #endif

4763 #ifdef GL_ARB_texture_cube_map

4764 "GL_ARB_texture_cube_map",

4765 #endif

4766 #ifdef GL_ARB_texture_cube_map_array

4767 "GL_ARB_texture_cube_map_array",

4768 #endif

4769 #ifdef GL_ARB_texture_env_add

4770 "GL_ARB_texture_env_add",

4771 #endif

4772 #ifdef GL_ARB_texture_env_combine

4773 "GL_ARB_texture_env_combine",

4774 #endif

4775 #ifdef GL_ARB_texture_env_crossbar

4776 "GL_ARB_texture_env_crossbar",

4777 #endif

4778 #ifdef GL_ARB_texture_env_dot3

4779 "GL_ARB_texture_env_dot3",

4780 #endif

4781 #ifdef GL_ARB_texture_filter_anisotropic

4782 "GL_ARB_texture_filter_anisotropic",

4783 #endif

4784 #ifdef GL_ARB_texture_filter_minmax

4785 "GL_ARB_texture_filter_minmax",

4786 #endif

4787 #ifdef GL_ARB_texture_float

4788 "GL_ARB_texture_float",

4789 #endif

4790 #ifdef GL_ARB_texture_gather

4791 "GL_ARB_texture_gather",

4792 #endif

4793 #ifdef GL_ARB_texture_mirror_clamp_to_edge

4794 "GL_ARB_texture_mirror_clamp_to_edge",

4795 #endif

4796 #ifdef GL_ARB_texture_mirrored_repeat

4797 "GL_ARB_texture_mirrored_repeat",

4798 #endif

4799 #ifdef GL_ARB_texture_multisample

4800 "GL_ARB_texture_multisample",

4801 #endif

4802 #ifdef GL_ARB_texture_non_power_of_two

4803 "GL_ARB_texture_non_power_of_two",

4804 #endif

4805 #ifdef GL_ARB_texture_query_levels

4806 "GL_ARB_texture_query_levels",

4807 #endif

4808 #ifdef GL_ARB_texture_query_lod

4809 "GL_ARB_texture_query_lod",

4810 #endif

4811 #ifdef GL_ARB_texture_rectangle

4812 "GL_ARB_texture_rectangle",

4813 #endif

4814 #ifdef GL_ARB_texture_rg

4815 "GL_ARB_texture_rg",

4816 #endif

4817 #ifdef GL_ARB_texture_rgb10_a2ui

4818 "GL_ARB_texture_rgb10_a2ui",

4819 #endif

4820 #ifdef GL_ARB_texture_stencil8

4821 "GL_ARB_texture_stencil8",

4822 #endif

4823 #ifdef GL_ARB_texture_storage

4824 "GL_ARB_texture_storage",

4825 #endif

4826 #ifdef GL_ARB_texture_storage_multisample

4827 "GL_ARB_texture_storage_multisample",

4828 #endif

4829 #ifdef GL_ARB_texture_swizzle

4830 "GL_ARB_texture_swizzle",

4831 #endif

4832 #ifdef GL_ARB_texture_view

4833 "GL_ARB_texture_view",

4834 #endif

4835 #ifdef GL_ARB_timer_query

4836 "GL_ARB_timer_query",

4837 #endif

4838 #ifdef GL_ARB_transform_feedback2

4839 "GL_ARB_transform_feedback2",

4840 #endif

4841 #ifdef GL_ARB_transform_feedback3

4842 "GL_ARB_transform_feedback3",

4843 #endif

4844 #ifdef GL_ARB_transform_feedback_instanced

4845 "GL_ARB_transform_feedback_instanced",

4846 #endif

4847 #ifdef GL_ARB_transform_feedback_overflow_query

4848 "GL_ARB_transform_feedback_overflow_query",

4849 #endif

4850 #ifdef GL_ARB_transpose_matrix

4851 "GL_ARB_transpose_matrix",

4852 #endif

4853 #ifdef GL_ARB_uniform_buffer_object

4854 "GL_ARB_uniform_buffer_object",

4855 #endif

4856 #ifdef GL_ARB_vertex_array_bgra

4857 "GL_ARB_vertex_array_bgra",

4858 #endif

4859 #ifdef GL_ARB_vertex_array_object

4860 "GL_ARB_vertex_array_object",

4861 #endif

4862 #ifdef GL_ARB_vertex_attrib_64bit

4863 "GL_ARB_vertex_attrib_64bit",

4864 #endif

4865 #ifdef GL_ARB_vertex_attrib_binding

4866 "GL_ARB_vertex_attrib_binding",

4867 #endif

4868 #ifdef GL_ARB_vertex_blend

4869 "GL_ARB_vertex_blend",

4870 #endif

4871 #ifdef GL_ARB_vertex_buffer_object

4872 "GL_ARB_vertex_buffer_object",

4873 #endif

4874 #ifdef GL_ARB_vertex_program

4875 "GL_ARB_vertex_program",

4876 #endif

4877 #ifdef GL_ARB_vertex_shader

4878 "GL_ARB_vertex_shader",

4879 #endif

4880 #ifdef GL_ARB_vertex_type_10f_11f_11f_rev

4881 "GL_ARB_vertex_type_10f_11f_11f_rev",

4882 #endif

4883 #ifdef GL_ARB_vertex_type_2_10_10_10_rev

4884 "GL_ARB_vertex_type_2_10_10_10_rev",

4885 #endif

4886 #ifdef GL_ARB_viewport_array

4887 "GL_ARB_viewport_array",

4888 #endif

4889 #ifdef GL_ARB_window_pos

4890 "GL_ARB_window_pos",

4891 #endif

4892 #ifdef GL_ARM_mali_program_binary

4893 "GL_ARM_mali_program_binary",

4894 #endif

4895 #ifdef GL_ARM_mali_shader_binary

4896 "GL_ARM_mali_shader_binary",

4897 #endif

4898 #ifdef GL_ARM_rgba8

4899 "GL_ARM_rgba8",

4900 #endif

4901 #ifdef GL_ARM_shader_framebuffer_fetch

4902 "GL_ARM_shader_framebuffer_fetch",

4903 #endif

4904 #ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil

4905 "GL_ARM_shader_framebuffer_fetch_depth_stencil",

4906 #endif

4907 #ifdef GL_ATIX_point_sprites

4908 "GL_ATIX_point_sprites",

4909 #endif

4910 #ifdef GL_ATIX_texture_env_combine3

4911 "GL_ATIX_texture_env_combine3",

4912 #endif

4913 #ifdef GL_ATIX_texture_env_route

4914 "GL_ATIX_texture_env_route",

4915 #endif

4916 #ifdef GL_ATIX_vertex_shader_output_point_size

4917 "GL_ATIX_vertex_shader_output_point_size",

4918 #endif

4919 #ifdef GL_ATI_draw_buffers

4920 "GL_ATI_draw_buffers",

4921 #endif

4922 #ifdef GL_ATI_element_array

4923 "GL_ATI_element_array",

4924 #endif

4925 #ifdef GL_ATI_envmap_bumpmap

4926 "GL_ATI_envmap_bumpmap",

4927 #endif

4928 #ifdef GL_ATI_fragment_shader

4929 "GL_ATI_fragment_shader",

4930 #endif

4931 #ifdef GL_ATI_map_object_buffer

4932 "GL_ATI_map_object_buffer",

4933 #endif

4934 #ifdef GL_ATI_meminfo

4935 "GL_ATI_meminfo",

4936 #endif

4937 #ifdef GL_ATI_pn_triangles

4938 "GL_ATI_pn_triangles",

4939 #endif

4940 #ifdef GL_ATI_separate_stencil

4941 "GL_ATI_separate_stencil",

4942 #endif

4943 #ifdef GL_ATI_shader_texture_lod

4944 "GL_ATI_shader_texture_lod",

4945 #endif

4946 #ifdef GL_ATI_text_fragment_shader

4947 "GL_ATI_text_fragment_shader",

4948 #endif

4949 #ifdef GL_ATI_texture_compression_3dc

4950 "GL_ATI_texture_compression_3dc",

4951 #endif

4952 #ifdef GL_ATI_texture_env_combine3

4953 "GL_ATI_texture_env_combine3",

4954 #endif

4955 #ifdef GL_ATI_texture_float

4956 "GL_ATI_texture_float",

4957 #endif

4958 #ifdef GL_ATI_texture_mirror_once

4959 "GL_ATI_texture_mirror_once",

4960 #endif

4961 #ifdef GL_ATI_vertex_array_object

4962 "GL_ATI_vertex_array_object",

4963 #endif

4964 #ifdef GL_ATI_vertex_attrib_array_object

4965 "GL_ATI_vertex_attrib_array_object",

4966 #endif

4967 #ifdef GL_ATI_vertex_streams

4968 "GL_ATI_vertex_streams",

4969 #endif

4970 #ifdef GL_EGL_KHR_context_flush_control

4971 "GL_EGL_KHR_context_flush_control",

4972 #endif

4973 #ifdef GL_EGL_NV_robustness_video_memory_purge

4974 "GL_EGL_NV_robustness_video_memory_purge",

4975 #endif

4976 #ifdef GL_EXT_422_pixels

4977 "GL_EXT_422_pixels",

4978 #endif

4979 #ifdef GL_EXT_Cg_shader

4980 "GL_EXT_Cg_shader",

4981 #endif

4982 #ifdef GL_EXT_EGL_image_array

4983 "GL_EXT_EGL_image_array",

4984 #endif

4985 #ifdef GL_EXT_YUV_target

4986 "GL_EXT_YUV_target",

4987 #endif

4988 #ifdef GL_EXT_abgr

4989 "GL_EXT_abgr",

4990 #endif

4991 #ifdef GL_EXT_base_instance

4992 "GL_EXT_base_instance",

4993 #endif

4994 #ifdef GL_EXT_bgra

4995 "GL_EXT_bgra",

4996 #endif

4997 #ifdef GL_EXT_bindable_uniform

4998 "GL_EXT_bindable_uniform",

4999 #endif

5000 #ifdef GL_EXT_blend_color

5001 "GL_EXT_blend_color",

5002 #endif

5003 #ifdef GL_EXT_blend_equation_separate

5004 "GL_EXT_blend_equation_separate",

5005 #endif

5006 #ifdef GL_EXT_blend_func_extended

5007 "GL_EXT_blend_func_extended",

5008 #endif

5009 #ifdef GL_EXT_blend_func_separate

5010 "GL_EXT_blend_func_separate",

5011 #endif

5012 #ifdef GL_EXT_blend_logic_op

5013 "GL_EXT_blend_logic_op",

5014 #endif

5015 #ifdef GL_EXT_blend_minmax

5016 "GL_EXT_blend_minmax",

5017 #endif

5018 #ifdef GL_EXT_blend_subtract

5019 "GL_EXT_blend_subtract",

5020 #endif

5021 #ifdef GL_EXT_buffer_storage

5022 "GL_EXT_buffer_storage",

5023 #endif

5024 #ifdef GL_EXT_clear_texture

5025 "GL_EXT_clear_texture",

5026 #endif

5027 #ifdef GL_EXT_clip_cull_distance

5028 "GL_EXT_clip_cull_distance",

5029 #endif

5030 #ifdef GL_EXT_clip_volume_hint

5031 "GL_EXT_clip_volume_hint",

5032 #endif

5033 #ifdef GL_EXT_cmyka

5034 "GL_EXT_cmyka",

5035 #endif

5036 #ifdef GL_EXT_color_buffer_float

5037 "GL_EXT_color_buffer_float",

5038 #endif

5039 #ifdef GL_EXT_color_buffer_half_float

5040 "GL_EXT_color_buffer_half_float",

5041 #endif

5042 #ifdef GL_EXT_color_subtable

5043 "GL_EXT_color_subtable",

5044 #endif

5045 #ifdef GL_EXT_compiled_vertex_array

5046 "GL_EXT_compiled_vertex_array",

5047 #endif

5048 #ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture

5049 "GL_EXT_compressed_ETC1_RGB8_sub_texture",

5050 #endif

5051 #ifdef GL_EXT_conservative_depth

5052 "GL_EXT_conservative_depth",

5053 #endif

5054 #ifdef GL_EXT_convolution

5055 "GL_EXT_convolution",

5056 #endif

5057 #ifdef GL_EXT_coordinate_frame

5058 "GL_EXT_coordinate_frame",

5059 #endif

5060 #ifdef GL_EXT_copy_image

5061 "GL_EXT_copy_image",

5062 #endif

5063 #ifdef GL_EXT_copy_texture

5064 "GL_EXT_copy_texture",

5065 #endif

5066 #ifdef GL_EXT_cull_vertex

5067 "GL_EXT_cull_vertex",

5068 #endif

5069 #ifdef GL_EXT_debug_label

5070 "GL_EXT_debug_label",

5071 #endif

5072 #ifdef GL_EXT_debug_marker

5073 "GL_EXT_debug_marker",

5074 #endif

5075 #ifdef GL_EXT_depth_bounds_test

5076 "GL_EXT_depth_bounds_test",

5077 #endif

5078 #ifdef GL_EXT_direct_state_access

5079 "GL_EXT_direct_state_access",

5080 #endif

5081 #ifdef GL_EXT_discard_framebuffer

5082 "GL_EXT_discard_framebuffer",

5083 #endif

5084 #ifdef GL_EXT_draw_buffers

5085 "GL_EXT_draw_buffers",

5086 #endif

5087 #ifdef GL_EXT_draw_buffers2

5088 "GL_EXT_draw_buffers2",

5089 #endif

5090 #ifdef GL_EXT_draw_buffers_indexed

5091 "GL_EXT_draw_buffers_indexed",

5092 #endif

5093 #ifdef GL_EXT_draw_elements_base_vertex

5094 "GL_EXT_draw_elements_base_vertex",

5095 #endif

5096 #ifdef GL_EXT_draw_instanced

5097 "GL_EXT_draw_instanced",

5098 #endif

5099 #ifdef GL_EXT_draw_range_elements

5100 "GL_EXT_draw_range_elements",

5101 #endif

5102 #ifdef GL_EXT_external_buffer

5103 "GL_EXT_external_buffer",

5104 #endif

5105 #ifdef GL_EXT_float_blend

5106 "GL_EXT_float_blend",

5107 #endif

5108 #ifdef GL_EXT_fog_coord

5109 "GL_EXT_fog_coord",

5110 #endif

5111 #ifdef GL_EXT_frag_depth

5112 "GL_EXT_frag_depth",

5113 #endif

5114 #ifdef GL_EXT_fragment_lighting

5115 "GL_EXT_fragment_lighting",

5116 #endif

5117 #ifdef GL_EXT_framebuffer_blit

5118 "GL_EXT_framebuffer_blit",

5119 #endif

5120 #ifdef GL_EXT_framebuffer_multisample

5121 "GL_EXT_framebuffer_multisample",

5122 #endif

5123 #ifdef GL_EXT_framebuffer_multisample_blit_scaled

5124 "GL_EXT_framebuffer_multisample_blit_scaled",

5125 #endif

5126 #ifdef GL_EXT_framebuffer_object

5127 "GL_EXT_framebuffer_object",

5128 #endif

5129 #ifdef GL_EXT_framebuffer_sRGB

5130 "GL_EXT_framebuffer_sRGB",

5131 #endif

5132 #ifdef GL_EXT_geometry_point_size

5133 "GL_EXT_geometry_point_size",

5134 #endif

5135 #ifdef GL_EXT_geometry_shader

5136 "GL_EXT_geometry_shader",

5137 #endif

5138 #ifdef GL_EXT_geometry_shader4

5139 "GL_EXT_geometry_shader4",

5140 #endif

5141 #ifdef GL_EXT_gpu_program_parameters

5142 "GL_EXT_gpu_program_parameters",

5143 #endif

5144 #ifdef GL_EXT_gpu_shader4

5145 "GL_EXT_gpu_shader4",

5146 #endif

5147 #ifdef GL_EXT_gpu_shader5

5148 "GL_EXT_gpu_shader5",

5149 #endif

5150 #ifdef GL_EXT_histogram

5151 "GL_EXT_histogram",

5152 #endif

5153 #ifdef GL_EXT_index_array_formats

5154 "GL_EXT_index_array_formats",

5155 #endif

5156 #ifdef GL_EXT_index_func

5157 "GL_EXT_index_func",

5158 #endif

5159 #ifdef GL_EXT_index_material

5160 "GL_EXT_index_material",

5161 #endif

5162 #ifdef GL_EXT_index_texture

5163 "GL_EXT_index_texture",

5164 #endif

5165 #ifdef GL_EXT_instanced_arrays

5166 "GL_EXT_instanced_arrays",

5167 #endif

5168 #ifdef GL_EXT_light_texture

5169 "GL_EXT_light_texture",

5170 #endif

5171 #ifdef GL_EXT_map_buffer_range

5172 "GL_EXT_map_buffer_range",

5173 #endif

5174 #ifdef GL_EXT_memory_object

5175 "GL_EXT_memory_object",

5176 #endif

5177 #ifdef GL_EXT_memory_object_fd

5178 "GL_EXT_memory_object_fd",

5179 #endif

5180 #ifdef GL_EXT_memory_object_win32

5181 "GL_EXT_memory_object_win32",

5182 #endif

5183 #ifdef GL_EXT_misc_attribute

5184 "GL_EXT_misc_attribute",

5185 #endif

5186 #ifdef GL_EXT_multi_draw_arrays

5187 "GL_EXT_multi_draw_arrays",

5188 #endif

5189 #ifdef GL_EXT_multi_draw_indirect

5190 "GL_EXT_multi_draw_indirect",

5191 #endif

5192 #ifdef GL_EXT_multiple_textures

5193 "GL_EXT_multiple_textures",

5194 #endif

5195 #ifdef GL_EXT_multisample

5196 "GL_EXT_multisample",

5197 #endif

5198 #ifdef GL_EXT_multisample_compatibility

5199 "GL_EXT_multisample_compatibility",

5200 #endif

5201 #ifdef GL_EXT_multisampled_render_to_texture

5202 "GL_EXT_multisampled_render_to_texture",

5203 #endif

5204 #ifdef GL_EXT_multisampled_render_to_texture2

5205 "GL_EXT_multisampled_render_to_texture2",

5206 #endif

5207 #ifdef GL_EXT_multiview_draw_buffers

5208 "GL_EXT_multiview_draw_buffers",

5209 #endif

5210 #ifdef GL_EXT_packed_depth_stencil

5211 "GL_EXT_packed_depth_stencil",

5212 #endif

5213 #ifdef GL_EXT_packed_float

5214 "GL_EXT_packed_float",

5215 #endif

5216 #ifdef GL_EXT_packed_pixels

5217 "GL_EXT_packed_pixels",

5218 #endif

5219 #ifdef GL_EXT_paletted_texture

5220 "GL_EXT_paletted_texture",

5221 #endif

5222 #ifdef GL_EXT_pixel_buffer_object

5223 "GL_EXT_pixel_buffer_object",

5224 #endif

5225 #ifdef GL_EXT_pixel_transform

5226 "GL_EXT_pixel_transform",

5227 #endif

5228 #ifdef GL_EXT_pixel_transform_color_table

5229 "GL_EXT_pixel_transform_color_table",

5230 #endif

5231 #ifdef GL_EXT_point_parameters

5232 "GL_EXT_point_parameters",

5233 #endif

5234 #ifdef GL_EXT_polygon_offset

5235 "GL_EXT_polygon_offset",

5236 #endif

5237 #ifdef GL_EXT_polygon_offset_clamp

5238 "GL_EXT_polygon_offset_clamp",

5239 #endif

5240 #ifdef GL_EXT_post_depth_coverage

5241 "GL_EXT_post_depth_coverage",

5242 #endif

5243 #ifdef GL_EXT_provoking_vertex

5244 "GL_EXT_provoking_vertex",

5245 #endif

5246 #ifdef GL_EXT_pvrtc_sRGB

5247 "GL_EXT_pvrtc_sRGB",

5248 #endif

5249 #ifdef GL_EXT_raster_multisample

5250 "GL_EXT_raster_multisample",

5251 #endif

5252 #ifdef GL_EXT_read_format_bgra

5253 "GL_EXT_read_format_bgra",

5254 #endif

5255 #ifdef GL_EXT_render_snorm

5256 "GL_EXT_render_snorm",

5257 #endif

5258 #ifdef GL_EXT_rescale_normal

5259 "GL_EXT_rescale_normal",

5260 #endif

5261 #ifdef GL_EXT_sRGB

5262 "GL_EXT_sRGB",

5263 #endif

5264 #ifdef GL_EXT_sRGB_write_control

5265 "GL_EXT_sRGB_write_control",

5266 #endif

5267 #ifdef GL_EXT_scene_marker

5268 "GL_EXT_scene_marker",

5269 #endif

5270 #ifdef GL_EXT_secondary_color

5271 "GL_EXT_secondary_color",

5272 #endif

5273 #ifdef GL_EXT_semaphore

5274 "GL_EXT_semaphore",

5275 #endif

5276 #ifdef GL_EXT_semaphore_fd

5277 "GL_EXT_semaphore_fd",

5278 #endif

5279 #ifdef GL_EXT_semaphore_win32

5280 "GL_EXT_semaphore_win32",

5281 #endif

5282 #ifdef GL_EXT_separate_shader_objects

5283 "GL_EXT_separate_shader_objects",

5284 #endif

5285 #ifdef GL_EXT_separate_specular_color

5286 "GL_EXT_separate_specular_color",

5287 #endif

5288 #ifdef GL_EXT_shader_framebuffer_fetch

5289 "GL_EXT_shader_framebuffer_fetch",

5290 #endif

5291 #ifdef GL_EXT_shader_group_vote

5292 "GL_EXT_shader_group_vote",

5293 #endif

5294 #ifdef GL_EXT_shader_image_load_formatted

5295 "GL_EXT_shader_image_load_formatted",

5296 #endif

5297 #ifdef GL_EXT_shader_image_load_store

5298 "GL_EXT_shader_image_load_store",

5299 #endif

5300 #ifdef GL_EXT_shader_implicit_conversions

5301 "GL_EXT_shader_implicit_conversions",

5302 #endif

5303 #ifdef GL_EXT_shader_integer_mix

5304 "GL_EXT_shader_integer_mix",

5305 #endif

5306 #ifdef GL_EXT_shader_io_blocks

5307 "GL_EXT_shader_io_blocks",

5308 #endif

5309 #ifdef GL_EXT_shader_non_constant_global_initializers

5310 "GL_EXT_shader_non_constant_global_initializers",

5311 #endif

5312 #ifdef GL_EXT_shader_pixel_local_storage

5313 "GL_EXT_shader_pixel_local_storage",

5314 #endif

5315 #ifdef GL_EXT_shader_pixel_local_storage2

5316 "GL_EXT_shader_pixel_local_storage2",

5317 #endif

5318 #ifdef GL_EXT_shader_texture_lod

5319 "GL_EXT_shader_texture_lod",

5320 #endif

5321 #ifdef GL_EXT_shadow_funcs

5322 "GL_EXT_shadow_funcs",

5323 #endif

5324 #ifdef GL_EXT_shadow_samplers

5325 "GL_EXT_shadow_samplers",

5326 #endif

5327 #ifdef GL_EXT_shared_texture_palette

5328 "GL_EXT_shared_texture_palette",

5329 #endif

5330 #ifdef GL_EXT_sparse_texture

5331 "GL_EXT_sparse_texture",

5332 #endif

5333 #ifdef GL_EXT_sparse_texture2

5334 "GL_EXT_sparse_texture2",

5335 #endif

5336 #ifdef GL_EXT_stencil_clear_tag

5337 "GL_EXT_stencil_clear_tag",

5338 #endif

5339 #ifdef GL_EXT_stencil_two_side

5340 "GL_EXT_stencil_two_side",

5341 #endif

5342 #ifdef GL_EXT_stencil_wrap

5343 "GL_EXT_stencil_wrap",

5344 #endif

5345 #ifdef GL_EXT_subtexture

5346 "GL_EXT_subtexture",

5347 #endif

5348 #ifdef GL_EXT_texture

5349 "GL_EXT_texture",

5350 #endif

5351 #ifdef GL_EXT_texture3D

5352 "GL_EXT_texture3D",

5353 #endif

5354 #ifdef GL_EXT_texture_array

5355 "GL_EXT_texture_array",

5356 #endif

5357 #ifdef GL_EXT_texture_buffer_object

5358 "GL_EXT_texture_buffer_object",

5359 #endif

5360 #ifdef GL_EXT_texture_compression_astc_decode_mode

5361 "GL_EXT_texture_compression_astc_decode_mode",

5362 #endif

5363 #ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5

5364 "GL_EXT_texture_compression_astc_decode_mode_rgb9e5",

5365 #endif

5366 #ifdef GL_EXT_texture_compression_bptc

5367 "GL_EXT_texture_compression_bptc",

5368 #endif

5369 #ifdef GL_EXT_texture_compression_dxt1

5370 "GL_EXT_texture_compression_dxt1",

5371 #endif

5372 #ifdef GL_EXT_texture_compression_latc

5373 "GL_EXT_texture_compression_latc",

5374 #endif

5375 #ifdef GL_EXT_texture_compression_rgtc

5376 "GL_EXT_texture_compression_rgtc",

5377 #endif

5378 #ifdef GL_EXT_texture_compression_s3tc

5379 "GL_EXT_texture_compression_s3tc",

5380 #endif

5381 #ifdef GL_EXT_texture_cube_map

5382 "GL_EXT_texture_cube_map",

5383 #endif

5384 #ifdef GL_EXT_texture_cube_map_array

5385 "GL_EXT_texture_cube_map_array",

5386 #endif

5387 #ifdef GL_EXT_texture_edge_clamp

5388 "GL_EXT_texture_edge_clamp",

5389 #endif

5390 #ifdef GL_EXT_texture_env

5391 "GL_EXT_texture_env",

5392 #endif

5393 #ifdef GL_EXT_texture_env_add

5394 "GL_EXT_texture_env_add",

5395 #endif

5396 #ifdef GL_EXT_texture_env_combine

5397 "GL_EXT_texture_env_combine",

5398 #endif

5399 #ifdef GL_EXT_texture_env_dot3

5400 "GL_EXT_texture_env_dot3",

5401 #endif

5402 #ifdef GL_EXT_texture_filter_anisotropic

5403 "GL_EXT_texture_filter_anisotropic",

5404 #endif

5405 #ifdef GL_EXT_texture_filter_minmax

5406 "GL_EXT_texture_filter_minmax",

5407 #endif

5408 #ifdef GL_EXT_texture_format_BGRA8888

5409 "GL_EXT_texture_format_BGRA8888",

5410 #endif

5411 #ifdef GL_EXT_texture_integer

5412 "GL_EXT_texture_integer",

5413 #endif

5414 #ifdef GL_EXT_texture_lod_bias

5415 "GL_EXT_texture_lod_bias",

5416 #endif

5417 #ifdef GL_EXT_texture_mirror_clamp

5418 "GL_EXT_texture_mirror_clamp",

5419 #endif

5420 #ifdef GL_EXT_texture_norm16

5421 "GL_EXT_texture_norm16",

5422 #endif

5423 #ifdef GL_EXT_texture_object

5424 "GL_EXT_texture_object",

5425 #endif

5426 #ifdef GL_EXT_texture_perturb_normal

5427 "GL_EXT_texture_perturb_normal",

5428 #endif

5429 #ifdef GL_EXT_texture_rectangle

5430 "GL_EXT_texture_rectangle",

5431 #endif

5432 #ifdef GL_EXT_texture_rg

5433 "GL_EXT_texture_rg",

5434 #endif

5435 #ifdef GL_EXT_texture_sRGB

5436 "GL_EXT_texture_sRGB",

5437 #endif

5438 #ifdef GL_EXT_texture_sRGB_R8

5439 "GL_EXT_texture_sRGB_R8",

5440 #endif

5441 #ifdef GL_EXT_texture_sRGB_RG8

5442 "GL_EXT_texture_sRGB_RG8",

5443 #endif

5444 #ifdef GL_EXT_texture_sRGB_decode

5445 "GL_EXT_texture_sRGB_decode",

5446 #endif

5447 #ifdef GL_EXT_texture_shared_exponent

5448 "GL_EXT_texture_shared_exponent",

5449 #endif

5450 #ifdef GL_EXT_texture_snorm

5451 "GL_EXT_texture_snorm",

5452 #endif

5453 #ifdef GL_EXT_texture_storage

5454 "GL_EXT_texture_storage",

5455 #endif

5456 #ifdef GL_EXT_texture_swizzle

5457 "GL_EXT_texture_swizzle",

5458 #endif

5459 #ifdef GL_EXT_texture_type_2_10_10_10_REV

5460 "GL_EXT_texture_type_2_10_10_10_REV",

5461 #endif

5462 #ifdef GL_EXT_texture_view

5463 "GL_EXT_texture_view",

5464 #endif

5465 #ifdef GL_EXT_timer_query

5466 "GL_EXT_timer_query",

5467 #endif

5468 #ifdef GL_EXT_transform_feedback

5469 "GL_EXT_transform_feedback",

5470 #endif

5471 #ifdef GL_EXT_unpack_subimage

5472 "GL_EXT_unpack_subimage",

5473 #endif

5474 #ifdef GL_EXT_vertex_array

5475 "GL_EXT_vertex_array",

5476 #endif

5477 #ifdef GL_EXT_vertex_array_bgra

5478 "GL_EXT_vertex_array_bgra",

5479 #endif

5480 #ifdef GL_EXT_vertex_array_setXXX

5481 "GL_EXT_vertex_array_setXXX",

5482 #endif

5483 #ifdef GL_EXT_vertex_attrib_64bit

5484 "GL_EXT_vertex_attrib_64bit",

5485 #endif

5486 #ifdef GL_EXT_vertex_shader

5487 "GL_EXT_vertex_shader",

5488 #endif

5489 #ifdef GL_EXT_vertex_weighting

5490 "GL_EXT_vertex_weighting",

5491 #endif

5492 #ifdef GL_EXT_win32_keyed_mutex

5493 "GL_EXT_win32_keyed_mutex",

5494 #endif

5495 #ifdef GL_EXT_window_rectangles

5496 "GL_EXT_window_rectangles",

5497 #endif

5498 #ifdef GL_EXT_x11_sync_object

5499 "GL_EXT_x11_sync_object",

5500 #endif

5501 #ifdef GL_GREMEDY_frame_terminator

5502 "GL_GREMEDY_frame_terminator",

5503 #endif

5504 #ifdef GL_GREMEDY_string_marker

5505 "GL_GREMEDY_string_marker",

5506 #endif

5507 #ifdef GL_HP_convolution_border_modes

5508 "GL_HP_convolution_border_modes",

5509 #endif

5510 #ifdef GL_HP_image_transform

5511 "GL_HP_image_transform",

5512 #endif

5513 #ifdef GL_HP_occlusion_test

5514 "GL_HP_occlusion_test",

5515 #endif

5516 #ifdef GL_HP_texture_lighting

5517 "GL_HP_texture_lighting",

5518 #endif

5519 #ifdef GL_IBM_cull_vertex

5520 "GL_IBM_cull_vertex",

5521 #endif

5522 #ifdef GL_IBM_multimode_draw_arrays

5523 "GL_IBM_multimode_draw_arrays",

5524 #endif

5525 #ifdef GL_IBM_rasterpos_clip

5526 "GL_IBM_rasterpos_clip",

5527 #endif

5528 #ifdef GL_IBM_static_data

5529 "GL_IBM_static_data",

5530 #endif

5531 #ifdef GL_IBM_texture_mirrored_repeat

5532 "GL_IBM_texture_mirrored_repeat",

5533 #endif

5534 #ifdef GL_IBM_vertex_array_lists

5535 "GL_IBM_vertex_array_lists",

5536 #endif

5537 #ifdef GL_INGR_color_clamp

5538 "GL_INGR_color_clamp",

5539 #endif

5540 #ifdef GL_INGR_interlace_read

5541 "GL_INGR_interlace_read",

5542 #endif

5543 #ifdef GL_INTEL_conservative_rasterization

5544 "GL_INTEL_conservative_rasterization",

5545 #endif

5546 #ifdef GL_INTEL_fragment_shader_ordering

5547 "GL_INTEL_fragment_shader_ordering",

5548 #endif

5549 #ifdef GL_INTEL_framebuffer_CMAA

5550 "GL_INTEL_framebuffer_CMAA",

5551 #endif

5552 #ifdef GL_INTEL_map_texture

5553 "GL_INTEL_map_texture",

5554 #endif

5555 #ifdef GL_INTEL_parallel_arrays

5556 "GL_INTEL_parallel_arrays",

5557 #endif

5558 #ifdef GL_INTEL_performance_query

5559 "GL_INTEL_performance_query",

5560 #endif

5561 #ifdef GL_INTEL_texture_scissor

5562 "GL_INTEL_texture_scissor",

5563 #endif

5564 #ifdef GL_KHR_blend_equation_advanced

5565 "GL_KHR_blend_equation_advanced",

5566 #endif

5567 #ifdef GL_KHR_blend_equation_advanced_coherent

5568 "GL_KHR_blend_equation_advanced_coherent",

5569 #endif

5570 #ifdef GL_KHR_context_flush_control

5571 "GL_KHR_context_flush_control",

5572 #endif

5573 #ifdef GL_KHR_debug

5574 "GL_KHR_debug",

5575 #endif

5576 #ifdef GL_KHR_no_error

5577 "GL_KHR_no_error",

5578 #endif

5579 #ifdef GL_KHR_parallel_shader_compile

5580 "GL_KHR_parallel_shader_compile",

5581 #endif

5582 #ifdef GL_KHR_robust_buffer_access_behavior

5583 "GL_KHR_robust_buffer_access_behavior",

5584 #endif

5585 #ifdef GL_KHR_robustness

5586 "GL_KHR_robustness",

5587 #endif

5588 #ifdef GL_KHR_texture_compression_astc_hdr

5589 "GL_KHR_texture_compression_astc_hdr",

5590 #endif

5591 #ifdef GL_KHR_texture_compression_astc_ldr

5592 "GL_KHR_texture_compression_astc_ldr",

5593 #endif

5594 #ifdef GL_KHR_texture_compression_astc_sliced_3d

5595 "GL_KHR_texture_compression_astc_sliced_3d",

5596 #endif

5597 #ifdef GL_KTX_buffer_region

5598 "GL_KTX_buffer_region",

5599 #endif

5600 #ifdef GL_MESAX_texture_stack

5601 "GL_MESAX_texture_stack",

5602 #endif

5603 #ifdef GL_MESA_pack_invert

5604 "GL_MESA_pack_invert",

5605 #endif

5606 #ifdef GL_MESA_resize_buffers

5607 "GL_MESA_resize_buffers",

5608 #endif

5609 #ifdef GL_MESA_shader_integer_functions

5610 "GL_MESA_shader_integer_functions",

5611 #endif

5612 #ifdef GL_MESA_window_pos

5613 "GL_MESA_window_pos",

5614 #endif

5615 #ifdef GL_MESA_ycbcr_texture

5616 "GL_MESA_ycbcr_texture",

5617 #endif

5618 #ifdef GL_NVX_blend_equation_advanced_multi_draw_buffers

5619 "GL_NVX_blend_equation_advanced_multi_draw_buffers",

5620 #endif

5621 #ifdef GL_NVX_conditional_render

5622 "GL_NVX_conditional_render",

5623 #endif

5624 #ifdef GL_NVX_gpu_memory_info

5625 "GL_NVX_gpu_memory_info",

5626 #endif

5627 #ifdef GL_NVX_linked_gpu_multicast

5628 "GL_NVX_linked_gpu_multicast",

5629 #endif

5630 #ifdef GL_NV_3dvision_settings

5631 "GL_NV_3dvision_settings",

5632 #endif

5633 #ifdef GL_NV_EGL_stream_consumer_external

5634 "GL_NV_EGL_stream_consumer_external",

5635 #endif

5636 #ifdef GL_NV_alpha_to_coverage_dither_control

5637 "GL_NV_alpha_to_coverage_dither_control",

5638 #endif

5639 #ifdef GL_NV_bgr

5640 "GL_NV_bgr",

5641 #endif

5642 #ifdef GL_NV_bindless_multi_draw_indirect

5643 "GL_NV_bindless_multi_draw_indirect",

5644 #endif

5645 #ifdef GL_NV_bindless_multi_draw_indirect_count

5646 "GL_NV_bindless_multi_draw_indirect_count",

5647 #endif

5648 #ifdef GL_NV_bindless_texture

5649 "GL_NV_bindless_texture",

5650 #endif

5651 #ifdef GL_NV_blend_equation_advanced

5652 "GL_NV_blend_equation_advanced",

5653 #endif

5654 #ifdef GL_NV_blend_equation_advanced_coherent

5655 "GL_NV_blend_equation_advanced_coherent",

5656 #endif

5657 #ifdef GL_NV_blend_minmax_factor

5658 "GL_NV_blend_minmax_factor",

5659 #endif

5660 #ifdef GL_NV_blend_square

5661 "GL_NV_blend_square",

5662 #endif

5663 #ifdef GL_NV_clip_space_w_scaling

5664 "GL_NV_clip_space_w_scaling",

5665 #endif

5666 #ifdef GL_NV_command_list

5667 "GL_NV_command_list",

5668 #endif

5669 #ifdef GL_NV_compute_program5

5670 "GL_NV_compute_program5",

5671 #endif

5672 #ifdef GL_NV_conditional_render

5673 "GL_NV_conditional_render",

5674 #endif

5675 #ifdef GL_NV_conservative_raster

5676 "GL_NV_conservative_raster",

5677 #endif

5678 #ifdef GL_NV_conservative_raster_dilate

5679 "GL_NV_conservative_raster_dilate",

5680 #endif

5681 #ifdef GL_NV_conservative_raster_pre_snap_triangles

5682 "GL_NV_conservative_raster_pre_snap_triangles",

5683 #endif

5684 #ifdef GL_NV_copy_buffer

5685 "GL_NV_copy_buffer",

5686 #endif

5687 #ifdef GL_NV_copy_depth_to_color

5688 "GL_NV_copy_depth_to_color",

5689 #endif

5690 #ifdef GL_NV_copy_image

5691 "GL_NV_copy_image",

5692 #endif

5693 #ifdef GL_NV_deep_texture3D

5694 "GL_NV_deep_texture3D",

5695 #endif

5696 #ifdef GL_NV_depth_buffer_float

5697 "GL_NV_depth_buffer_float",

5698 #endif

5699 #ifdef GL_NV_depth_clamp

5700 "GL_NV_depth_clamp",

5701 #endif

5702 #ifdef GL_NV_depth_range_unclamped

5703 "GL_NV_depth_range_unclamped",

5704 #endif

5705 #ifdef GL_NV_draw_buffers

5706 "GL_NV_draw_buffers",

5707 #endif

5708 #ifdef GL_NV_draw_instanced

5709 "GL_NV_draw_instanced",

5710 #endif

5711 #ifdef GL_NV_draw_texture

5712 "GL_NV_draw_texture",

5713 #endif

5714 #ifdef GL_NV_draw_vulkan_image

5715 "GL_NV_draw_vulkan_image",

5716 #endif

5717 #ifdef GL_NV_evaluators

5718 "GL_NV_evaluators",

5719 #endif

5720 #ifdef GL_NV_explicit_attrib_location

5721 "GL_NV_explicit_attrib_location",

5722 #endif

5723 #ifdef GL_NV_explicit_multisample

5724 "GL_NV_explicit_multisample",

5725 #endif

5726 #ifdef GL_NV_fbo_color_attachments

5727 "GL_NV_fbo_color_attachments",

5728 #endif

5729 #ifdef GL_NV_fence

5730 "GL_NV_fence",

5731 #endif

5732 #ifdef GL_NV_fill_rectangle

5733 "GL_NV_fill_rectangle",

5734 #endif

5735 #ifdef GL_NV_float_buffer

5736 "GL_NV_float_buffer",

5737 #endif

5738 #ifdef GL_NV_fog_distance

5739 "GL_NV_fog_distance",

5740 #endif

5741 #ifdef GL_NV_fragment_coverage_to_color

5742 "GL_NV_fragment_coverage_to_color",

5743 #endif

5744 #ifdef GL_NV_fragment_program

5745 "GL_NV_fragment_program",

5746 #endif

5747 #ifdef GL_NV_fragment_program2

5748 "GL_NV_fragment_program2",

5749 #endif

5750 #ifdef GL_NV_fragment_program4

5751 "GL_NV_fragment_program4",

5752 #endif

5753 #ifdef GL_NV_fragment_program_option

5754 "GL_NV_fragment_program_option",

5755 #endif

5756 #ifdef GL_NV_fragment_shader_interlock

5757 "GL_NV_fragment_shader_interlock",

5758 #endif

5759 #ifdef GL_NV_framebuffer_blit

5760 "GL_NV_framebuffer_blit",

5761 #endif

5762 #ifdef GL_NV_framebuffer_mixed_samples

5763 "GL_NV_framebuffer_mixed_samples",

5764 #endif

5765 #ifdef GL_NV_framebuffer_multisample

5766 "GL_NV_framebuffer_multisample",

5767 #endif

5768 #ifdef GL_NV_framebuffer_multisample_coverage

5769 "GL_NV_framebuffer_multisample_coverage",

5770 #endif

5771 #ifdef GL_NV_generate_mipmap_sRGB

5772 "GL_NV_generate_mipmap_sRGB",

5773 #endif

5774 #ifdef GL_NV_geometry_program4

5775 "GL_NV_geometry_program4",

5776 #endif

5777 #ifdef GL_NV_geometry_shader4

5778 "GL_NV_geometry_shader4",

5779 #endif

5780 #ifdef GL_NV_geometry_shader_passthrough

5781 "GL_NV_geometry_shader_passthrough",

5782 #endif

5783 #ifdef GL_NV_gpu_multicast

5784 "GL_NV_gpu_multicast",

5785 #endif

5786 #ifdef GL_NV_gpu_program4

5787 "GL_NV_gpu_program4",

5788 #endif

5789 #ifdef GL_NV_gpu_program5

5790 "GL_NV_gpu_program5",

5791 #endif

5792 #ifdef GL_NV_gpu_program5_mem_extended

5793 "GL_NV_gpu_program5_mem_extended",

5794 #endif

5795 #ifdef GL_NV_gpu_program_fp64

5796 "GL_NV_gpu_program_fp64",

5797 #endif

5798 #ifdef GL_NV_gpu_shader5

5799 "GL_NV_gpu_shader5",

5800 #endif

5801 #ifdef GL_NV_half_float

5802 "GL_NV_half_float",

5803 #endif

5804 #ifdef GL_NV_image_formats

5805 "GL_NV_image_formats",

5806 #endif

5807 #ifdef GL_NV_instanced_arrays

5808 "GL_NV_instanced_arrays",

5809 #endif

5810 #ifdef GL_NV_internalformat_sample_query

5811 "GL_NV_internalformat_sample_query",

5812 #endif

5813 #ifdef GL_NV_light_max_exponent

5814 "GL_NV_light_max_exponent",

5815 #endif

5816 #ifdef GL_NV_multisample_coverage

5817 "GL_NV_multisample_coverage",

5818 #endif

5819 #ifdef GL_NV_multisample_filter_hint

5820 "GL_NV_multisample_filter_hint",

5821 #endif

5822 #ifdef GL_NV_non_square_matrices

5823 "GL_NV_non_square_matrices",

5824 #endif

5825 #ifdef GL_NV_occlusion_query

5826 "GL_NV_occlusion_query",

5827 #endif

5828 #ifdef GL_NV_pack_subimage

5829 "GL_NV_pack_subimage",

5830 #endif

5831 #ifdef GL_NV_packed_depth_stencil

5832 "GL_NV_packed_depth_stencil",

5833 #endif

5834 #ifdef GL_NV_packed_float

5835 "GL_NV_packed_float",

5836 #endif

5837 #ifdef GL_NV_packed_float_linear

5838 "GL_NV_packed_float_linear",

5839 #endif

5840 #ifdef GL_NV_parameter_buffer_object

5841 "GL_NV_parameter_buffer_object",

5842 #endif

5843 #ifdef GL_NV_parameter_buffer_object2

5844 "GL_NV_parameter_buffer_object2",

5845 #endif

5846 #ifdef GL_NV_path_rendering

5847 "GL_NV_path_rendering",

5848 #endif

5849 #ifdef GL_NV_path_rendering_shared_edge

5850 "GL_NV_path_rendering_shared_edge",

5851 #endif

5852 #ifdef GL_NV_pixel_buffer_object

5853 "GL_NV_pixel_buffer_object",

5854 #endif

5855 #ifdef GL_NV_pixel_data_range

5856 "GL_NV_pixel_data_range",

5857 #endif

5858 #ifdef GL_NV_platform_binary

5859 "GL_NV_platform_binary",

5860 #endif

5861 #ifdef GL_NV_point_sprite

5862 "GL_NV_point_sprite",

5863 #endif

5864 #ifdef GL_NV_polygon_mode

5865 "GL_NV_polygon_mode",

5866 #endif

5867 #ifdef GL_NV_present_video

5868 "GL_NV_present_video",

5869 #endif

5870 #ifdef GL_NV_primitive_restart

5871 "GL_NV_primitive_restart",

5872 #endif

5873 #ifdef GL_NV_read_depth

5874 "GL_NV_read_depth",

5875 #endif

5876 #ifdef GL_NV_read_depth_stencil

5877 "GL_NV_read_depth_stencil",

5878 #endif

5879 #ifdef GL_NV_read_stencil

5880 "GL_NV_read_stencil",

5881 #endif

5882 #ifdef GL_NV_register_combiners

5883 "GL_NV_register_combiners",

5884 #endif

5885 #ifdef GL_NV_register_combiners2

5886 "GL_NV_register_combiners2",

5887 #endif

5888 #ifdef GL_NV_robustness_video_memory_purge

5889 "GL_NV_robustness_video_memory_purge",

5890 #endif

5891 #ifdef GL_NV_sRGB_formats

5892 "GL_NV_sRGB_formats",

5893 #endif

5894 #ifdef GL_NV_sample_locations

5895 "GL_NV_sample_locations",

5896 #endif

5897 #ifdef GL_NV_sample_mask_override_coverage

5898 "GL_NV_sample_mask_override_coverage",

5899 #endif

5900 #ifdef GL_NV_shader_atomic_counters

5901 "GL_NV_shader_atomic_counters",

5902 #endif

5903 #ifdef GL_NV_shader_atomic_float

5904 "GL_NV_shader_atomic_float",

5905 #endif

5906 #ifdef GL_NV_shader_atomic_float64

5907 "GL_NV_shader_atomic_float64",

5908 #endif

5909 #ifdef GL_NV_shader_atomic_fp16_vector

5910 "GL_NV_shader_atomic_fp16_vector",

5911 #endif

5912 #ifdef GL_NV_shader_atomic_int64

5913 "GL_NV_shader_atomic_int64",

5914 #endif

5915 #ifdef GL_NV_shader_buffer_load

5916 "GL_NV_shader_buffer_load",

5917 #endif

5918 #ifdef GL_NV_shader_noperspective_interpolation

5919 "GL_NV_shader_noperspective_interpolation",

5920 #endif

5921 #ifdef GL_NV_shader_storage_buffer_object

5922 "GL_NV_shader_storage_buffer_object",

5923 #endif

5924 #ifdef GL_NV_shader_thread_group

5925 "GL_NV_shader_thread_group",

5926 #endif

5927 #ifdef GL_NV_shader_thread_shuffle

5928 "GL_NV_shader_thread_shuffle",

5929 #endif

5930 #ifdef GL_NV_shadow_samplers_array

5931 "GL_NV_shadow_samplers_array",

5932 #endif

5933 #ifdef GL_NV_shadow_samplers_cube

5934 "GL_NV_shadow_samplers_cube",

5935 #endif

5936 #ifdef GL_NV_stereo_view_rendering

5937 "GL_NV_stereo_view_rendering",

5938 #endif

5939 #ifdef GL_NV_tessellation_program5

5940 "GL_NV_tessellation_program5",

5941 #endif

5942 #ifdef GL_NV_texgen_emboss

5943 "GL_NV_texgen_emboss",

5944 #endif

5945 #ifdef GL_NV_texgen_reflection

5946 "GL_NV_texgen_reflection",

5947 #endif

5948 #ifdef GL_NV_texture_array

5949 "GL_NV_texture_array",

5950 #endif

5951 #ifdef GL_NV_texture_barrier

5952 "GL_NV_texture_barrier",

5953 #endif

5954 #ifdef GL_NV_texture_border_clamp

5955 "GL_NV_texture_border_clamp",

5956 #endif

5957 #ifdef GL_NV_texture_compression_latc

5958 "GL_NV_texture_compression_latc",

5959 #endif

5960 #ifdef GL_NV_texture_compression_s3tc

5961 "GL_NV_texture_compression_s3tc",

5962 #endif

5963 #ifdef GL_NV_texture_compression_s3tc_update

5964 "GL_NV_texture_compression_s3tc_update",

5965 #endif

5966 #ifdef GL_NV_texture_compression_vtc

5967 "GL_NV_texture_compression_vtc",

5968 #endif

5969 #ifdef GL_NV_texture_env_combine4

5970 "GL_NV_texture_env_combine4",

5971 #endif

5972 #ifdef GL_NV_texture_expand_normal

5973 "GL_NV_texture_expand_normal",

5974 #endif

5975 #ifdef GL_NV_texture_multisample

5976 "GL_NV_texture_multisample",

5977 #endif

5978 #ifdef GL_NV_texture_npot_2D_mipmap

5979 "GL_NV_texture_npot_2D_mipmap",

5980 #endif

5981 #ifdef GL_NV_texture_rectangle

5982 "GL_NV_texture_rectangle",

5983 #endif

5984 #ifdef GL_NV_texture_rectangle_compressed

5985 "GL_NV_texture_rectangle_compressed",

5986 #endif

5987 #ifdef GL_NV_texture_shader

5988 "GL_NV_texture_shader",

5989 #endif

5990 #ifdef GL_NV_texture_shader2

5991 "GL_NV_texture_shader2",

5992 #endif

5993 #ifdef GL_NV_texture_shader3

5994 "GL_NV_texture_shader3",

5995 #endif

5996 #ifdef GL_NV_transform_feedback

5997 "GL_NV_transform_feedback",

5998 #endif

5999 #ifdef GL_NV_transform_feedback2

6000 "GL_NV_transform_feedback2",

6001 #endif

6002 #ifdef GL_NV_uniform_buffer_unified_memory

6003 "GL_NV_uniform_buffer_unified_memory",

6004 #endif

6005 #ifdef GL_NV_vdpau_interop

6006 "GL_NV_vdpau_interop",

6007 #endif

6008 #ifdef GL_NV_vertex_array_range

6009 "GL_NV_vertex_array_range",

6010 #endif

6011 #ifdef GL_NV_vertex_array_range2

6012 "GL_NV_vertex_array_range2",

6013 #endif

6014 #ifdef GL_NV_vertex_attrib_integer_64bit

6015 "GL_NV_vertex_attrib_integer_64bit",

6016 #endif

6017 #ifdef GL_NV_vertex_buffer_unified_memory

6018 "GL_NV_vertex_buffer_unified_memory",

6019 #endif

6020 #ifdef GL_NV_vertex_program

6021 "GL_NV_vertex_program",

6022 #endif

6023 #ifdef GL_NV_vertex_program1_1

6024 "GL_NV_vertex_program1_1",

6025 #endif

6026 #ifdef GL_NV_vertex_program2

6027 "GL_NV_vertex_program2",

6028 #endif

6029 #ifdef GL_NV_vertex_program2_option

6030 "GL_NV_vertex_program2_option",

6031 #endif

6032 #ifdef GL_NV_vertex_program3

6033 "GL_NV_vertex_program3",

6034 #endif

6035 #ifdef GL_NV_vertex_program4

6036 "GL_NV_vertex_program4",

6037 #endif

6038 #ifdef GL_NV_video_capture

6039 "GL_NV_video_capture",

6040 #endif

6041 #ifdef GL_NV_viewport_array

6042 "GL_NV_viewport_array",

6043 #endif

6044 #ifdef GL_NV_viewport_array2

6045 "GL_NV_viewport_array2",

6046 #endif

6047 #ifdef GL_NV_viewport_swizzle

6048 "GL_NV_viewport_swizzle",

6049 #endif

6050 #ifdef GL_OES_byte_coordinates

6051 "GL_OES_byte_coordinates",

6052 #endif

6053 #ifdef GL_OML_interlace

6054 "GL_OML_interlace",

6055 #endif

6056 #ifdef GL_OML_resample

6057 "GL_OML_resample",

6058 #endif

6059 #ifdef GL_OML_subsample

6060 "GL_OML_subsample",

6061 #endif

6062 #ifdef GL_OVR_multiview

6063 "GL_OVR_multiview",

6064 #endif

6065 #ifdef GL_OVR_multiview2

6066 "GL_OVR_multiview2",

6067 #endif

6068 #ifdef GL_OVR_multiview_multisampled_render_to_texture

6069 "GL_OVR_multiview_multisampled_render_to_texture",

6070 #endif

6071 #ifdef GL_PGI_misc_hints

6072 "GL_PGI_misc_hints",

6073 #endif

6074 #ifdef GL_PGI_vertex_hints

6075 "GL_PGI_vertex_hints",

6076 #endif

6077 #ifdef GL_QCOM_alpha_test

6078 "GL_QCOM_alpha_test",

6079 #endif

6080 #ifdef GL_QCOM_binning_control

6081 "GL_QCOM_binning_control",

6082 #endif

6083 #ifdef GL_QCOM_driver_control

6084 "GL_QCOM_driver_control",

6085 #endif

6086 #ifdef GL_QCOM_extended_get

6087 "GL_QCOM_extended_get",

6088 #endif

6089 #ifdef GL_QCOM_extended_get2

6090 "GL_QCOM_extended_get2",

6091 #endif

6092 #ifdef GL_QCOM_framebuffer_foveated

6093 "GL_QCOM_framebuffer_foveated",

6094 #endif

6095 #ifdef GL_QCOM_perfmon_global_mode

6096 "GL_QCOM_perfmon_global_mode",

6097 #endif

6098 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent

6099 "GL_QCOM_shader_framebuffer_fetch_noncoherent",

6100 #endif

6101 #ifdef GL_QCOM_tiled_rendering

6102 "GL_QCOM_tiled_rendering",

6103 #endif

6104 #ifdef GL_QCOM_writeonly_rendering

6105 "GL_QCOM_writeonly_rendering",

6106 #endif

6107 #ifdef GL_REGAL_ES1_0_compatibility

6108 "GL_REGAL_ES1_0_compatibility",

6109 #endif

6110 #ifdef GL_REGAL_ES1_1_compatibility

6111 "GL_REGAL_ES1_1_compatibility",

6112 #endif

6113 #ifdef GL_REGAL_enable

6114 "GL_REGAL_enable",

6115 #endif

6116 #ifdef GL_REGAL_error_string

6117 "GL_REGAL_error_string",

6118 #endif

6119 #ifdef GL_REGAL_extension_query

6120 "GL_REGAL_extension_query",

6121 #endif

6122 #ifdef GL_REGAL_log

6123 "GL_REGAL_log",

6124 #endif

6125 #ifdef GL_REGAL_proc_address

6126 "GL_REGAL_proc_address",

6127 #endif

6128 #ifdef GL_REND_screen_coordinates

6129 "GL_REND_screen_coordinates",

6130 #endif

6131 #ifdef GL_S3_s3tc

6132 "GL_S3_s3tc",

6133 #endif

6134 #ifdef GL_SGIS_clip_band_hint

6135 "GL_SGIS_clip_band_hint",

6136 #endif

6137 #ifdef GL_SGIS_color_range

6138 "GL_SGIS_color_range",

6139 #endif

6140 #ifdef GL_SGIS_detail_texture

6141 "GL_SGIS_detail_texture",

6142 #endif

6143 #ifdef GL_SGIS_fog_function

6144 "GL_SGIS_fog_function",

6145 #endif

6146 #ifdef GL_SGIS_generate_mipmap

6147 "GL_SGIS_generate_mipmap",

6148 #endif

6149 #ifdef GL_SGIS_line_texgen

6150 "GL_SGIS_line_texgen",

6151 #endif

6152 #ifdef GL_SGIS_multisample

6153 "GL_SGIS_multisample",

6154 #endif

6155 #ifdef GL_SGIS_multitexture

6156 "GL_SGIS_multitexture",

6157 #endif

6158 #ifdef GL_SGIS_pixel_texture

6159 "GL_SGIS_pixel_texture",

6160 #endif

6161 #ifdef GL_SGIS_point_line_texgen

6162 "GL_SGIS_point_line_texgen",

6163 #endif

6164 #ifdef GL_SGIS_shared_multisample

6165 "GL_SGIS_shared_multisample",

6166 #endif

6167 #ifdef GL_SGIS_sharpen_texture

6168 "GL_SGIS_sharpen_texture",

6169 #endif

6170 #ifdef GL_SGIS_texture4D

6171 "GL_SGIS_texture4D",

6172 #endif

6173 #ifdef GL_SGIS_texture_border_clamp

6174 "GL_SGIS_texture_border_clamp",

6175 #endif

6176 #ifdef GL_SGIS_texture_edge_clamp

6177 "GL_SGIS_texture_edge_clamp",

6178 #endif

6179 #ifdef GL_SGIS_texture_filter4

6180 "GL_SGIS_texture_filter4",

6181 #endif

6182 #ifdef GL_SGIS_texture_lod

6183 "GL_SGIS_texture_lod",

6184 #endif

6185 #ifdef GL_SGIS_texture_select

6186 "GL_SGIS_texture_select",

6187 #endif

6188 #ifdef GL_SGIX_async

6189 "GL_SGIX_async",

6190 #endif

6191 #ifdef GL_SGIX_async_histogram

6192 "GL_SGIX_async_histogram",

6193 #endif

6194 #ifdef GL_SGIX_async_pixel

6195 "GL_SGIX_async_pixel",

6196 #endif

6197 #ifdef GL_SGIX_bali_g_instruments

6198 "GL_SGIX_bali_g_instruments",

6199 #endif

6200 #ifdef GL_SGIX_bali_r_instruments

6201 "GL_SGIX_bali_r_instruments",

6202 #endif

6203 #ifdef GL_SGIX_bali_timer_instruments

6204 "GL_SGIX_bali_timer_instruments",

6205 #endif

6206 #ifdef GL_SGIX_blend_alpha_minmax

6207 "GL_SGIX_blend_alpha_minmax",

6208 #endif

6209 #ifdef GL_SGIX_blend_cadd

6210 "GL_SGIX_blend_cadd",

6211 #endif

6212 #ifdef GL_SGIX_blend_cmultiply

6213 "GL_SGIX_blend_cmultiply",

6214 #endif

6215 #ifdef GL_SGIX_calligraphic_fragment

6216 "GL_SGIX_calligraphic_fragment",

6217 #endif

6218 #ifdef GL_SGIX_clipmap

6219 "GL_SGIX_clipmap",

6220 #endif

6221 #ifdef GL_SGIX_color_matrix_accuracy

6222 "GL_SGIX_color_matrix_accuracy",

6223 #endif

6224 #ifdef GL_SGIX_color_table_index_mode

6225 "GL_SGIX_color_table_index_mode",

6226 #endif

6227 #ifdef GL_SGIX_complex_polar

6228 "GL_SGIX_complex_polar",

6229 #endif

6230 #ifdef GL_SGIX_convolution_accuracy

6231 "GL_SGIX_convolution_accuracy",

6232 #endif

6233 #ifdef GL_SGIX_cube_map

6234 "GL_SGIX_cube_map",

6235 #endif

6236 #ifdef GL_SGIX_cylinder_texgen

6237 "GL_SGIX_cylinder_texgen",

6238 #endif

6239 #ifdef GL_SGIX_datapipe

6240 "GL_SGIX_datapipe",

6241 #endif

6242 #ifdef GL_SGIX_decimation

6243 "GL_SGIX_decimation",

6244 #endif

6245 #ifdef GL_SGIX_depth_pass_instrument

6246 "GL_SGIX_depth_pass_instrument",

6247 #endif

6248 #ifdef GL_SGIX_depth_texture

6249 "GL_SGIX_depth_texture",

6250 #endif

6251 #ifdef GL_SGIX_dvc

6252 "GL_SGIX_dvc",

6253 #endif

6254 #ifdef GL_SGIX_flush_raster

6255 "GL_SGIX_flush_raster",

6256 #endif

6257 #ifdef GL_SGIX_fog_blend

6258 "GL_SGIX_fog_blend",

6259 #endif

6260 #ifdef GL_SGIX_fog_factor_to_alpha

6261 "GL_SGIX_fog_factor_to_alpha",

6262 #endif

6263 #ifdef GL_SGIX_fog_layers

6264 "GL_SGIX_fog_layers",

6265 #endif

6266 #ifdef GL_SGIX_fog_offset

6267 "GL_SGIX_fog_offset",

6268 #endif

6269 #ifdef GL_SGIX_fog_patchy

6270 "GL_SGIX_fog_patchy",

6271 #endif

6272 #ifdef GL_SGIX_fog_scale

6273 "GL_SGIX_fog_scale",

6274 #endif

6275 #ifdef GL_SGIX_fog_texture

6276 "GL_SGIX_fog_texture",

6277 #endif

6278 #ifdef GL_SGIX_fragment_lighting_space

6279 "GL_SGIX_fragment_lighting_space",

6280 #endif

6281 #ifdef GL_SGIX_fragment_specular_lighting

6282 "GL_SGIX_fragment_specular_lighting",

6283 #endif

6284 #ifdef GL_SGIX_fragments_instrument

6285 "GL_SGIX_fragments_instrument",

6286 #endif

6287 #ifdef GL_SGIX_framezoom

6288 "GL_SGIX_framezoom",

6289 #endif

6290 #ifdef GL_SGIX_icc_texture

6291 "GL_SGIX_icc_texture",

6292 #endif

6293 #ifdef GL_SGIX_igloo_interface

6294 "GL_SGIX_igloo_interface",

6295 #endif

6296 #ifdef GL_SGIX_image_compression

6297 "GL_SGIX_image_compression",

6298 #endif

6299 #ifdef GL_SGIX_impact_pixel_texture

6300 "GL_SGIX_impact_pixel_texture",

6301 #endif

6302 #ifdef GL_SGIX_instrument_error

6303 "GL_SGIX_instrument_error",

6304 #endif

6305 #ifdef GL_SGIX_interlace

6306 "GL_SGIX_interlace",

6307 #endif

6308 #ifdef GL_SGIX_ir_instrument1

6309 "GL_SGIX_ir_instrument1",

6310 #endif

6311 #ifdef GL_SGIX_line_quality_hint

6312 "GL_SGIX_line_quality_hint",

6313 #endif

6314 #ifdef GL_SGIX_list_priority

6315 "GL_SGIX_list_priority",

6316 #endif

6317 #ifdef GL_SGIX_mpeg1

6318 "GL_SGIX_mpeg1",

6319 #endif

6320 #ifdef GL_SGIX_mpeg2

6321 "GL_SGIX_mpeg2",

6322 #endif

6323 #ifdef GL_SGIX_nonlinear_lighting_pervertex

6324 "GL_SGIX_nonlinear_lighting_pervertex",

6325 #endif

6326 #ifdef GL_SGIX_nurbs_eval

6327 "GL_SGIX_nurbs_eval",

6328 #endif

6329 #ifdef GL_SGIX_occlusion_instrument

6330 "GL_SGIX_occlusion_instrument",

6331 #endif

6332 #ifdef GL_SGIX_packed_6bytes

6333 "GL_SGIX_packed_6bytes",

6334 #endif

6335 #ifdef GL_SGIX_pixel_texture

6336 "GL_SGIX_pixel_texture",

6337 #endif

6338 #ifdef GL_SGIX_pixel_texture_bits

6339 "GL_SGIX_pixel_texture_bits",

6340 #endif

6341 #ifdef GL_SGIX_pixel_texture_lod

6342 "GL_SGIX_pixel_texture_lod",

6343 #endif

6344 #ifdef GL_SGIX_pixel_tiles

6345 "GL_SGIX_pixel_tiles",

6346 #endif

6347 #ifdef GL_SGIX_polynomial_ffd

6348 "GL_SGIX_polynomial_ffd",

6349 #endif

6350 #ifdef GL_SGIX_quad_mesh

6351 "GL_SGIX_quad_mesh",

6352 #endif

6353 #ifdef GL_SGIX_reference_plane

6354 "GL_SGIX_reference_plane",

6355 #endif

6356 #ifdef GL_SGIX_resample

6357 "GL_SGIX_resample",

6358 #endif

6359 #ifdef GL_SGIX_scalebias_hint

6360 "GL_SGIX_scalebias_hint",

6361 #endif

6362 #ifdef GL_SGIX_shadow

6363 "GL_SGIX_shadow",

6364 #endif

6365 #ifdef GL_SGIX_shadow_ambient

6366 "GL_SGIX_shadow_ambient",

6367 #endif

6368 #ifdef GL_SGIX_slim

6369 "GL_SGIX_slim",

6370 #endif

6371 #ifdef GL_SGIX_spotlight_cutoff

6372 "GL_SGIX_spotlight_cutoff",

6373 #endif

6374 #ifdef GL_SGIX_sprite

6375 "GL_SGIX_sprite",

6376 #endif

6377 #ifdef GL_SGIX_subdiv_patch

6378 "GL_SGIX_subdiv_patch",

6379 #endif

6380 #ifdef GL_SGIX_subsample

6381 "GL_SGIX_subsample",

6382 #endif

6383 #ifdef GL_SGIX_tag_sample_buffer

6384 "GL_SGIX_tag_sample_buffer",

6385 #endif

6386 #ifdef GL_SGIX_texture_add_env

6387 "GL_SGIX_texture_add_env",

6388 #endif

6389 #ifdef GL_SGIX_texture_coordinate_clamp

6390 "GL_SGIX_texture_coordinate_clamp",

6391 #endif

6392 #ifdef GL_SGIX_texture_lod_bias

6393 "GL_SGIX_texture_lod_bias",

6394 #endif

6395 #ifdef GL_SGIX_texture_mipmap_anisotropic

6396 "GL_SGIX_texture_mipmap_anisotropic",

6397 #endif

6398 #ifdef GL_SGIX_texture_multi_buffer

6399 "GL_SGIX_texture_multi_buffer",

6400 #endif

6401 #ifdef GL_SGIX_texture_phase

6402 "GL_SGIX_texture_phase",

6403 #endif

6404 #ifdef GL_SGIX_texture_range

6405 "GL_SGIX_texture_range",

6406 #endif

6407 #ifdef GL_SGIX_texture_scale_bias

6408 "GL_SGIX_texture_scale_bias",

6409 #endif

6410 #ifdef GL_SGIX_texture_supersample

6411 "GL_SGIX_texture_supersample",

6412 #endif

6413 #ifdef GL_SGIX_vector_ops

6414 "GL_SGIX_vector_ops",

6415 #endif

6416 #ifdef GL_SGIX_vertex_array_object

6417 "GL_SGIX_vertex_array_object",

6418 #endif

6419 #ifdef GL_SGIX_vertex_preclip

6420 "GL_SGIX_vertex_preclip",

6421 #endif

6422 #ifdef GL_SGIX_vertex_preclip_hint

6423 "GL_SGIX_vertex_preclip_hint",

6424 #endif

6425 #ifdef GL_SGIX_ycrcb

6426 "GL_SGIX_ycrcb",

6427 #endif

6428 #ifdef GL_SGIX_ycrcb_subsample

6429 "GL_SGIX_ycrcb_subsample",

6430 #endif

6431 #ifdef GL_SGIX_ycrcba

6432 "GL_SGIX_ycrcba",

6433 #endif

6434 #ifdef GL_SGI_color_matrix

6435 "GL_SGI_color_matrix",

6436 #endif

6437 #ifdef GL_SGI_color_table

6438 "GL_SGI_color_table",

6439 #endif

6440 #ifdef GL_SGI_complex

6441 "GL_SGI_complex",

6442 #endif

6443 #ifdef GL_SGI_complex_type

6444 "GL_SGI_complex_type",

6445 #endif

6446 #ifdef GL_SGI_fft

6447 "GL_SGI_fft",

6448 #endif

6449 #ifdef GL_SGI_texture_color_table

6450 "GL_SGI_texture_color_table",

6451 #endif

6452 #ifdef GL_SUNX_constant_data

6453 "GL_SUNX_constant_data",

6454 #endif

6455 #ifdef GL_SUN_convolution_border_modes

6456 "GL_SUN_convolution_border_modes",

6457 #endif

6458 #ifdef GL_SUN_global_alpha

6459 "GL_SUN_global_alpha",

6460 #endif

6461 #ifdef GL_SUN_mesh_array

6462 "GL_SUN_mesh_array",

6463 #endif

6464 #ifdef GL_SUN_read_video_pixels

6465 "GL_SUN_read_video_pixels",

6466 #endif

6467 #ifdef GL_SUN_slice_accum

6468 "GL_SUN_slice_accum",

6469 #endif

6470 #ifdef GL_SUN_triangle_list

6471 "GL_SUN_triangle_list",

6472 #endif

6473 #ifdef GL_SUN_vertex

6474 "GL_SUN_vertex",

6475 #endif

6476 #ifdef GL_WIN_phong_shading

6477 "GL_WIN_phong_shading",

6478 #endif

6479 #ifdef GL_WIN_scene_markerXXX

6480 "GL_WIN_scene_markerXXX",

6481 #endif

6482 #ifdef GL_WIN_specular_fog

6483 "GL_WIN_specular_fog",

6484 #endif

6485 #ifdef GL_WIN_swap_hint

6486 "GL_WIN_swap_hint",

6487 #endif

6488 NULL

6489 };

6490

6491 /* Detected in the extension string or strings */

6492 static GLboolean _glewExtensionString[801];

6493 /* Detected via extension string or experimental mode */

6494 static GLboolean* _glewExtensionEnabled[] = {

6495 #ifdef GL_VERSION_1_2

6496 &__GLEW_VERSION_1_2,

6497 #endif

6498 #ifdef GL_VERSION_1_2_1

6499 &__GLEW_VERSION_1_2_1,

6500 #endif

6501 #ifdef GL_VERSION_1_3

6502 &__GLEW_VERSION_1_3,

6503 #endif

6504 #ifdef GL_VERSION_1_4

6505 &__GLEW_VERSION_1_4,

6506 #endif

6507 #ifdef GL_VERSION_1_5

6508 &__GLEW_VERSION_1_5,

6509 #endif

6510 #ifdef GL_VERSION_2_0

6511 &__GLEW_VERSION_2_0,

6512 #endif

6513 #ifdef GL_VERSION_2_1

6514 &__GLEW_VERSION_2_1,

6515 #endif

6516 #ifdef GL_VERSION_3_0

6517 &__GLEW_VERSION_3_0,

6518 #endif

6519 #ifdef GL_VERSION_3_1

6520 &__GLEW_VERSION_3_1,

6521 #endif

6522 #ifdef GL_VERSION_3_2

6523 &__GLEW_VERSION_3_2,

6524 #endif

6525 #ifdef GL_VERSION_3_3

6526 &__GLEW_VERSION_3_3,

6527 #endif

6528 #ifdef GL_VERSION_4_0

6529 &__GLEW_VERSION_4_0,

6530 #endif

6531 #ifdef GL_VERSION_4_1

6532 &__GLEW_VERSION_4_1,

6533 #endif

6534 #ifdef GL_VERSION_4_2

6535 &__GLEW_VERSION_4_2,

6536 #endif

6537 #ifdef GL_VERSION_4_3

6538 &__GLEW_VERSION_4_3,

6539 #endif

6540 #ifdef GL_VERSION_4_4

6541 &__GLEW_VERSION_4_4,

6542 #endif

6543 #ifdef GL_VERSION_4_5

6544 &__GLEW_VERSION_4_5,

6545 #endif

6546 #ifdef GL_VERSION_4_6

6547 &__GLEW_VERSION_4_6,

6548 #endif

6549 #ifdef GL_3DFX_multisample

6550 &__GLEW_3DFX_multisample,

6551 #endif

6552 #ifdef GL_3DFX_tbuffer

6553 &__GLEW_3DFX_tbuffer,

6554 #endif

6555 #ifdef GL_3DFX_texture_compression_FXT1

6556 &__GLEW_3DFX_texture_compression_FXT1,

6557 #endif

6558 #ifdef GL_AMD_blend_minmax_factor

6559 &__GLEW_AMD_blend_minmax_factor,

6560 #endif

6561 #ifdef GL_AMD_compressed_3DC_texture

6562 &__GLEW_AMD_compressed_3DC_texture,

6563 #endif

6564 #ifdef GL_AMD_compressed_ATC_texture

6565 &__GLEW_AMD_compressed_ATC_texture,

6566 #endif

6567 #ifdef GL_AMD_conservative_depth

6568 &__GLEW_AMD_conservative_depth,

6569 #endif

6570 #ifdef GL_AMD_debug_output

6571 &__GLEW_AMD_debug_output,

6572 #endif

6573 #ifdef GL_AMD_depth_clamp_separate

6574 &__GLEW_AMD_depth_clamp_separate,

6575 #endif

6576 #ifdef GL_AMD_draw_buffers_blend

6577 &__GLEW_AMD_draw_buffers_blend,

6578 #endif

6579 #ifdef GL_AMD_framebuffer_sample_positions

6580 &__GLEW_AMD_framebuffer_sample_positions,

6581 #endif

6582 #ifdef GL_AMD_gcn_shader

6583 &__GLEW_AMD_gcn_shader,

6584 #endif

6585 #ifdef GL_AMD_gpu_shader_half_float

6586 &__GLEW_AMD_gpu_shader_half_float,

6587 #endif

6588 #ifdef GL_AMD_gpu_shader_int16

6589 &__GLEW_AMD_gpu_shader_int16,

6590 #endif

6591 #ifdef GL_AMD_gpu_shader_int64

6592 &__GLEW_AMD_gpu_shader_int64,

6593 #endif

6594 #ifdef GL_AMD_interleaved_elements

6595 &__GLEW_AMD_interleaved_elements,

6596 #endif

6597 #ifdef GL_AMD_multi_draw_indirect

6598 &__GLEW_AMD_multi_draw_indirect,

6599 #endif

6600 #ifdef GL_AMD_name_gen_delete

6601 &__GLEW_AMD_name_gen_delete,

6602 #endif

6603 #ifdef GL_AMD_occlusion_query_event

6604 &__GLEW_AMD_occlusion_query_event,

6605 #endif

6606 #ifdef GL_AMD_performance_monitor

6607 &__GLEW_AMD_performance_monitor,

6608 #endif

6609 #ifdef GL_AMD_pinned_memory

6610 &__GLEW_AMD_pinned_memory,

6611 #endif

6612 #ifdef GL_AMD_program_binary_Z400

6613 &__GLEW_AMD_program_binary_Z400,

6614 #endif

6615 #ifdef GL_AMD_query_buffer_object

6616 &__GLEW_AMD_query_buffer_object,

6617 #endif

6618 #ifdef GL_AMD_sample_positions

6619 &__GLEW_AMD_sample_positions,

6620 #endif

6621 #ifdef GL_AMD_seamless_cubemap_per_texture

6622 &__GLEW_AMD_seamless_cubemap_per_texture,

6623 #endif

6624 #ifdef GL_AMD_shader_atomic_counter_ops

6625 &__GLEW_AMD_shader_atomic_counter_ops,

6626 #endif

6627 #ifdef GL_AMD_shader_ballot

6628 &__GLEW_AMD_shader_ballot,

6629 #endif

6630 #ifdef GL_AMD_shader_explicit_vertex_parameter

6631 &__GLEW_AMD_shader_explicit_vertex_parameter,

6632 #endif

6633 #ifdef GL_AMD_shader_stencil_export

6634 &__GLEW_AMD_shader_stencil_export,

6635 #endif

6636 #ifdef GL_AMD_shader_stencil_value_export

6637 &__GLEW_AMD_shader_stencil_value_export,

6638 #endif

6639 #ifdef GL_AMD_shader_trinary_minmax

6640 &__GLEW_AMD_shader_trinary_minmax,

6641 #endif

6642 #ifdef GL_AMD_sparse_texture

6643 &__GLEW_AMD_sparse_texture,

6644 #endif

6645 #ifdef GL_AMD_stencil_operation_extended

6646 &__GLEW_AMD_stencil_operation_extended,

6647 #endif

6648 #ifdef GL_AMD_texture_gather_bias_lod

6649 &__GLEW_AMD_texture_gather_bias_lod,

6650 #endif

6651 #ifdef GL_AMD_texture_texture4

6652 &__GLEW_AMD_texture_texture4,

6653 #endif

6654 #ifdef GL_AMD_transform_feedback3_lines_triangles

6655 &__GLEW_AMD_transform_feedback3_lines_triangles,

6656 #endif

6657 #ifdef GL_AMD_transform_feedback4

6658 &__GLEW_AMD_transform_feedback4,

6659 #endif

6660 #ifdef GL_AMD_vertex_shader_layer

6661 &__GLEW_AMD_vertex_shader_layer,

6662 #endif

6663 #ifdef GL_AMD_vertex_shader_tessellator

6664 &__GLEW_AMD_vertex_shader_tessellator,

6665 #endif

6666 #ifdef GL_AMD_vertex_shader_viewport_index

6667 &__GLEW_AMD_vertex_shader_viewport_index,

6668 #endif

6669 #ifdef GL_ANDROID_extension_pack_es31a

6670 &__GLEW_ANDROID_extension_pack_es31a,

6671 #endif

6672 #ifdef GL_ANGLE_depth_texture

6673 &__GLEW_ANGLE_depth_texture,

6674 #endif

6675 #ifdef GL_ANGLE_framebuffer_blit

6676 &__GLEW_ANGLE_framebuffer_blit,

6677 #endif

6678 #ifdef GL_ANGLE_framebuffer_multisample

6679 &__GLEW_ANGLE_framebuffer_multisample,

6680 #endif

6681 #ifdef GL_ANGLE_instanced_arrays

6682 &__GLEW_ANGLE_instanced_arrays,

6683 #endif

6684 #ifdef GL_ANGLE_pack_reverse_row_order

6685 &__GLEW_ANGLE_pack_reverse_row_order,

6686 #endif

6687 #ifdef GL_ANGLE_program_binary

6688 &__GLEW_ANGLE_program_binary,

6689 #endif

6690 #ifdef GL_ANGLE_texture_compression_dxt1

6691 &__GLEW_ANGLE_texture_compression_dxt1,

6692 #endif

6693 #ifdef GL_ANGLE_texture_compression_dxt3

6694 &__GLEW_ANGLE_texture_compression_dxt3,

6695 #endif

6696 #ifdef GL_ANGLE_texture_compression_dxt5

6697 &__GLEW_ANGLE_texture_compression_dxt5,

6698 #endif

6699 #ifdef GL_ANGLE_texture_usage

6700 &__GLEW_ANGLE_texture_usage,

6701 #endif

6702 #ifdef GL_ANGLE_timer_query

6703 &__GLEW_ANGLE_timer_query,

6704 #endif

6705 #ifdef GL_ANGLE_translated_shader_source

6706 &__GLEW_ANGLE_translated_shader_source,

6707 #endif

6708 #ifdef GL_APPLE_aux_depth_stencil

6709 &__GLEW_APPLE_aux_depth_stencil,

6710 #endif

6711 #ifdef GL_APPLE_client_storage

6712 &__GLEW_APPLE_client_storage,

6713 #endif

6714 #ifdef GL_APPLE_clip_distance

6715 &__GLEW_APPLE_clip_distance,

6716 #endif

6717 #ifdef GL_APPLE_color_buffer_packed_float

6718 &__GLEW_APPLE_color_buffer_packed_float,

6719 #endif

6720 #ifdef GL_APPLE_copy_texture_levels

6721 &__GLEW_APPLE_copy_texture_levels,

6722 #endif

6723 #ifdef GL_APPLE_element_array

6724 &__GLEW_APPLE_element_array,

6725 #endif

6726 #ifdef GL_APPLE_fence

6727 &__GLEW_APPLE_fence,

6728 #endif

6729 #ifdef GL_APPLE_float_pixels

6730 &__GLEW_APPLE_float_pixels,

6731 #endif

6732 #ifdef GL_APPLE_flush_buffer_range

6733 &__GLEW_APPLE_flush_buffer_range,

6734 #endif

6735 #ifdef GL_APPLE_framebuffer_multisample

6736 &__GLEW_APPLE_framebuffer_multisample,

6737 #endif

6738 #ifdef GL_APPLE_object_purgeable

6739 &__GLEW_APPLE_object_purgeable,

6740 #endif

6741 #ifdef GL_APPLE_pixel_buffer

6742 &__GLEW_APPLE_pixel_buffer,

6743 #endif

6744 #ifdef GL_APPLE_rgb_422

6745 &__GLEW_APPLE_rgb_422,

6746 #endif

6747 #ifdef GL_APPLE_row_bytes

6748 &__GLEW_APPLE_row_bytes,

6749 #endif

6750 #ifdef GL_APPLE_specular_vector

6751 &__GLEW_APPLE_specular_vector,

6752 #endif

6753 #ifdef GL_APPLE_sync

6754 &__GLEW_APPLE_sync,

6755 #endif

6756 #ifdef GL_APPLE_texture_2D_limited_npot

6757 &__GLEW_APPLE_texture_2D_limited_npot,

6758 #endif

6759 #ifdef GL_APPLE_texture_format_BGRA8888

6760 &__GLEW_APPLE_texture_format_BGRA8888,

6761 #endif

6762 #ifdef GL_APPLE_texture_max_level

6763 &__GLEW_APPLE_texture_max_level,

6764 #endif

6765 #ifdef GL_APPLE_texture_packed_float

6766 &__GLEW_APPLE_texture_packed_float,

6767 #endif

6768 #ifdef GL_APPLE_texture_range

6769 &__GLEW_APPLE_texture_range,

6770 #endif

6771 #ifdef GL_APPLE_transform_hint

6772 &__GLEW_APPLE_transform_hint,

6773 #endif

6774 #ifdef GL_APPLE_vertex_array_object

6775 &__GLEW_APPLE_vertex_array_object,

6776 #endif

6777 #ifdef GL_APPLE_vertex_array_range

6778 &__GLEW_APPLE_vertex_array_range,

6779 #endif

6780 #ifdef GL_APPLE_vertex_program_evaluators

6781 &__GLEW_APPLE_vertex_program_evaluators,

6782 #endif

6783 #ifdef GL_APPLE_ycbcr_422

6784 &__GLEW_APPLE_ycbcr_422,

6785 #endif

6786 #ifdef GL_ARB_ES2_compatibility

6787 &__GLEW_ARB_ES2_compatibility,

6788 #endif

6789 #ifdef GL_ARB_ES3_1_compatibility

6790 &__GLEW_ARB_ES3_1_compatibility,

6791 #endif

6792 #ifdef GL_ARB_ES3_2_compatibility

6793 &__GLEW_ARB_ES3_2_compatibility,

6794 #endif

6795 #ifdef GL_ARB_ES3_compatibility

6796 &__GLEW_ARB_ES3_compatibility,

6797 #endif

6798 #ifdef GL_ARB_arrays_of_arrays

6799 &__GLEW_ARB_arrays_of_arrays,

6800 #endif

6801 #ifdef GL_ARB_base_instance

6802 &__GLEW_ARB_base_instance,

6803 #endif

6804 #ifdef GL_ARB_bindless_texture

6805 &__GLEW_ARB_bindless_texture,

6806 #endif

6807 #ifdef GL_ARB_blend_func_extended

6808 &__GLEW_ARB_blend_func_extended,

6809 #endif

6810 #ifdef GL_ARB_buffer_storage

6811 &__GLEW_ARB_buffer_storage,

6812 #endif

6813 #ifdef GL_ARB_cl_event

6814 &__GLEW_ARB_cl_event,

6815 #endif

6816 #ifdef GL_ARB_clear_buffer_object

6817 &__GLEW_ARB_clear_buffer_object,

6818 #endif

6819 #ifdef GL_ARB_clear_texture

6820 &__GLEW_ARB_clear_texture,

6821 #endif

6822 #ifdef GL_ARB_clip_control

6823 &__GLEW_ARB_clip_control,

6824 #endif

6825 #ifdef GL_ARB_color_buffer_float

6826 &__GLEW_ARB_color_buffer_float,

6827 #endif

6828 #ifdef GL_ARB_compatibility

6829 &__GLEW_ARB_compatibility,

6830 #endif

6831 #ifdef GL_ARB_compressed_texture_pixel_storage

6832 &__GLEW_ARB_compressed_texture_pixel_storage,

6833 #endif

6834 #ifdef GL_ARB_compute_shader

6835 &__GLEW_ARB_compute_shader,

6836 #endif

6837 #ifdef GL_ARB_compute_variable_group_size

6838 &__GLEW_ARB_compute_variable_group_size,

6839 #endif

6840 #ifdef GL_ARB_conditional_render_inverted

6841 &__GLEW_ARB_conditional_render_inverted,

6842 #endif

6843 #ifdef GL_ARB_conservative_depth

6844 &__GLEW_ARB_conservative_depth,

6845 #endif

6846 #ifdef GL_ARB_copy_buffer

6847 &__GLEW_ARB_copy_buffer,

6848 #endif

6849 #ifdef GL_ARB_copy_image

6850 &__GLEW_ARB_copy_image,

6851 #endif

6852 #ifdef GL_ARB_cull_distance

6853 &__GLEW_ARB_cull_distance,

6854 #endif

6855 #ifdef GL_ARB_debug_output

6856 &__GLEW_ARB_debug_output,

6857 #endif

6858 #ifdef GL_ARB_depth_buffer_float

6859 &__GLEW_ARB_depth_buffer_float,

6860 #endif

6861 #ifdef GL_ARB_depth_clamp

6862 &__GLEW_ARB_depth_clamp,

6863 #endif

6864 #ifdef GL_ARB_depth_texture

6865 &__GLEW_ARB_depth_texture,

6866 #endif

6867 #ifdef GL_ARB_derivative_control

6868 &__GLEW_ARB_derivative_control,

6869 #endif

6870 #ifdef GL_ARB_direct_state_access

6871 &__GLEW_ARB_direct_state_access,

6872 #endif

6873 #ifdef GL_ARB_draw_buffers

6874 &__GLEW_ARB_draw_buffers,

6875 #endif

6876 #ifdef GL_ARB_draw_buffers_blend

6877 &__GLEW_ARB_draw_buffers_blend,

6878 #endif

6879 #ifdef GL_ARB_draw_elements_base_vertex

6880 &__GLEW_ARB_draw_elements_base_vertex,

6881 #endif

6882 #ifdef GL_ARB_draw_indirect

6883 &__GLEW_ARB_draw_indirect,

6884 #endif

6885 #ifdef GL_ARB_draw_instanced

6886 &__GLEW_ARB_draw_instanced,

6887 #endif

6888 #ifdef GL_ARB_enhanced_layouts

6889 &__GLEW_ARB_enhanced_layouts,

6890 #endif

6891 #ifdef GL_ARB_explicit_attrib_location

6892 &__GLEW_ARB_explicit_attrib_location,

6893 #endif

6894 #ifdef GL_ARB_explicit_uniform_location

6895 &__GLEW_ARB_explicit_uniform_location,

6896 #endif

6897 #ifdef GL_ARB_fragment_coord_conventions

6898 &__GLEW_ARB_fragment_coord_conventions,

6899 #endif

6900 #ifdef GL_ARB_fragment_layer_viewport

6901 &__GLEW_ARB_fragment_layer_viewport,

6902 #endif

6903 #ifdef GL_ARB_fragment_program

6904 &__GLEW_ARB_fragment_program,

6905 #endif

6906 #ifdef GL_ARB_fragment_program_shadow

6907 &__GLEW_ARB_fragment_program_shadow,

6908 #endif

6909 #ifdef GL_ARB_fragment_shader

6910 &__GLEW_ARB_fragment_shader,

6911 #endif

6912 #ifdef GL_ARB_fragment_shader_interlock

6913 &__GLEW_ARB_fragment_shader_interlock,

6914 #endif

6915 #ifdef GL_ARB_framebuffer_no_attachments

6916 &__GLEW_ARB_framebuffer_no_attachments,

6917 #endif

6918 #ifdef GL_ARB_framebuffer_object

6919 &__GLEW_ARB_framebuffer_object,

6920 #endif

6921 #ifdef GL_ARB_framebuffer_sRGB

6922 &__GLEW_ARB_framebuffer_sRGB,

6923 #endif

6924 #ifdef GL_ARB_geometry_shader4

6925 &__GLEW_ARB_geometry_shader4,

6926 #endif

6927 #ifdef GL_ARB_get_program_binary

6928 &__GLEW_ARB_get_program_binary,

6929 #endif

6930 #ifdef GL_ARB_get_texture_sub_image

6931 &__GLEW_ARB_get_texture_sub_image,

6932 #endif

6933 #ifdef GL_ARB_gl_spirv

6934 &__GLEW_ARB_gl_spirv,

6935 #endif

6936 #ifdef GL_ARB_gpu_shader5

6937 &__GLEW_ARB_gpu_shader5,

6938 #endif

6939 #ifdef GL_ARB_gpu_shader_fp64

6940 &__GLEW_ARB_gpu_shader_fp64,

6941 #endif

6942 #ifdef GL_ARB_gpu_shader_int64

6943 &__GLEW_ARB_gpu_shader_int64,

6944 #endif

6945 #ifdef GL_ARB_half_float_pixel

6946 &__GLEW_ARB_half_float_pixel,

6947 #endif

6948 #ifdef GL_ARB_half_float_vertex

6949 &__GLEW_ARB_half_float_vertex,

6950 #endif

6951 #ifdef GL_ARB_imaging

6952 &__GLEW_ARB_imaging,

6953 #endif

6954 #ifdef GL_ARB_indirect_parameters

6955 &__GLEW_ARB_indirect_parameters,

6956 #endif

6957 #ifdef GL_ARB_instanced_arrays

6958 &__GLEW_ARB_instanced_arrays,

6959 #endif

6960 #ifdef GL_ARB_internalformat_query

6961 &__GLEW_ARB_internalformat_query,

6962 #endif

6963 #ifdef GL_ARB_internalformat_query2

6964 &__GLEW_ARB_internalformat_query2,

6965 #endif

6966 #ifdef GL_ARB_invalidate_subdata

6967 &__GLEW_ARB_invalidate_subdata,

6968 #endif

6969 #ifdef GL_ARB_map_buffer_alignment

6970 &__GLEW_ARB_map_buffer_alignment,

6971 #endif

6972 #ifdef GL_ARB_map_buffer_range

6973 &__GLEW_ARB_map_buffer_range,

6974 #endif

6975 #ifdef GL_ARB_matrix_palette

6976 &__GLEW_ARB_matrix_palette,

6977 #endif

6978 #ifdef GL_ARB_multi_bind

6979 &__GLEW_ARB_multi_bind,

6980 #endif

6981 #ifdef GL_ARB_multi_draw_indirect

6982 &__GLEW_ARB_multi_draw_indirect,

6983 #endif

6984 #ifdef GL_ARB_multisample

6985 &__GLEW_ARB_multisample,

6986 #endif

6987 #ifdef GL_ARB_multitexture

6988 &__GLEW_ARB_multitexture,

6989 #endif

6990 #ifdef GL_ARB_occlusion_query

6991 &__GLEW_ARB_occlusion_query,

6992 #endif

6993 #ifdef GL_ARB_occlusion_query2

6994 &__GLEW_ARB_occlusion_query2,

6995 #endif

6996 #ifdef GL_ARB_parallel_shader_compile

6997 &__GLEW_ARB_parallel_shader_compile,

6998 #endif

6999 #ifdef GL_ARB_pipeline_statistics_query

7000 &__GLEW_ARB_pipeline_statistics_query,

7001 #endif

7002 #ifdef GL_ARB_pixel_buffer_object

7003 &__GLEW_ARB_pixel_buffer_object,

7004 #endif

7005 #ifdef GL_ARB_point_parameters

7006 &__GLEW_ARB_point_parameters,

7007 #endif

7008 #ifdef GL_ARB_point_sprite

7009 &__GLEW_ARB_point_sprite,

7010 #endif

7011 #ifdef GL_ARB_polygon_offset_clamp

7012 &__GLEW_ARB_polygon_offset_clamp,

7013 #endif

7014 #ifdef GL_ARB_post_depth_coverage

7015 &__GLEW_ARB_post_depth_coverage,

7016 #endif

7017 #ifdef GL_ARB_program_interface_query

7018 &__GLEW_ARB_program_interface_query,

7019 #endif

7020 #ifdef GL_ARB_provoking_vertex

7021 &__GLEW_ARB_provoking_vertex,

7022 #endif

7023 #ifdef GL_ARB_query_buffer_object

7024 &__GLEW_ARB_query_buffer_object,

7025 #endif

7026 #ifdef GL_ARB_robust_buffer_access_behavior

7027 &__GLEW_ARB_robust_buffer_access_behavior,

7028 #endif

7029 #ifdef GL_ARB_robustness

7030 &__GLEW_ARB_robustness,

7031 #endif

7032 #ifdef GL_ARB_robustness_application_isolation

7033 &__GLEW_ARB_robustness_application_isolation,

7034 #endif

7035 #ifdef GL_ARB_robustness_share_group_isolation

7036 &__GLEW_ARB_robustness_share_group_isolation,

7037 #endif

7038 #ifdef GL_ARB_sample_locations

7039 &__GLEW_ARB_sample_locations,

7040 #endif

7041 #ifdef GL_ARB_sample_shading

7042 &__GLEW_ARB_sample_shading,

7043 #endif

7044 #ifdef GL_ARB_sampler_objects

7045 &__GLEW_ARB_sampler_objects,

7046 #endif

7047 #ifdef GL_ARB_seamless_cube_map

7048 &__GLEW_ARB_seamless_cube_map,

7049 #endif

7050 #ifdef GL_ARB_seamless_cubemap_per_texture

7051 &__GLEW_ARB_seamless_cubemap_per_texture,

7052 #endif

7053 #ifdef GL_ARB_separate_shader_objects

7054 &__GLEW_ARB_separate_shader_objects,

7055 #endif

7056 #ifdef GL_ARB_shader_atomic_counter_ops

7057 &__GLEW_ARB_shader_atomic_counter_ops,

7058 #endif

7059 #ifdef GL_ARB_shader_atomic_counters

7060 &__GLEW_ARB_shader_atomic_counters,

7061 #endif

7062 #ifdef GL_ARB_shader_ballot

7063 &__GLEW_ARB_shader_ballot,

7064 #endif

7065 #ifdef GL_ARB_shader_bit_encoding

7066 &__GLEW_ARB_shader_bit_encoding,

7067 #endif

7068 #ifdef GL_ARB_shader_clock

7069 &__GLEW_ARB_shader_clock,

7070 #endif

7071 #ifdef GL_ARB_shader_draw_parameters

7072 &__GLEW_ARB_shader_draw_parameters,

7073 #endif

7074 #ifdef GL_ARB_shader_group_vote

7075 &__GLEW_ARB_shader_group_vote,

7076 #endif

7077 #ifdef GL_ARB_shader_image_load_store

7078 &__GLEW_ARB_shader_image_load_store,

7079 #endif

7080 #ifdef GL_ARB_shader_image_size

7081 &__GLEW_ARB_shader_image_size,

7082 #endif

7083 #ifdef GL_ARB_shader_objects

7084 &__GLEW_ARB_shader_objects,

7085 #endif

7086 #ifdef GL_ARB_shader_precision

7087 &__GLEW_ARB_shader_precision,

7088 #endif

7089 #ifdef GL_ARB_shader_stencil_export

7090 &__GLEW_ARB_shader_stencil_export,

7091 #endif

7092 #ifdef GL_ARB_shader_storage_buffer_object

7093 &__GLEW_ARB_shader_storage_buffer_object,

7094 #endif

7095 #ifdef GL_ARB_shader_subroutine

7096 &__GLEW_ARB_shader_subroutine,

7097 #endif

7098 #ifdef GL_ARB_shader_texture_image_samples

7099 &__GLEW_ARB_shader_texture_image_samples,

7100 #endif

7101 #ifdef GL_ARB_shader_texture_lod

7102 &__GLEW_ARB_shader_texture_lod,

7103 #endif

7104 #ifdef GL_ARB_shader_viewport_layer_array

7105 &__GLEW_ARB_shader_viewport_layer_array,

7106 #endif

7107 #ifdef GL_ARB_shading_language_100

7108 &__GLEW_ARB_shading_language_100,

7109 #endif

7110 #ifdef GL_ARB_shading_language_420pack

7111 &__GLEW_ARB_shading_language_420pack,

7112 #endif

7113 #ifdef GL_ARB_shading_language_include

7114 &__GLEW_ARB_shading_language_include,

7115 #endif

7116 #ifdef GL_ARB_shading_language_packing

7117 &__GLEW_ARB_shading_language_packing,

7118 #endif

7119 #ifdef GL_ARB_shadow

7120 &__GLEW_ARB_shadow,

7121 #endif

7122 #ifdef GL_ARB_shadow_ambient

7123 &__GLEW_ARB_shadow_ambient,

7124 #endif

7125 #ifdef GL_ARB_sparse_buffer

7126 &__GLEW_ARB_sparse_buffer,

7127 #endif

7128 #ifdef GL_ARB_sparse_texture

7129 &__GLEW_ARB_sparse_texture,

7130 #endif

7131 #ifdef GL_ARB_sparse_texture2

7132 &__GLEW_ARB_sparse_texture2,

7133 #endif

7134 #ifdef GL_ARB_sparse_texture_clamp

7135 &__GLEW_ARB_sparse_texture_clamp,

7136 #endif

7137 #ifdef GL_ARB_spirv_extensions

7138 &__GLEW_ARB_spirv_extensions,

7139 #endif

7140 #ifdef GL_ARB_stencil_texturing

7141 &__GLEW_ARB_stencil_texturing,

7142 #endif

7143 #ifdef GL_ARB_sync

7144 &__GLEW_ARB_sync,

7145 #endif

7146 #ifdef GL_ARB_tessellation_shader

7147 &__GLEW_ARB_tessellation_shader,

7148 #endif

7149 #ifdef GL_ARB_texture_barrier

7150 &__GLEW_ARB_texture_barrier,

7151 #endif

7152 #ifdef GL_ARB_texture_border_clamp

7153 &__GLEW_ARB_texture_border_clamp,

7154 #endif

7155 #ifdef GL_ARB_texture_buffer_object

7156 &__GLEW_ARB_texture_buffer_object,

7157 #endif

7158 #ifdef GL_ARB_texture_buffer_object_rgb32

7159 &__GLEW_ARB_texture_buffer_object_rgb32,

7160 #endif

7161 #ifdef GL_ARB_texture_buffer_range

7162 &__GLEW_ARB_texture_buffer_range,

7163 #endif

7164 #ifdef GL_ARB_texture_compression

7165 &__GLEW_ARB_texture_compression,

7166 #endif

7167 #ifdef GL_ARB_texture_compression_bptc

7168 &__GLEW_ARB_texture_compression_bptc,

7169 #endif

7170 #ifdef GL_ARB_texture_compression_rgtc

7171 &__GLEW_ARB_texture_compression_rgtc,

7172 #endif

7173 #ifdef GL_ARB_texture_cube_map

7174 &__GLEW_ARB_texture_cube_map,

7175 #endif

7176 #ifdef GL_ARB_texture_cube_map_array

7177 &__GLEW_ARB_texture_cube_map_array,

7178 #endif

7179 #ifdef GL_ARB_texture_env_add

7180 &__GLEW_ARB_texture_env_add,

7181 #endif

7182 #ifdef GL_ARB_texture_env_combine

7183 &__GLEW_ARB_texture_env_combine,

7184 #endif

7185 #ifdef GL_ARB_texture_env_crossbar

7186 &__GLEW_ARB_texture_env_crossbar,

7187 #endif

7188 #ifdef GL_ARB_texture_env_dot3

7189 &__GLEW_ARB_texture_env_dot3,

7190 #endif

7191 #ifdef GL_ARB_texture_filter_anisotropic

7192 &__GLEW_ARB_texture_filter_anisotropic,

7193 #endif

7194 #ifdef GL_ARB_texture_filter_minmax

7195 &__GLEW_ARB_texture_filter_minmax,

7196 #endif

7197 #ifdef GL_ARB_texture_float

7198 &__GLEW_ARB_texture_float,

7199 #endif

7200 #ifdef GL_ARB_texture_gather

7201 &__GLEW_ARB_texture_gather,

7202 #endif

7203 #ifdef GL_ARB_texture_mirror_clamp_to_edge

7204 &__GLEW_ARB_texture_mirror_clamp_to_edge,

7205 #endif

7206 #ifdef GL_ARB_texture_mirrored_repeat

7207 &__GLEW_ARB_texture_mirrored_repeat,

7208 #endif

7209 #ifdef GL_ARB_texture_multisample

7210 &__GLEW_ARB_texture_multisample,

7211 #endif

7212 #ifdef GL_ARB_texture_non_power_of_two

7213 &__GLEW_ARB_texture_non_power_of_two,

7214 #endif

7215 #ifdef GL_ARB_texture_query_levels

7216 &__GLEW_ARB_texture_query_levels,

7217 #endif

7218 #ifdef GL_ARB_texture_query_lod

7219 &__GLEW_ARB_texture_query_lod,

7220 #endif

7221 #ifdef GL_ARB_texture_rectangle

7222 &__GLEW_ARB_texture_rectangle,

7223 #endif

7224 #ifdef GL_ARB_texture_rg

7225 &__GLEW_ARB_texture_rg,

7226 #endif

7227 #ifdef GL_ARB_texture_rgb10_a2ui

7228 &__GLEW_ARB_texture_rgb10_a2ui,

7229 #endif

7230 #ifdef GL_ARB_texture_stencil8

7231 &__GLEW_ARB_texture_stencil8,

7232 #endif

7233 #ifdef GL_ARB_texture_storage

7234 &__GLEW_ARB_texture_storage,

7235 #endif

7236 #ifdef GL_ARB_texture_storage_multisample

7237 &__GLEW_ARB_texture_storage_multisample,

7238 #endif

7239 #ifdef GL_ARB_texture_swizzle

7240 &__GLEW_ARB_texture_swizzle,

7241 #endif

7242 #ifdef GL_ARB_texture_view

7243 &__GLEW_ARB_texture_view,

7244 #endif

7245 #ifdef GL_ARB_timer_query

7246 &__GLEW_ARB_timer_query,

7247 #endif

7248 #ifdef GL_ARB_transform_feedback2

7249 &__GLEW_ARB_transform_feedback2,

7250 #endif

7251 #ifdef GL_ARB_transform_feedback3

7252 &__GLEW_ARB_transform_feedback3,

7253 #endif

7254 #ifdef GL_ARB_transform_feedback_instanced

7255 &__GLEW_ARB_transform_feedback_instanced,

7256 #endif

7257 #ifdef GL_ARB_transform_feedback_overflow_query

7258 &__GLEW_ARB_transform_feedback_overflow_query,

7259 #endif

7260 #ifdef GL_ARB_transpose_matrix

7261 &__GLEW_ARB_transpose_matrix,

7262 #endif

7263 #ifdef GL_ARB_uniform_buffer_object

7264 &__GLEW_ARB_uniform_buffer_object,

7265 #endif

7266 #ifdef GL_ARB_vertex_array_bgra

7267 &__GLEW_ARB_vertex_array_bgra,

7268 #endif

7269 #ifdef GL_ARB_vertex_array_object

7270 &__GLEW_ARB_vertex_array_object,

7271 #endif

7272 #ifdef GL_ARB_vertex_attrib_64bit

7273 &__GLEW_ARB_vertex_attrib_64bit,

7274 #endif

7275 #ifdef GL_ARB_vertex_attrib_binding

7276 &__GLEW_ARB_vertex_attrib_binding,

7277 #endif

7278 #ifdef GL_ARB_vertex_blend

7279 &__GLEW_ARB_vertex_blend,

7280 #endif

7281 #ifdef GL_ARB_vertex_buffer_object

7282 &__GLEW_ARB_vertex_buffer_object,

7283 #endif

7284 #ifdef GL_ARB_vertex_program

7285 &__GLEW_ARB_vertex_program,

7286 #endif

7287 #ifdef GL_ARB_vertex_shader

7288 &__GLEW_ARB_vertex_shader,

7289 #endif

7290 #ifdef GL_ARB_vertex_type_10f_11f_11f_rev

7291 &__GLEW_ARB_vertex_type_10f_11f_11f_rev,

7292 #endif

7293 #ifdef GL_ARB_vertex_type_2_10_10_10_rev

7294 &__GLEW_ARB_vertex_type_2_10_10_10_rev,

7295 #endif

7296 #ifdef GL_ARB_viewport_array

7297 &__GLEW_ARB_viewport_array,

7298 #endif

7299 #ifdef GL_ARB_window_pos

7300 &__GLEW_ARB_window_pos,

7301 #endif

7302 #ifdef GL_ARM_mali_program_binary

7303 &__GLEW_ARM_mali_program_binary,

7304 #endif

7305 #ifdef GL_ARM_mali_shader_binary

7306 &__GLEW_ARM_mali_shader_binary,

7307 #endif

7308 #ifdef GL_ARM_rgba8

7309 &__GLEW_ARM_rgba8,

7310 #endif

7311 #ifdef GL_ARM_shader_framebuffer_fetch

7312 &__GLEW_ARM_shader_framebuffer_fetch,

7313 #endif

7314 #ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil

7315 &__GLEW_ARM_shader_framebuffer_fetch_depth_stencil,

7316 #endif

7317 #ifdef GL_ATIX_point_sprites

7318 &__GLEW_ATIX_point_sprites,

7319 #endif

7320 #ifdef GL_ATIX_texture_env_combine3

7321 &__GLEW_ATIX_texture_env_combine3,

7322 #endif

7323 #ifdef GL_ATIX_texture_env_route

7324 &__GLEW_ATIX_texture_env_route,

7325 #endif

7326 #ifdef GL_ATIX_vertex_shader_output_point_size

7327 &__GLEW_ATIX_vertex_shader_output_point_size,

7328 #endif

7329 #ifdef GL_ATI_draw_buffers

7330 &__GLEW_ATI_draw_buffers,

7331 #endif

7332 #ifdef GL_ATI_element_array

7333 &__GLEW_ATI_element_array,

7334 #endif

7335 #ifdef GL_ATI_envmap_bumpmap

7336 &__GLEW_ATI_envmap_bumpmap,

7337 #endif

7338 #ifdef GL_ATI_fragment_shader

7339 &__GLEW_ATI_fragment_shader,

7340 #endif

7341 #ifdef GL_ATI_map_object_buffer

7342 &__GLEW_ATI_map_object_buffer,

7343 #endif

7344 #ifdef GL_ATI_meminfo

7345 &__GLEW_ATI_meminfo,

7346 #endif

7347 #ifdef GL_ATI_pn_triangles

7348 &__GLEW_ATI_pn_triangles,

7349 #endif

7350 #ifdef GL_ATI_separate_stencil

7351 &__GLEW_ATI_separate_stencil,

7352 #endif

7353 #ifdef GL_ATI_shader_texture_lod

7354 &__GLEW_ATI_shader_texture_lod,

7355 #endif

7356 #ifdef GL_ATI_text_fragment_shader

7357 &__GLEW_ATI_text_fragment_shader,

7358 #endif

7359 #ifdef GL_ATI_texture_compression_3dc

7360 &__GLEW_ATI_texture_compression_3dc,

7361 #endif

7362 #ifdef GL_ATI_texture_env_combine3

7363 &__GLEW_ATI_texture_env_combine3,

7364 #endif

7365 #ifdef GL_ATI_texture_float

7366 &__GLEW_ATI_texture_float,

7367 #endif

7368 #ifdef GL_ATI_texture_mirror_once

7369 &__GLEW_ATI_texture_mirror_once,

7370 #endif

7371 #ifdef GL_ATI_vertex_array_object

7372 &__GLEW_ATI_vertex_array_object,

7373 #endif

7374 #ifdef GL_ATI_vertex_attrib_array_object

7375 &__GLEW_ATI_vertex_attrib_array_object,

7376 #endif

7377 #ifdef GL_ATI_vertex_streams

7378 &__GLEW_ATI_vertex_streams,

7379 #endif

7380 #ifdef GL_EGL_KHR_context_flush_control

7381 &__GLEW_EGL_KHR_context_flush_control,

7382 #endif

7383 #ifdef GL_EGL_NV_robustness_video_memory_purge

7384 &__GLEW_EGL_NV_robustness_video_memory_purge,

7385 #endif

7386 #ifdef GL_EXT_422_pixels

7387 &__GLEW_EXT_422_pixels,

7388 #endif

7389 #ifdef GL_EXT_Cg_shader

7390 &__GLEW_EXT_Cg_shader,

7391 #endif

7392 #ifdef GL_EXT_EGL_image_array

7393 &__GLEW_EXT_EGL_image_array,

7394 #endif

7395 #ifdef GL_EXT_YUV_target

7396 &__GLEW_EXT_YUV_target,

7397 #endif

7398 #ifdef GL_EXT_abgr

7399 &__GLEW_EXT_abgr,

7400 #endif

7401 #ifdef GL_EXT_base_instance

7402 &__GLEW_EXT_base_instance,

7403 #endif

7404 #ifdef GL_EXT_bgra

7405 &__GLEW_EXT_bgra,

7406 #endif

7407 #ifdef GL_EXT_bindable_uniform

7408 &__GLEW_EXT_bindable_uniform,

7409 #endif

7410 #ifdef GL_EXT_blend_color

7411 &__GLEW_EXT_blend_color,

7412 #endif

7413 #ifdef GL_EXT_blend_equation_separate

7414 &__GLEW_EXT_blend_equation_separate,

7415 #endif

7416 #ifdef GL_EXT_blend_func_extended

7417 &__GLEW_EXT_blend_func_extended,

7418 #endif

7419 #ifdef GL_EXT_blend_func_separate

7420 &__GLEW_EXT_blend_func_separate,

7421 #endif

7422 #ifdef GL_EXT_blend_logic_op

7423 &__GLEW_EXT_blend_logic_op,

7424 #endif

7425 #ifdef GL_EXT_blend_minmax

7426 &__GLEW_EXT_blend_minmax,

7427 #endif

7428 #ifdef GL_EXT_blend_subtract

7429 &__GLEW_EXT_blend_subtract,

7430 #endif

7431 #ifdef GL_EXT_buffer_storage

7432 &__GLEW_EXT_buffer_storage,

7433 #endif

7434 #ifdef GL_EXT_clear_texture

7435 &__GLEW_EXT_clear_texture,

7436 #endif

7437 #ifdef GL_EXT_clip_cull_distance

7438 &__GLEW_EXT_clip_cull_distance,

7439 #endif

7440 #ifdef GL_EXT_clip_volume_hint

7441 &__GLEW_EXT_clip_volume_hint,

7442 #endif

7443 #ifdef GL_EXT_cmyka

7444 &__GLEW_EXT_cmyka,

7445 #endif

7446 #ifdef GL_EXT_color_buffer_float

7447 &__GLEW_EXT_color_buffer_float,

7448 #endif

7449 #ifdef GL_EXT_color_buffer_half_float

7450 &__GLEW_EXT_color_buffer_half_float,

7451 #endif

7452 #ifdef GL_EXT_color_subtable

7453 &__GLEW_EXT_color_subtable,

7454 #endif

7455 #ifdef GL_EXT_compiled_vertex_array

7456 &__GLEW_EXT_compiled_vertex_array,

7457 #endif

7458 #ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture

7459 &__GLEW_EXT_compressed_ETC1_RGB8_sub_texture,

7460 #endif

7461 #ifdef GL_EXT_conservative_depth

7462 &__GLEW_EXT_conservative_depth,

7463 #endif

7464 #ifdef GL_EXT_convolution

7465 &__GLEW_EXT_convolution,

7466 #endif

7467 #ifdef GL_EXT_coordinate_frame

7468 &__GLEW_EXT_coordinate_frame,

7469 #endif

7470 #ifdef GL_EXT_copy_image

7471 &__GLEW_EXT_copy_image,

7472 #endif

7473 #ifdef GL_EXT_copy_texture

7474 &__GLEW_EXT_copy_texture,

7475 #endif

7476 #ifdef GL_EXT_cull_vertex

7477 &__GLEW_EXT_cull_vertex,

7478 #endif

7479 #ifdef GL_EXT_debug_label

7480 &__GLEW_EXT_debug_label,

7481 #endif

7482 #ifdef GL_EXT_debug_marker

7483 &__GLEW_EXT_debug_marker,

7484 #endif

7485 #ifdef GL_EXT_depth_bounds_test

7486 &__GLEW_EXT_depth_bounds_test,

7487 #endif

7488 #ifdef GL_EXT_direct_state_access

7489 &__GLEW_EXT_direct_state_access,

7490 #endif

7491 #ifdef GL_EXT_discard_framebuffer

7492 &__GLEW_EXT_discard_framebuffer,

7493 #endif

7494 #ifdef GL_EXT_draw_buffers

7495 &__GLEW_EXT_draw_buffers,

7496 #endif

7497 #ifdef GL_EXT_draw_buffers2

7498 &__GLEW_EXT_draw_buffers2,

7499 #endif

7500 #ifdef GL_EXT_draw_buffers_indexed

7501 &__GLEW_EXT_draw_buffers_indexed,

7502 #endif

7503 #ifdef GL_EXT_draw_elements_base_vertex

7504 &__GLEW_EXT_draw_elements_base_vertex,

7505 #endif

7506 #ifdef GL_EXT_draw_instanced

7507 &__GLEW_EXT_draw_instanced,

7508 #endif

7509 #ifdef GL_EXT_draw_range_elements

7510 &__GLEW_EXT_draw_range_elements,

7511 #endif

7512 #ifdef GL_EXT_external_buffer

7513 &__GLEW_EXT_external_buffer,

7514 #endif

7515 #ifdef GL_EXT_float_blend

7516 &__GLEW_EXT_float_blend,

7517 #endif

7518 #ifdef GL_EXT_fog_coord

7519 &__GLEW_EXT_fog_coord,

7520 #endif

7521 #ifdef GL_EXT_frag_depth

7522 &__GLEW_EXT_frag_depth,

7523 #endif

7524 #ifdef GL_EXT_fragment_lighting

7525 &__GLEW_EXT_fragment_lighting,

7526 #endif

7527 #ifdef GL_EXT_framebuffer_blit

7528 &__GLEW_EXT_framebuffer_blit,

7529 #endif

7530 #ifdef GL_EXT_framebuffer_multisample

7531 &__GLEW_EXT_framebuffer_multisample,

7532 #endif

7533 #ifdef GL_EXT_framebuffer_multisample_blit_scaled

7534 &__GLEW_EXT_framebuffer_multisample_blit_scaled,

7535 #endif

7536 #ifdef GL_EXT_framebuffer_object

7537 &__GLEW_EXT_framebuffer_object,

7538 #endif

7539 #ifdef GL_EXT_framebuffer_sRGB

7540 &__GLEW_EXT_framebuffer_sRGB,

7541 #endif

7542 #ifdef GL_EXT_geometry_point_size

7543 &__GLEW_EXT_geometry_point_size,

7544 #endif

7545 #ifdef GL_EXT_geometry_shader

7546 &__GLEW_EXT_geometry_shader,

7547 #endif

7548 #ifdef GL_EXT_geometry_shader4

7549 &__GLEW_EXT_geometry_shader4,

7550 #endif

7551 #ifdef GL_EXT_gpu_program_parameters

7552 &__GLEW_EXT_gpu_program_parameters,

7553 #endif

7554 #ifdef GL_EXT_gpu_shader4

7555 &__GLEW_EXT_gpu_shader4,

7556 #endif

7557 #ifdef GL_EXT_gpu_shader5

7558 &__GLEW_EXT_gpu_shader5,

7559 #endif

7560 #ifdef GL_EXT_histogram

7561 &__GLEW_EXT_histogram,

7562 #endif

7563 #ifdef GL_EXT_index_array_formats

7564 &__GLEW_EXT_index_array_formats,

7565 #endif

7566 #ifdef GL_EXT_index_func

7567 &__GLEW_EXT_index_func,

7568 #endif

7569 #ifdef GL_EXT_index_material

7570 &__GLEW_EXT_index_material,

7571 #endif

7572 #ifdef GL_EXT_index_texture

7573 &__GLEW_EXT_index_texture,

7574 #endif

7575 #ifdef GL_EXT_instanced_arrays

7576 &__GLEW_EXT_instanced_arrays,

7577 #endif

7578 #ifdef GL_EXT_light_texture

7579 &__GLEW_EXT_light_texture,

7580 #endif

7581 #ifdef GL_EXT_map_buffer_range

7582 &__GLEW_EXT_map_buffer_range,

7583 #endif

7584 #ifdef GL_EXT_memory_object

7585 &__GLEW_EXT_memory_object,

7586 #endif

7587 #ifdef GL_EXT_memory_object_fd

7588 &__GLEW_EXT_memory_object_fd,

7589 #endif

7590 #ifdef GL_EXT_memory_object_win32

7591 &__GLEW_EXT_memory_object_win32,

7592 #endif

7593 #ifdef GL_EXT_misc_attribute

7594 &__GLEW_EXT_misc_attribute,

7595 #endif

7596 #ifdef GL_EXT_multi_draw_arrays

7597 &__GLEW_EXT_multi_draw_arrays,

7598 #endif

7599 #ifdef GL_EXT_multi_draw_indirect

7600 &__GLEW_EXT_multi_draw_indirect,

7601 #endif

7602 #ifdef GL_EXT_multiple_textures

7603 &__GLEW_EXT_multiple_textures,

7604 #endif

7605 #ifdef GL_EXT_multisample

7606 &__GLEW_EXT_multisample,

7607 #endif

7608 #ifdef GL_EXT_multisample_compatibility

7609 &__GLEW_EXT_multisample_compatibility,

7610 #endif

7611 #ifdef GL_EXT_multisampled_render_to_texture

7612 &__GLEW_EXT_multisampled_render_to_texture,

7613 #endif

7614 #ifdef GL_EXT_multisampled_render_to_texture2

7615 &__GLEW_EXT_multisampled_render_to_texture2,

7616 #endif

7617 #ifdef GL_EXT_multiview_draw_buffers

7618 &__GLEW_EXT_multiview_draw_buffers,

7619 #endif

7620 #ifdef GL_EXT_packed_depth_stencil

7621 &__GLEW_EXT_packed_depth_stencil,

7622 #endif

7623 #ifdef GL_EXT_packed_float

7624 &__GLEW_EXT_packed_float,

7625 #endif

7626 #ifdef GL_EXT_packed_pixels

7627 &__GLEW_EXT_packed_pixels,

7628 #endif

7629 #ifdef GL_EXT_paletted_texture

7630 &__GLEW_EXT_paletted_texture,

7631 #endif

7632 #ifdef GL_EXT_pixel_buffer_object

7633 &__GLEW_EXT_pixel_buffer_object,

7634 #endif

7635 #ifdef GL_EXT_pixel_transform

7636 &__GLEW_EXT_pixel_transform,

7637 #endif

7638 #ifdef GL_EXT_pixel_transform_color_table

7639 &__GLEW_EXT_pixel_transform_color_table,

7640 #endif

7641 #ifdef GL_EXT_point_parameters

7642 &__GLEW_EXT_point_parameters,

7643 #endif

7644 #ifdef GL_EXT_polygon_offset

7645 &__GLEW_EXT_polygon_offset,

7646 #endif

7647 #ifdef GL_EXT_polygon_offset_clamp

7648 &__GLEW_EXT_polygon_offset_clamp,

7649 #endif

7650 #ifdef GL_EXT_post_depth_coverage

7651 &__GLEW_EXT_post_depth_coverage,

7652 #endif

7653 #ifdef GL_EXT_provoking_vertex

7654 &__GLEW_EXT_provoking_vertex,

7655 #endif

7656 #ifdef GL_EXT_pvrtc_sRGB

7657 &__GLEW_EXT_pvrtc_sRGB,

7658 #endif

7659 #ifdef GL_EXT_raster_multisample

7660 &__GLEW_EXT_raster_multisample,

7661 #endif

7662 #ifdef GL_EXT_read_format_bgra

7663 &__GLEW_EXT_read_format_bgra,

7664 #endif

7665 #ifdef GL_EXT_render_snorm

7666 &__GLEW_EXT_render_snorm,

7667 #endif

7668 #ifdef GL_EXT_rescale_normal

7669 &__GLEW_EXT_rescale_normal,

7670 #endif

7671 #ifdef GL_EXT_sRGB

7672 &__GLEW_EXT_sRGB,

7673 #endif

7674 #ifdef GL_EXT_sRGB_write_control

7675 &__GLEW_EXT_sRGB_write_control,

7676 #endif

7677 #ifdef GL_EXT_scene_marker

7678 &__GLEW_EXT_scene_marker,

7679 #endif

7680 #ifdef GL_EXT_secondary_color

7681 &__GLEW_EXT_secondary_color,

7682 #endif

7683 #ifdef GL_EXT_semaphore

7684 &__GLEW_EXT_semaphore,

7685 #endif

7686 #ifdef GL_EXT_semaphore_fd

7687 &__GLEW_EXT_semaphore_fd,

7688 #endif

7689 #ifdef GL_EXT_semaphore_win32

7690 &__GLEW_EXT_semaphore_win32,

7691 #endif

7692 #ifdef GL_EXT_separate_shader_objects

7693 &__GLEW_EXT_separate_shader_objects,

7694 #endif

7695 #ifdef GL_EXT_separate_specular_color

7696 &__GLEW_EXT_separate_specular_color,

7697 #endif

7698 #ifdef GL_EXT_shader_framebuffer_fetch

7699 &__GLEW_EXT_shader_framebuffer_fetch,

7700 #endif

7701 #ifdef GL_EXT_shader_group_vote

7702 &__GLEW_EXT_shader_group_vote,

7703 #endif

7704 #ifdef GL_EXT_shader_image_load_formatted

7705 &__GLEW_EXT_shader_image_load_formatted,

7706 #endif

7707 #ifdef GL_EXT_shader_image_load_store

7708 &__GLEW_EXT_shader_image_load_store,

7709 #endif

7710 #ifdef GL_EXT_shader_implicit_conversions

7711 &__GLEW_EXT_shader_implicit_conversions,

7712 #endif

7713 #ifdef GL_EXT_shader_integer_mix

7714 &__GLEW_EXT_shader_integer_mix,

7715 #endif

7716 #ifdef GL_EXT_shader_io_blocks

7717 &__GLEW_EXT_shader_io_blocks,

7718 #endif

7719 #ifdef GL_EXT_shader_non_constant_global_initializers

7720 &__GLEW_EXT_shader_non_constant_global_initializers,

7721 #endif

7722 #ifdef GL_EXT_shader_pixel_local_storage

7723 &__GLEW_EXT_shader_pixel_local_storage,

7724 #endif

7725 #ifdef GL_EXT_shader_pixel_local_storage2

7726 &__GLEW_EXT_shader_pixel_local_storage2,

7727 #endif

7728 #ifdef GL_EXT_shader_texture_lod

7729 &__GLEW_EXT_shader_texture_lod,

7730 #endif

7731 #ifdef GL_EXT_shadow_funcs

7732 &__GLEW_EXT_shadow_funcs,

7733 #endif

7734 #ifdef GL_EXT_shadow_samplers

7735 &__GLEW_EXT_shadow_samplers,

7736 #endif

7737 #ifdef GL_EXT_shared_texture_palette

7738 &__GLEW_EXT_shared_texture_palette,

7739 #endif

7740 #ifdef GL_EXT_sparse_texture

7741 &__GLEW_EXT_sparse_texture,

7742 #endif

7743 #ifdef GL_EXT_sparse_texture2

7744 &__GLEW_EXT_sparse_texture2,

7745 #endif

7746 #ifdef GL_EXT_stencil_clear_tag

7747 &__GLEW_EXT_stencil_clear_tag,

7748 #endif

7749 #ifdef GL_EXT_stencil_two_side

7750 &__GLEW_EXT_stencil_two_side,

7751 #endif

7752 #ifdef GL_EXT_stencil_wrap

7753 &__GLEW_EXT_stencil_wrap,

7754 #endif

7755 #ifdef GL_EXT_subtexture

7756 &__GLEW_EXT_subtexture,

7757 #endif

7758 #ifdef GL_EXT_texture

7759 &__GLEW_EXT_texture,

7760 #endif

7761 #ifdef GL_EXT_texture3D

7762 &__GLEW_EXT_texture3D,

7763 #endif

7764 #ifdef GL_EXT_texture_array

7765 &__GLEW_EXT_texture_array,

7766 #endif

7767 #ifdef GL_EXT_texture_buffer_object

7768 &__GLEW_EXT_texture_buffer_object,

7769 #endif

7770 #ifdef GL_EXT_texture_compression_astc_decode_mode

7771 &__GLEW_EXT_texture_compression_astc_decode_mode,

7772 #endif

7773 #ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5

7774 &__GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5,

7775 #endif

7776 #ifdef GL_EXT_texture_compression_bptc

7777 &__GLEW_EXT_texture_compression_bptc,

7778 #endif

7779 #ifdef GL_EXT_texture_compression_dxt1

7780 &__GLEW_EXT_texture_compression_dxt1,

7781 #endif

7782 #ifdef GL_EXT_texture_compression_latc

7783 &__GLEW_EXT_texture_compression_latc,

7784 #endif

7785 #ifdef GL_EXT_texture_compression_rgtc

7786 &__GLEW_EXT_texture_compression_rgtc,

7787 #endif

7788 #ifdef GL_EXT_texture_compression_s3tc

7789 &__GLEW_EXT_texture_compression_s3tc,

7790 #endif

7791 #ifdef GL_EXT_texture_cube_map

7792 &__GLEW_EXT_texture_cube_map,

7793 #endif

7794 #ifdef GL_EXT_texture_cube_map_array

7795 &__GLEW_EXT_texture_cube_map_array,

7796 #endif

7797 #ifdef GL_EXT_texture_edge_clamp

7798 &__GLEW_EXT_texture_edge_clamp,

7799 #endif

7800 #ifdef GL_EXT_texture_env

7801 &__GLEW_EXT_texture_env,

7802 #endif

7803 #ifdef GL_EXT_texture_env_add

7804 &__GLEW_EXT_texture_env_add,

7805 #endif

7806 #ifdef GL_EXT_texture_env_combine

7807 &__GLEW_EXT_texture_env_combine,

7808 #endif

7809 #ifdef GL_EXT_texture_env_dot3

7810 &__GLEW_EXT_texture_env_dot3,

7811 #endif

7812 #ifdef GL_EXT_texture_filter_anisotropic

7813 &__GLEW_EXT_texture_filter_anisotropic,

7814 #endif

7815 #ifdef GL_EXT_texture_filter_minmax

7816 &__GLEW_EXT_texture_filter_minmax,

7817 #endif

7818 #ifdef GL_EXT_texture_format_BGRA8888

7819 &__GLEW_EXT_texture_format_BGRA8888,

7820 #endif

7821 #ifdef GL_EXT_texture_integer

7822 &__GLEW_EXT_texture_integer,

7823 #endif

7824 #ifdef GL_EXT_texture_lod_bias

7825 &__GLEW_EXT_texture_lod_bias,

7826 #endif

7827 #ifdef GL_EXT_texture_mirror_clamp

7828 &__GLEW_EXT_texture_mirror_clamp,

7829 #endif

7830 #ifdef GL_EXT_texture_norm16

7831 &__GLEW_EXT_texture_norm16,

7832 #endif

7833 #ifdef GL_EXT_texture_object

7834 &__GLEW_EXT_texture_object,

7835 #endif

7836 #ifdef GL_EXT_texture_perturb_normal

7837 &__GLEW_EXT_texture_perturb_normal,

7838 #endif

7839 #ifdef GL_EXT_texture_rectangle

7840 &__GLEW_EXT_texture_rectangle,

7841 #endif

7842 #ifdef GL_EXT_texture_rg

7843 &__GLEW_EXT_texture_rg,

7844 #endif

7845 #ifdef GL_EXT_texture_sRGB

7846 &__GLEW_EXT_texture_sRGB,

7847 #endif

7848 #ifdef GL_EXT_texture_sRGB_R8

7849 &__GLEW_EXT_texture_sRGB_R8,

7850 #endif

7851 #ifdef GL_EXT_texture_sRGB_RG8

7852 &__GLEW_EXT_texture_sRGB_RG8,

7853 #endif

7854 #ifdef GL_EXT_texture_sRGB_decode

7855 &__GLEW_EXT_texture_sRGB_decode,

7856 #endif

7857 #ifdef GL_EXT_texture_shared_exponent

7858 &__GLEW_EXT_texture_shared_exponent,

7859 #endif

7860 #ifdef GL_EXT_texture_snorm

7861 &__GLEW_EXT_texture_snorm,

7862 #endif

7863 #ifdef GL_EXT_texture_storage

7864 &__GLEW_EXT_texture_storage,

7865 #endif

7866 #ifdef GL_EXT_texture_swizzle

7867 &__GLEW_EXT_texture_swizzle,

7868 #endif

7869 #ifdef GL_EXT_texture_type_2_10_10_10_REV

7870 &__GLEW_EXT_texture_type_2_10_10_10_REV,

7871 #endif

7872 #ifdef GL_EXT_texture_view

7873 &__GLEW_EXT_texture_view,

7874 #endif

7875 #ifdef GL_EXT_timer_query

7876 &__GLEW_EXT_timer_query,

7877 #endif

7878 #ifdef GL_EXT_transform_feedback

7879 &__GLEW_EXT_transform_feedback,

7880 #endif

7881 #ifdef GL_EXT_unpack_subimage

7882 &__GLEW_EXT_unpack_subimage,

7883 #endif

7884 #ifdef GL_EXT_vertex_array

7885 &__GLEW_EXT_vertex_array,

7886 #endif

7887 #ifdef GL_EXT_vertex_array_bgra

7888 &__GLEW_EXT_vertex_array_bgra,

7889 #endif

7890 #ifdef GL_EXT_vertex_array_setXXX

7891 &__GLEW_EXT_vertex_array_setXXX,

7892 #endif

7893 #ifdef GL_EXT_vertex_attrib_64bit

7894 &__GLEW_EXT_vertex_attrib_64bit,

7895 #endif

7896 #ifdef GL_EXT_vertex_shader

7897 &__GLEW_EXT_vertex_shader,

7898 #endif

7899 #ifdef GL_EXT_vertex_weighting

7900 &__GLEW_EXT_vertex_weighting,

7901 #endif

7902 #ifdef GL_EXT_win32_keyed_mutex

7903 &__GLEW_EXT_win32_keyed_mutex,

7904 #endif

7905 #ifdef GL_EXT_window_rectangles

7906 &__GLEW_EXT_window_rectangles,

7907 #endif

7908 #ifdef GL_EXT_x11_sync_object

7909 &__GLEW_EXT_x11_sync_object,

7910 #endif

7911 #ifdef GL_GREMEDY_frame_terminator

7912 &__GLEW_GREMEDY_frame_terminator,

7913 #endif

7914 #ifdef GL_GREMEDY_string_marker

7915 &__GLEW_GREMEDY_string_marker,

7916 #endif

7917 #ifdef GL_HP_convolution_border_modes

7918 &__GLEW_HP_convolution_border_modes,

7919 #endif

7920 #ifdef GL_HP_image_transform

7921 &__GLEW_HP_image_transform,

7922 #endif

7923 #ifdef GL_HP_occlusion_test

7924 &__GLEW_HP_occlusion_test,

7925 #endif

7926 #ifdef GL_HP_texture_lighting

7927 &__GLEW_HP_texture_lighting,

7928 #endif

7929 #ifdef GL_IBM_cull_vertex

7930 &__GLEW_IBM_cull_vertex,

7931 #endif

7932 #ifdef GL_IBM_multimode_draw_arrays

7933 &__GLEW_IBM_multimode_draw_arrays,

7934 #endif

7935 #ifdef GL_IBM_rasterpos_clip

7936 &__GLEW_IBM_rasterpos_clip,

7937 #endif

7938 #ifdef GL_IBM_static_data

7939 &__GLEW_IBM_static_data,

7940 #endif

7941 #ifdef GL_IBM_texture_mirrored_repeat

7942 &__GLEW_IBM_texture_mirrored_repeat,

7943 #endif

7944 #ifdef GL_IBM_vertex_array_lists

7945 &__GLEW_IBM_vertex_array_lists,

7946 #endif

7947 #ifdef GL_INGR_color_clamp

7948 &__GLEW_INGR_color_clamp,

7949 #endif

7950 #ifdef GL_INGR_interlace_read

7951 &__GLEW_INGR_interlace_read,

7952 #endif

7953 #ifdef GL_INTEL_conservative_rasterization

7954 &__GLEW_INTEL_conservative_rasterization,

7955 #endif

7956 #ifdef GL_INTEL_fragment_shader_ordering

7957 &__GLEW_INTEL_fragment_shader_ordering,

7958 #endif

7959 #ifdef GL_INTEL_framebuffer_CMAA

7960 &__GLEW_INTEL_framebuffer_CMAA,

7961 #endif

7962 #ifdef GL_INTEL_map_texture

7963 &__GLEW_INTEL_map_texture,

7964 #endif

7965 #ifdef GL_INTEL_parallel_arrays

7966 &__GLEW_INTEL_parallel_arrays,

7967 #endif

7968 #ifdef GL_INTEL_performance_query

7969 &__GLEW_INTEL_performance_query,

7970 #endif

7971 #ifdef GL_INTEL_texture_scissor

7972 &__GLEW_INTEL_texture_scissor,

7973 #endif

7974 #ifdef GL_KHR_blend_equation_advanced

7975 &__GLEW_KHR_blend_equation_advanced,

7976 #endif

7977 #ifdef GL_KHR_blend_equation_advanced_coherent

7978 &__GLEW_KHR_blend_equation_advanced_coherent,

7979 #endif

7980 #ifdef GL_KHR_context_flush_control

7981 &__GLEW_KHR_context_flush_control,

7982 #endif

7983 #ifdef GL_KHR_debug

7984 &__GLEW_KHR_debug,

7985 #endif

7986 #ifdef GL_KHR_no_error

7987 &__GLEW_KHR_no_error,

7988 #endif

7989 #ifdef GL_KHR_parallel_shader_compile

7990 &__GLEW_KHR_parallel_shader_compile,

7991 #endif

7992 #ifdef GL_KHR_robust_buffer_access_behavior

7993 &__GLEW_KHR_robust_buffer_access_behavior,

7994 #endif

7995 #ifdef GL_KHR_robustness

7996 &__GLEW_KHR_robustness,

7997 #endif

7998 #ifdef GL_KHR_texture_compression_astc_hdr

7999 &__GLEW_KHR_texture_compression_astc_hdr,

8000 #endif

8001 #ifdef GL_KHR_texture_compression_astc_ldr

8002 &__GLEW_KHR_texture_compression_astc_ldr,

8003 #endif

8004 #ifdef GL_KHR_texture_compression_astc_sliced_3d

8005 &__GLEW_KHR_texture_compression_astc_sliced_3d,

8006 #endif

8007 #ifdef GL_KTX_buffer_region

8008 &__GLEW_KTX_buffer_region,

8009 #endif

8010 #ifdef GL_MESAX_texture_stack

8011 &__GLEW_MESAX_texture_stack,

8012 #endif

8013 #ifdef GL_MESA_pack_invert

8014 &__GLEW_MESA_pack_invert,

8015 #endif

8016 #ifdef GL_MESA_resize_buffers

8017 &__GLEW_MESA_resize_buffers,

8018 #endif

8019 #ifdef GL_MESA_shader_integer_functions

8020 &__GLEW_MESA_shader_integer_functions,

8021 #endif

8022 #ifdef GL_MESA_window_pos

8023 &__GLEW_MESA_window_pos,

8024 #endif

8025 #ifdef GL_MESA_ycbcr_texture

8026 &__GLEW_MESA_ycbcr_texture,

8027 #endif

8028 #ifdef GL_NVX_blend_equation_advanced_multi_draw_buffers

8029 &__GLEW_NVX_blend_equation_advanced_multi_draw_buffers,

8030 #endif

8031 #ifdef GL_NVX_conditional_render

8032 &__GLEW_NVX_conditional_render,

8033 #endif

8034 #ifdef GL_NVX_gpu_memory_info

8035 &__GLEW_NVX_gpu_memory_info,

8036 #endif

8037 #ifdef GL_NVX_linked_gpu_multicast

8038 &__GLEW_NVX_linked_gpu_multicast,

8039 #endif

8040 #ifdef GL_NV_3dvision_settings

8041 &__GLEW_NV_3dvision_settings,

8042 #endif

8043 #ifdef GL_NV_EGL_stream_consumer_external

8044 &__GLEW_NV_EGL_stream_consumer_external,

8045 #endif

8046 #ifdef GL_NV_alpha_to_coverage_dither_control

8047 &__GLEW_NV_alpha_to_coverage_dither_control,

8048 #endif

8049 #ifdef GL_NV_bgr

8050 &__GLEW_NV_bgr,

8051 #endif

8052 #ifdef GL_NV_bindless_multi_draw_indirect

8053 &__GLEW_NV_bindless_multi_draw_indirect,

8054 #endif

8055 #ifdef GL_NV_bindless_multi_draw_indirect_count

8056 &__GLEW_NV_bindless_multi_draw_indirect_count,

8057 #endif

8058 #ifdef GL_NV_bindless_texture

8059 &__GLEW_NV_bindless_texture,

8060 #endif

8061 #ifdef GL_NV_blend_equation_advanced

8062 &__GLEW_NV_blend_equation_advanced,

8063 #endif

8064 #ifdef GL_NV_blend_equation_advanced_coherent

8065 &__GLEW_NV_blend_equation_advanced_coherent,

8066 #endif

8067 #ifdef GL_NV_blend_minmax_factor

8068 &__GLEW_NV_blend_minmax_factor,

8069 #endif

8070 #ifdef GL_NV_blend_square

8071 &__GLEW_NV_blend_square,

8072 #endif

8073 #ifdef GL_NV_clip_space_w_scaling

8074 &__GLEW_NV_clip_space_w_scaling,

8075 #endif

8076 #ifdef GL_NV_command_list

8077 &__GLEW_NV_command_list,

8078 #endif

8079 #ifdef GL_NV_compute_program5

8080 &__GLEW_NV_compute_program5,

8081 #endif

8082 #ifdef GL_NV_conditional_render

8083 &__GLEW_NV_conditional_render,

8084 #endif

8085 #ifdef GL_NV_conservative_raster

8086 &__GLEW_NV_conservative_raster,

8087 #endif

8088 #ifdef GL_NV_conservative_raster_dilate

8089 &__GLEW_NV_conservative_raster_dilate,

8090 #endif

8091 #ifdef GL_NV_conservative_raster_pre_snap_triangles

8092 &__GLEW_NV_conservative_raster_pre_snap_triangles,

8093 #endif

8094 #ifdef GL_NV_copy_buffer

8095 &__GLEW_NV_copy_buffer,

8096 #endif

8097 #ifdef GL_NV_copy_depth_to_color

8098 &__GLEW_NV_copy_depth_to_color,

8099 #endif

8100 #ifdef GL_NV_copy_image

8101 &__GLEW_NV_copy_image,

8102 #endif

8103 #ifdef GL_NV_deep_texture3D

8104 &__GLEW_NV_deep_texture3D,

8105 #endif

8106 #ifdef GL_NV_depth_buffer_float

8107 &__GLEW_NV_depth_buffer_float,

8108 #endif

8109 #ifdef GL_NV_depth_clamp

8110 &__GLEW_NV_depth_clamp,

8111 #endif

8112 #ifdef GL_NV_depth_range_unclamped

8113 &__GLEW_NV_depth_range_unclamped,

8114 #endif

8115 #ifdef GL_NV_draw_buffers

8116 &__GLEW_NV_draw_buffers,

8117 #endif

8118 #ifdef GL_NV_draw_instanced

8119 &__GLEW_NV_draw_instanced,

8120 #endif

8121 #ifdef GL_NV_draw_texture

8122 &__GLEW_NV_draw_texture,

8123 #endif

8124 #ifdef GL_NV_draw_vulkan_image

8125 &__GLEW_NV_draw_vulkan_image,

8126 #endif

8127 #ifdef GL_NV_evaluators

8128 &__GLEW_NV_evaluators,

8129 #endif

8130 #ifdef GL_NV_explicit_attrib_location

8131 &__GLEW_NV_explicit_attrib_location,

8132 #endif

8133 #ifdef GL_NV_explicit_multisample

8134 &__GLEW_NV_explicit_multisample,

8135 #endif

8136 #ifdef GL_NV_fbo_color_attachments

8137 &__GLEW_NV_fbo_color_attachments,

8138 #endif

8139 #ifdef GL_NV_fence

8140 &__GLEW_NV_fence,

8141 #endif

8142 #ifdef GL_NV_fill_rectangle

8143 &__GLEW_NV_fill_rectangle,

8144 #endif

8145 #ifdef GL_NV_float_buffer

8146 &__GLEW_NV_float_buffer,

8147 #endif

8148 #ifdef GL_NV_fog_distance

8149 &__GLEW_NV_fog_distance,

8150 #endif

8151 #ifdef GL_NV_fragment_coverage_to_color

8152 &__GLEW_NV_fragment_coverage_to_color,

8153 #endif

8154 #ifdef GL_NV_fragment_program

8155 &__GLEW_NV_fragment_program,

8156 #endif

8157 #ifdef GL_NV_fragment_program2

8158 &__GLEW_NV_fragment_program2,

8159 #endif

8160 #ifdef GL_NV_fragment_program4

8161 &__GLEW_NV_fragment_program4,

8162 #endif

8163 #ifdef GL_NV_fragment_program_option

8164 &__GLEW_NV_fragment_program_option,

8165 #endif

8166 #ifdef GL_NV_fragment_shader_interlock

8167 &__GLEW_NV_fragment_shader_interlock,

8168 #endif

8169 #ifdef GL_NV_framebuffer_blit

8170 &__GLEW_NV_framebuffer_blit,

8171 #endif

8172 #ifdef GL_NV_framebuffer_mixed_samples

8173 &__GLEW_NV_framebuffer_mixed_samples,

8174 #endif

8175 #ifdef GL_NV_framebuffer_multisample

8176 &__GLEW_NV_framebuffer_multisample,

8177 #endif

8178 #ifdef GL_NV_framebuffer_multisample_coverage

8179 &__GLEW_NV_framebuffer_multisample_coverage,

8180 #endif

8181 #ifdef GL_NV_generate_mipmap_sRGB

8182 &__GLEW_NV_generate_mipmap_sRGB,

8183 #endif

8184 #ifdef GL_NV_geometry_program4

8185 &__GLEW_NV_geometry_program4,

8186 #endif

8187 #ifdef GL_NV_geometry_shader4

8188 &__GLEW_NV_geometry_shader4,

8189 #endif

8190 #ifdef GL_NV_geometry_shader_passthrough

8191 &__GLEW_NV_geometry_shader_passthrough,

8192 #endif

8193 #ifdef GL_NV_gpu_multicast

8194 &__GLEW_NV_gpu_multicast,

8195 #endif

8196 #ifdef GL_NV_gpu_program4

8197 &__GLEW_NV_gpu_program4,

8198 #endif

8199 #ifdef GL_NV_gpu_program5

8200 &__GLEW_NV_gpu_program5,

8201 #endif

8202 #ifdef GL_NV_gpu_program5_mem_extended

8203 &__GLEW_NV_gpu_program5_mem_extended,

8204 #endif

8205 #ifdef GL_NV_gpu_program_fp64

8206 &__GLEW_NV_gpu_program_fp64,

8207 #endif

8208 #ifdef GL_NV_gpu_shader5

8209 &__GLEW_NV_gpu_shader5,

8210 #endif

8211 #ifdef GL_NV_half_float

8212 &__GLEW_NV_half_float,

8213 #endif

8214 #ifdef GL_NV_image_formats

8215 &__GLEW_NV_image_formats,

8216 #endif

8217 #ifdef GL_NV_instanced_arrays

8218 &__GLEW_NV_instanced_arrays,

8219 #endif

8220 #ifdef GL_NV_internalformat_sample_query

8221 &__GLEW_NV_internalformat_sample_query,

8222 #endif

8223 #ifdef GL_NV_light_max_exponent

8224 &__GLEW_NV_light_max_exponent,

8225 #endif

8226 #ifdef GL_NV_multisample_coverage

8227 &__GLEW_NV_multisample_coverage,

8228 #endif

8229 #ifdef GL_NV_multisample_filter_hint

8230 &__GLEW_NV_multisample_filter_hint,

8231 #endif

8232 #ifdef GL_NV_non_square_matrices

8233 &__GLEW_NV_non_square_matrices,

8234 #endif

8235 #ifdef GL_NV_occlusion_query

8236 &__GLEW_NV_occlusion_query,

8237 #endif

8238 #ifdef GL_NV_pack_subimage

8239 &__GLEW_NV_pack_subimage,

8240 #endif

8241 #ifdef GL_NV_packed_depth_stencil

8242 &__GLEW_NV_packed_depth_stencil,

8243 #endif

8244 #ifdef GL_NV_packed_float

8245 &__GLEW_NV_packed_float,

8246 #endif

8247 #ifdef GL_NV_packed_float_linear

8248 &__GLEW_NV_packed_float_linear,

8249 #endif

8250 #ifdef GL_NV_parameter_buffer_object

8251 &__GLEW_NV_parameter_buffer_object,

8252 #endif

8253 #ifdef GL_NV_parameter_buffer_object2

8254 &__GLEW_NV_parameter_buffer_object2,

8255 #endif

8256 #ifdef GL_NV_path_rendering

8257 &__GLEW_NV_path_rendering,

8258 #endif

8259 #ifdef GL_NV_path_rendering_shared_edge

8260 &__GLEW_NV_path_rendering_shared_edge,

8261 #endif

8262 #ifdef GL_NV_pixel_buffer_object

8263 &__GLEW_NV_pixel_buffer_object,

8264 #endif

8265 #ifdef GL_NV_pixel_data_range

8266 &__GLEW_NV_pixel_data_range,

8267 #endif

8268 #ifdef GL_NV_platform_binary

8269 &__GLEW_NV_platform_binary,

8270 #endif

8271 #ifdef GL_NV_point_sprite

8272 &__GLEW_NV_point_sprite,

8273 #endif

8274 #ifdef GL_NV_polygon_mode

8275 &__GLEW_NV_polygon_mode,

8276 #endif

8277 #ifdef GL_NV_present_video

8278 &__GLEW_NV_present_video,

8279 #endif

8280 #ifdef GL_NV_primitive_restart

8281 &__GLEW_NV_primitive_restart,

8282 #endif

8283 #ifdef GL_NV_read_depth

8284 &__GLEW_NV_read_depth,

8285 #endif

8286 #ifdef GL_NV_read_depth_stencil

8287 &__GLEW_NV_read_depth_stencil,

8288 #endif

8289 #ifdef GL_NV_read_stencil

8290 &__GLEW_NV_read_stencil,

8291 #endif

8292 #ifdef GL_NV_register_combiners

8293 &__GLEW_NV_register_combiners,

8294 #endif

8295 #ifdef GL_NV_register_combiners2

8296 &__GLEW_NV_register_combiners2,

8297 #endif

8298 #ifdef GL_NV_robustness_video_memory_purge

8299 &__GLEW_NV_robustness_video_memory_purge,

8300 #endif

8301 #ifdef GL_NV_sRGB_formats

8302 &__GLEW_NV_sRGB_formats,

8303 #endif

8304 #ifdef GL_NV_sample_locations

8305 &__GLEW_NV_sample_locations,

8306 #endif

8307 #ifdef GL_NV_sample_mask_override_coverage

8308 &__GLEW_NV_sample_mask_override_coverage,

8309 #endif

8310 #ifdef GL_NV_shader_atomic_counters

8311 &__GLEW_NV_shader_atomic_counters,

8312 #endif

8313 #ifdef GL_NV_shader_atomic_float

8314 &__GLEW_NV_shader_atomic_float,

8315 #endif

8316 #ifdef GL_NV_shader_atomic_float64

8317 &__GLEW_NV_shader_atomic_float64,

8318 #endif

8319 #ifdef GL_NV_shader_atomic_fp16_vector

8320 &__GLEW_NV_shader_atomic_fp16_vector,

8321 #endif

8322 #ifdef GL_NV_shader_atomic_int64

8323 &__GLEW_NV_shader_atomic_int64,

8324 #endif

8325 #ifdef GL_NV_shader_buffer_load

8326 &__GLEW_NV_shader_buffer_load,

8327 #endif

8328 #ifdef GL_NV_shader_noperspective_interpolation

8329 &__GLEW_NV_shader_noperspective_interpolation,

8330 #endif

8331 #ifdef GL_NV_shader_storage_buffer_object

8332 &__GLEW_NV_shader_storage_buffer_object,

8333 #endif

8334 #ifdef GL_NV_shader_thread_group

8335 &__GLEW_NV_shader_thread_group,

8336 #endif

8337 #ifdef GL_NV_shader_thread_shuffle

8338 &__GLEW_NV_shader_thread_shuffle,

8339 #endif

8340 #ifdef GL_NV_shadow_samplers_array

8341 &__GLEW_NV_shadow_samplers_array,

8342 #endif

8343 #ifdef GL_NV_shadow_samplers_cube

8344 &__GLEW_NV_shadow_samplers_cube,

8345 #endif

8346 #ifdef GL_NV_stereo_view_rendering

8347 &__GLEW_NV_stereo_view_rendering,

8348 #endif

8349 #ifdef GL_NV_tessellation_program5

8350 &__GLEW_NV_tessellation_program5,

8351 #endif

8352 #ifdef GL_NV_texgen_emboss

8353 &__GLEW_NV_texgen_emboss,

8354 #endif

8355 #ifdef GL_NV_texgen_reflection

8356 &__GLEW_NV_texgen_reflection,

8357 #endif

8358 #ifdef GL_NV_texture_array

8359 &__GLEW_NV_texture_array,

8360 #endif

8361 #ifdef GL_NV_texture_barrier

8362 &__GLEW_NV_texture_barrier,

8363 #endif

8364 #ifdef GL_NV_texture_border_clamp

8365 &__GLEW_NV_texture_border_clamp,

8366 #endif

8367 #ifdef GL_NV_texture_compression_latc

8368 &__GLEW_NV_texture_compression_latc,

8369 #endif

8370 #ifdef GL_NV_texture_compression_s3tc

8371 &__GLEW_NV_texture_compression_s3tc,

8372 #endif

8373 #ifdef GL_NV_texture_compression_s3tc_update

8374 &__GLEW_NV_texture_compression_s3tc_update,

8375 #endif

8376 #ifdef GL_NV_texture_compression_vtc

8377 &__GLEW_NV_texture_compression_vtc,

8378 #endif

8379 #ifdef GL_NV_texture_env_combine4

8380 &__GLEW_NV_texture_env_combine4,

8381 #endif

8382 #ifdef GL_NV_texture_expand_normal

8383 &__GLEW_NV_texture_expand_normal,

8384 #endif

8385 #ifdef GL_NV_texture_multisample

8386 &__GLEW_NV_texture_multisample,

8387 #endif

8388 #ifdef GL_NV_texture_npot_2D_mipmap

8389 &__GLEW_NV_texture_npot_2D_mipmap,

8390 #endif

8391 #ifdef GL_NV_texture_rectangle

8392 &__GLEW_NV_texture_rectangle,

8393 #endif

8394 #ifdef GL_NV_texture_rectangle_compressed

8395 &__GLEW_NV_texture_rectangle_compressed,

8396 #endif

8397 #ifdef GL_NV_texture_shader

8398 &__GLEW_NV_texture_shader,

8399 #endif

8400 #ifdef GL_NV_texture_shader2

8401 &__GLEW_NV_texture_shader2,

8402 #endif

8403 #ifdef GL_NV_texture_shader3

8404 &__GLEW_NV_texture_shader3,

8405 #endif

8406 #ifdef GL_NV_transform_feedback

8407 &__GLEW_NV_transform_feedback,

8408 #endif

8409 #ifdef GL_NV_transform_feedback2

8410 &__GLEW_NV_transform_feedback2,

8411 #endif

8412 #ifdef GL_NV_uniform_buffer_unified_memory

8413 &__GLEW_NV_uniform_buffer_unified_memory,

8414 #endif

8415 #ifdef GL_NV_vdpau_interop

8416 &__GLEW_NV_vdpau_interop,

8417 #endif

8418 #ifdef GL_NV_vertex_array_range

8419 &__GLEW_NV_vertex_array_range,

8420 #endif

8421 #ifdef GL_NV_vertex_array_range2

8422 &__GLEW_NV_vertex_array_range2,

8423 #endif

8424 #ifdef GL_NV_vertex_attrib_integer_64bit

8425 &__GLEW_NV_vertex_attrib_integer_64bit,

8426 #endif

8427 #ifdef GL_NV_vertex_buffer_unified_memory

8428 &__GLEW_NV_vertex_buffer_unified_memory,

8429 #endif

8430 #ifdef GL_NV_vertex_program

8431 &__GLEW_NV_vertex_program,

8432 #endif

8433 #ifdef GL_NV_vertex_program1_1

8434 &__GLEW_NV_vertex_program1_1,

8435 #endif

8436 #ifdef GL_NV_vertex_program2

8437 &__GLEW_NV_vertex_program2,

8438 #endif

8439 #ifdef GL_NV_vertex_program2_option

8440 &__GLEW_NV_vertex_program2_option,

8441 #endif

8442 #ifdef GL_NV_vertex_program3

8443 &__GLEW_NV_vertex_program3,

8444 #endif

8445 #ifdef GL_NV_vertex_program4

8446 &__GLEW_NV_vertex_program4,

8447 #endif

8448 #ifdef GL_NV_video_capture

8449 &__GLEW_NV_video_capture,

8450 #endif

8451 #ifdef GL_NV_viewport_array

8452 &__GLEW_NV_viewport_array,

8453 #endif

8454 #ifdef GL_NV_viewport_array2

8455 &__GLEW_NV_viewport_array2,

8456 #endif

8457 #ifdef GL_NV_viewport_swizzle

8458 &__GLEW_NV_viewport_swizzle,

8459 #endif

8460 #ifdef GL_OES_byte_coordinates

8461 &__GLEW_OES_byte_coordinates,

8462 #endif

8463 #ifdef GL_OML_interlace

8464 &__GLEW_OML_interlace,

8465 #endif

8466 #ifdef GL_OML_resample

8467 &__GLEW_OML_resample,

8468 #endif

8469 #ifdef GL_OML_subsample

8470 &__GLEW_OML_subsample,

8471 #endif

8472 #ifdef GL_OVR_multiview

8473 &__GLEW_OVR_multiview,

8474 #endif

8475 #ifdef GL_OVR_multiview2

8476 &__GLEW_OVR_multiview2,

8477 #endif

8478 #ifdef GL_OVR_multiview_multisampled_render_to_texture

8479 &__GLEW_OVR_multiview_multisampled_render_to_texture,

8480 #endif

8481 #ifdef GL_PGI_misc_hints

8482 &__GLEW_PGI_misc_hints,

8483 #endif

8484 #ifdef GL_PGI_vertex_hints

8485 &__GLEW_PGI_vertex_hints,

8486 #endif

8487 #ifdef GL_QCOM_alpha_test

8488 &__GLEW_QCOM_alpha_test,

8489 #endif

8490 #ifdef GL_QCOM_binning_control

8491 &__GLEW_QCOM_binning_control,

8492 #endif

8493 #ifdef GL_QCOM_driver_control

8494 &__GLEW_QCOM_driver_control,

8495 #endif

8496 #ifdef GL_QCOM_extended_get

8497 &__GLEW_QCOM_extended_get,

8498 #endif

8499 #ifdef GL_QCOM_extended_get2

8500 &__GLEW_QCOM_extended_get2,

8501 #endif

8502 #ifdef GL_QCOM_framebuffer_foveated

8503 &__GLEW_QCOM_framebuffer_foveated,

8504 #endif

8505 #ifdef GL_QCOM_perfmon_global_mode

8506 &__GLEW_QCOM_perfmon_global_mode,

8507 #endif

8508 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent

8509 &__GLEW_QCOM_shader_framebuffer_fetch_noncoherent,

8510 #endif

8511 #ifdef GL_QCOM_tiled_rendering

8512 &__GLEW_QCOM_tiled_rendering,

8513 #endif

8514 #ifdef GL_QCOM_writeonly_rendering

8515 &__GLEW_QCOM_writeonly_rendering,

8516 #endif

8517 #ifdef GL_REGAL_ES1_0_compatibility

8518 &__GLEW_REGAL_ES1_0_compatibility,

8519 #endif

8520 #ifdef GL_REGAL_ES1_1_compatibility

8521 &__GLEW_REGAL_ES1_1_compatibility,

8522 #endif

8523 #ifdef GL_REGAL_enable

8524 &__GLEW_REGAL_enable,

8525 #endif

8526 #ifdef GL_REGAL_error_string

8527 &__GLEW_REGAL_error_string,

8528 #endif

8529 #ifdef GL_REGAL_extension_query

8530 &__GLEW_REGAL_extension_query,

8531 #endif

8532 #ifdef GL_REGAL_log

8533 &__GLEW_REGAL_log,

8534 #endif

8535 #ifdef GL_REGAL_proc_address

8536 &__GLEW_REGAL_proc_address,

8537 #endif

8538 #ifdef GL_REND_screen_coordinates

8539 &__GLEW_REND_screen_coordinates,

8540 #endif

8541 #ifdef GL_S3_s3tc

8542 &__GLEW_S3_s3tc,

8543 #endif

8544 #ifdef GL_SGIS_clip_band_hint

8545 &__GLEW_SGIS_clip_band_hint,

8546 #endif

8547 #ifdef GL_SGIS_color_range

8548 &__GLEW_SGIS_color_range,

8549 #endif

8550 #ifdef GL_SGIS_detail_texture

8551 &__GLEW_SGIS_detail_texture,

8552 #endif

8553 #ifdef GL_SGIS_fog_function

8554 &__GLEW_SGIS_fog_function,

8555 #endif

8556 #ifdef GL_SGIS_generate_mipmap

8557 &__GLEW_SGIS_generate_mipmap,

8558 #endif

8559 #ifdef GL_SGIS_line_texgen

8560 &__GLEW_SGIS_line_texgen,

8561 #endif

8562 #ifdef GL_SGIS_multisample

8563 &__GLEW_SGIS_multisample,

8564 #endif

8565 #ifdef GL_SGIS_multitexture

8566 &__GLEW_SGIS_multitexture,

8567 #endif

8568 #ifdef GL_SGIS_pixel_texture

8569 &__GLEW_SGIS_pixel_texture,

8570 #endif

8571 #ifdef GL_SGIS_point_line_texgen

8572 &__GLEW_SGIS_point_line_texgen,

8573 #endif

8574 #ifdef GL_SGIS_shared_multisample

8575 &__GLEW_SGIS_shared_multisample,

8576 #endif

8577 #ifdef GL_SGIS_sharpen_texture

8578 &__GLEW_SGIS_sharpen_texture,

8579 #endif

8580 #ifdef GL_SGIS_texture4D

8581 &__GLEW_SGIS_texture4D,

8582 #endif

8583 #ifdef GL_SGIS_texture_border_clamp

8584 &__GLEW_SGIS_texture_border_clamp,

8585 #endif

8586 #ifdef GL_SGIS_texture_edge_clamp

8587 &__GLEW_SGIS_texture_edge_clamp,

8588 #endif

8589 #ifdef GL_SGIS_texture_filter4

8590 &__GLEW_SGIS_texture_filter4,

8591 #endif

8592 #ifdef GL_SGIS_texture_lod

8593 &__GLEW_SGIS_texture_lod,

8594 #endif

8595 #ifdef GL_SGIS_texture_select

8596 &__GLEW_SGIS_texture_select,

8597 #endif

8598 #ifdef GL_SGIX_async

8599 &__GLEW_SGIX_async,

8600 #endif

8601 #ifdef GL_SGIX_async_histogram

8602 &__GLEW_SGIX_async_histogram,

8603 #endif

8604 #ifdef GL_SGIX_async_pixel

8605 &__GLEW_SGIX_async_pixel,

8606 #endif

8607 #ifdef GL_SGIX_bali_g_instruments

8608 &__GLEW_SGIX_bali_g_instruments,

8609 #endif

8610 #ifdef GL_SGIX_bali_r_instruments

8611 &__GLEW_SGIX_bali_r_instruments,

8612 #endif

8613 #ifdef GL_SGIX_bali_timer_instruments

8614 &__GLEW_SGIX_bali_timer_instruments,

8615 #endif

8616 #ifdef GL_SGIX_blend_alpha_minmax

8617 &__GLEW_SGIX_blend_alpha_minmax,

8618 #endif

8619 #ifdef GL_SGIX_blend_cadd

8620 &__GLEW_SGIX_blend_cadd,

8621 #endif

8622 #ifdef GL_SGIX_blend_cmultiply

8623 &__GLEW_SGIX_blend_cmultiply,

8624 #endif

8625 #ifdef GL_SGIX_calligraphic_fragment

8626 &__GLEW_SGIX_calligraphic_fragment,

8627 #endif

8628 #ifdef GL_SGIX_clipmap

8629 &__GLEW_SGIX_clipmap,

8630 #endif

8631 #ifdef GL_SGIX_color_matrix_accuracy

8632 &__GLEW_SGIX_color_matrix_accuracy,

8633 #endif

8634 #ifdef GL_SGIX_color_table_index_mode

8635 &__GLEW_SGIX_color_table_index_mode,

8636 #endif

8637 #ifdef GL_SGIX_complex_polar

8638 &__GLEW_SGIX_complex_polar,

8639 #endif

8640 #ifdef GL_SGIX_convolution_accuracy

8641 &__GLEW_SGIX_convolution_accuracy,

8642 #endif

8643 #ifdef GL_SGIX_cube_map

8644 &__GLEW_SGIX_cube_map,

8645 #endif

8646 #ifdef GL_SGIX_cylinder_texgen

8647 &__GLEW_SGIX_cylinder_texgen,

8648 #endif

8649 #ifdef GL_SGIX_datapipe

8650 &__GLEW_SGIX_datapipe,

8651 #endif

8652 #ifdef GL_SGIX_decimation

8653 &__GLEW_SGIX_decimation,

8654 #endif

8655 #ifdef GL_SGIX_depth_pass_instrument

8656 &__GLEW_SGIX_depth_pass_instrument,

8657 #endif

8658 #ifdef GL_SGIX_depth_texture

8659 &__GLEW_SGIX_depth_texture,

8660 #endif

8661 #ifdef GL_SGIX_dvc

8662 &__GLEW_SGIX_dvc,

8663 #endif

8664 #ifdef GL_SGIX_flush_raster

8665 &__GLEW_SGIX_flush_raster,

8666 #endif

8667 #ifdef GL_SGIX_fog_blend

8668 &__GLEW_SGIX_fog_blend,

8669 #endif

8670 #ifdef GL_SGIX_fog_factor_to_alpha

8671 &__GLEW_SGIX_fog_factor_to_alpha,

8672 #endif

8673 #ifdef GL_SGIX_fog_layers

8674 &__GLEW_SGIX_fog_layers,

8675 #endif

8676 #ifdef GL_SGIX_fog_offset

8677 &__GLEW_SGIX_fog_offset,

8678 #endif

8679 #ifdef GL_SGIX_fog_patchy

8680 &__GLEW_SGIX_fog_patchy,

8681 #endif

8682 #ifdef GL_SGIX_fog_scale

8683 &__GLEW_SGIX_fog_scale,

8684 #endif

8685 #ifdef GL_SGIX_fog_texture

8686 &__GLEW_SGIX_fog_texture,

8687 #endif

8688 #ifdef GL_SGIX_fragment_lighting_space

8689 &__GLEW_SGIX_fragment_lighting_space,

8690 #endif

8691 #ifdef GL_SGIX_fragment_specular_lighting

8692 &__GLEW_SGIX_fragment_specular_lighting,

8693 #endif

8694 #ifdef GL_SGIX_fragments_instrument

8695 &__GLEW_SGIX_fragments_instrument,

8696 #endif

8697 #ifdef GL_SGIX_framezoom

8698 &__GLEW_SGIX_framezoom,

8699 #endif

8700 #ifdef GL_SGIX_icc_texture

8701 &__GLEW_SGIX_icc_texture,

8702 #endif

8703 #ifdef GL_SGIX_igloo_interface

8704 &__GLEW_SGIX_igloo_interface,

8705 #endif

8706 #ifdef GL_SGIX_image_compression

8707 &__GLEW_SGIX_image_compression,

8708 #endif

8709 #ifdef GL_SGIX_impact_pixel_texture

8710 &__GLEW_SGIX_impact_pixel_texture,

8711 #endif

8712 #ifdef GL_SGIX_instrument_error

8713 &__GLEW_SGIX_instrument_error,

8714 #endif

8715 #ifdef GL_SGIX_interlace

8716 &__GLEW_SGIX_interlace,

8717 #endif

8718 #ifdef GL_SGIX_ir_instrument1

8719 &__GLEW_SGIX_ir_instrument1,

8720 #endif

8721 #ifdef GL_SGIX_line_quality_hint

8722 &__GLEW_SGIX_line_quality_hint,

8723 #endif

8724 #ifdef GL_SGIX_list_priority

8725 &__GLEW_SGIX_list_priority,

8726 #endif

8727 #ifdef GL_SGIX_mpeg1

8728 &__GLEW_SGIX_mpeg1,

8729 #endif

8730 #ifdef GL_SGIX_mpeg2

8731 &__GLEW_SGIX_mpeg2,

8732 #endif

8733 #ifdef GL_SGIX_nonlinear_lighting_pervertex

8734 &__GLEW_SGIX_nonlinear_lighting_pervertex,

8735 #endif

8736 #ifdef GL_SGIX_nurbs_eval

8737 &__GLEW_SGIX_nurbs_eval,

8738 #endif

8739 #ifdef GL_SGIX_occlusion_instrument

8740 &__GLEW_SGIX_occlusion_instrument,

8741 #endif

8742 #ifdef GL_SGIX_packed_6bytes

8743 &__GLEW_SGIX_packed_6bytes,

8744 #endif

8745 #ifdef GL_SGIX_pixel_texture

8746 &__GLEW_SGIX_pixel_texture,

8747 #endif

8748 #ifdef GL_SGIX_pixel_texture_bits

8749 &__GLEW_SGIX_pixel_texture_bits,

8750 #endif

8751 #ifdef GL_SGIX_pixel_texture_lod

8752 &__GLEW_SGIX_pixel_texture_lod,

8753 #endif

8754 #ifdef GL_SGIX_pixel_tiles

8755 &__GLEW_SGIX_pixel_tiles,

8756 #endif

8757 #ifdef GL_SGIX_polynomial_ffd

8758 &__GLEW_SGIX_polynomial_ffd,

8759 #endif

8760 #ifdef GL_SGIX_quad_mesh

8761 &__GLEW_SGIX_quad_mesh,

8762 #endif

8763 #ifdef GL_SGIX_reference_plane

8764 &__GLEW_SGIX_reference_plane,

8765 #endif

8766 #ifdef GL_SGIX_resample

8767 &__GLEW_SGIX_resample,

8768 #endif

8769 #ifdef GL_SGIX_scalebias_hint

8770 &__GLEW_SGIX_scalebias_hint,

8771 #endif

8772 #ifdef GL_SGIX_shadow

8773 &__GLEW_SGIX_shadow,

8774 #endif

8775 #ifdef GL_SGIX_shadow_ambient

8776 &__GLEW_SGIX_shadow_ambient,

8777 #endif

8778 #ifdef GL_SGIX_slim

8779 &__GLEW_SGIX_slim,

8780 #endif

8781 #ifdef GL_SGIX_spotlight_cutoff

8782 &__GLEW_SGIX_spotlight_cutoff,

8783 #endif

8784 #ifdef GL_SGIX_sprite

8785 &__GLEW_SGIX_sprite,

8786 #endif

8787 #ifdef GL_SGIX_subdiv_patch

8788 &__GLEW_SGIX_subdiv_patch,

8789 #endif

8790 #ifdef GL_SGIX_subsample

8791 &__GLEW_SGIX_subsample,

8792 #endif

8793 #ifdef GL_SGIX_tag_sample_buffer

8794 &__GLEW_SGIX_tag_sample_buffer,

8795 #endif

8796 #ifdef GL_SGIX_texture_add_env

8797 &__GLEW_SGIX_texture_add_env,

8798 #endif

8799 #ifdef GL_SGIX_texture_coordinate_clamp

8800 &__GLEW_SGIX_texture_coordinate_clamp,

8801 #endif

8802 #ifdef GL_SGIX_texture_lod_bias

8803 &__GLEW_SGIX_texture_lod_bias,

8804 #endif

8805 #ifdef GL_SGIX_texture_mipmap_anisotropic

8806 &__GLEW_SGIX_texture_mipmap_anisotropic,

8807 #endif

8808 #ifdef GL_SGIX_texture_multi_buffer

8809 &__GLEW_SGIX_texture_multi_buffer,

8810 #endif

8811 #ifdef GL_SGIX_texture_phase

8812 &__GLEW_SGIX_texture_phase,

8813 #endif

8814 #ifdef GL_SGIX_texture_range

8815 &__GLEW_SGIX_texture_range,

8816 #endif

8817 #ifdef GL_SGIX_texture_scale_bias

8818 &__GLEW_SGIX_texture_scale_bias,

8819 #endif

8820 #ifdef GL_SGIX_texture_supersample

8821 &__GLEW_SGIX_texture_supersample,

8822 #endif

8823 #ifdef GL_SGIX_vector_ops

8824 &__GLEW_SGIX_vector_ops,

8825 #endif

8826 #ifdef GL_SGIX_vertex_array_object

8827 &__GLEW_SGIX_vertex_array_object,

8828 #endif

8829 #ifdef GL_SGIX_vertex_preclip

8830 &__GLEW_SGIX_vertex_preclip,

8831 #endif

8832 #ifdef GL_SGIX_vertex_preclip_hint

8833 &__GLEW_SGIX_vertex_preclip_hint,

8834 #endif

8835 #ifdef GL_SGIX_ycrcb

8836 &__GLEW_SGIX_ycrcb,

8837 #endif

8838 #ifdef GL_SGIX_ycrcb_subsample

8839 &__GLEW_SGIX_ycrcb_subsample,

8840 #endif

8841 #ifdef GL_SGIX_ycrcba

8842 &__GLEW_SGIX_ycrcba,

8843 #endif

8844 #ifdef GL_SGI_color_matrix

8845 &__GLEW_SGI_color_matrix,

8846 #endif

8847 #ifdef GL_SGI_color_table

8848 &__GLEW_SGI_color_table,

8849 #endif

8850 #ifdef GL_SGI_complex

8851 &__GLEW_SGI_complex,

8852 #endif

8853 #ifdef GL_SGI_complex_type

8854 &__GLEW_SGI_complex_type,

8855 #endif

8856 #ifdef GL_SGI_fft

8857 &__GLEW_SGI_fft,

8858 #endif

8859 #ifdef GL_SGI_texture_color_table

8860 &__GLEW_SGI_texture_color_table,

8861 #endif

8862 #ifdef GL_SUNX_constant_data

8863 &__GLEW_SUNX_constant_data,

8864 #endif

8865 #ifdef GL_SUN_convolution_border_modes

8866 &__GLEW_SUN_convolution_border_modes,

8867 #endif

8868 #ifdef GL_SUN_global_alpha

8869 &__GLEW_SUN_global_alpha,

8870 #endif

8871 #ifdef GL_SUN_mesh_array

8872 &__GLEW_SUN_mesh_array,

8873 #endif

8874 #ifdef GL_SUN_read_video_pixels

8875 &__GLEW_SUN_read_video_pixels,

8876 #endif

8877 #ifdef GL_SUN_slice_accum

8878 &__GLEW_SUN_slice_accum,

8879 #endif

8880 #ifdef GL_SUN_triangle_list

8881 &__GLEW_SUN_triangle_list,

8882 #endif

8883 #ifdef GL_SUN_vertex

8884 &__GLEW_SUN_vertex,

8885 #endif

8886 #ifdef GL_WIN_phong_shading

8887 &__GLEW_WIN_phong_shading,

8888 #endif

8889 #ifdef GL_WIN_scene_markerXXX

8890 &__GLEW_WIN_scene_markerXXX,

8891 #endif

8892 #ifdef GL_WIN_specular_fog

8893 &__GLEW_WIN_specular_fog,

8894 #endif

8895 #ifdef GL_WIN_swap_hint

8896 &__GLEW_WIN_swap_hint,

8897 #endif

8898 NULL

8899 };

8900 static GLboolean _glewInit_GL_VERSION_1_2 ();

8901 static GLboolean _glewInit_GL_VERSION_1_3 ();

8902 static GLboolean _glewInit_GL_VERSION_1_4 ();

8903 static GLboolean _glewInit_GL_VERSION_1_5 ();

8904 static GLboolean _glewInit_GL_VERSION_2_0 ();

8905 static GLboolean _glewInit_GL_VERSION_2_1 ();

8906 static GLboolean _glewInit_GL_VERSION_3_0 ();

8907 static GLboolean _glewInit_GL_VERSION_3_1 ();

8908 static GLboolean _glewInit_GL_VERSION_3_2 ();

8909 static GLboolean _glewInit_GL_VERSION_3_3 ();

8910 static GLboolean _glewInit_GL_VERSION_4_0 ();

8911 static GLboolean _glewInit_GL_VERSION_4_5 ();

8912 static GLboolean _glewInit_GL_VERSION_4_6 ();

8913 static GLboolean _glewInit_GL_3DFX_tbuffer ();

8914 static GLboolean _glewInit_GL_AMD_debug_output ();

8915 static GLboolean _glewInit_GL_AMD_draw_buffers_blend ();

8916 static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions ();

8917 static GLboolean _glewInit_GL_AMD_interleaved_elements ();

8918 static GLboolean _glewInit_GL_AMD_multi_draw_indirect ();

8919 static GLboolean _glewInit_GL_AMD_name_gen_delete ();

8920 static GLboolean _glewInit_GL_AMD_occlusion_query_event ();

8921 static GLboolean _glewInit_GL_AMD_performance_monitor ();

8922 static GLboolean _glewInit_GL_AMD_sample_positions ();

8923 static GLboolean _glewInit_GL_AMD_sparse_texture ();

8924 static GLboolean _glewInit_GL_AMD_stencil_operation_extended ();

8925 static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator ();

8926 static GLboolean _glewInit_GL_ANGLE_framebuffer_blit ();

8927 static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample ();

8928 static GLboolean _glewInit_GL_ANGLE_instanced_arrays ();

8929 static GLboolean _glewInit_GL_ANGLE_timer_query ();

8930 static GLboolean _glewInit_GL_ANGLE_translated_shader_source ();

8931 static GLboolean _glewInit_GL_APPLE_copy_texture_levels ();

8932 static GLboolean _glewInit_GL_APPLE_element_array ();

8933 static GLboolean _glewInit_GL_APPLE_fence ();

8934 static GLboolean _glewInit_GL_APPLE_flush_buffer_range ();

8935 static GLboolean _glewInit_GL_APPLE_framebuffer_multisample ();

8936 static GLboolean _glewInit_GL_APPLE_object_purgeable ();

8937 static GLboolean _glewInit_GL_APPLE_sync ();

8938 static GLboolean _glewInit_GL_APPLE_texture_range ();

8939 static GLboolean _glewInit_GL_APPLE_vertex_array_object ();

8940 static GLboolean _glewInit_GL_APPLE_vertex_array_range ();

8941 static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators ();

8942 static GLboolean _glewInit_GL_ARB_ES2_compatibility ();

8943 static GLboolean _glewInit_GL_ARB_ES3_1_compatibility ();

8944 static GLboolean _glewInit_GL_ARB_ES3_2_compatibility ();

8945 static GLboolean _glewInit_GL_ARB_base_instance ();

8946 static GLboolean _glewInit_GL_ARB_bindless_texture ();

8947 static GLboolean _glewInit_GL_ARB_blend_func_extended ();

8948 static GLboolean _glewInit_GL_ARB_buffer_storage ();

8949 static GLboolean _glewInit_GL_ARB_cl_event ();

8950 static GLboolean _glewInit_GL_ARB_clear_buffer_object ();

8951 static GLboolean _glewInit_GL_ARB_clear_texture ();

8952 static GLboolean _glewInit_GL_ARB_clip_control ();

8953 static GLboolean _glewInit_GL_ARB_color_buffer_float ();

8954 static GLboolean _glewInit_GL_ARB_compute_shader ();

8955 static GLboolean _glewInit_GL_ARB_compute_variable_group_size ();

8956 static GLboolean _glewInit_GL_ARB_copy_buffer ();

8957 static GLboolean _glewInit_GL_ARB_copy_image ();

8958 static GLboolean _glewInit_GL_ARB_debug_output ();

8959 static GLboolean _glewInit_GL_ARB_direct_state_access ();

8960 static GLboolean _glewInit_GL_ARB_draw_buffers ();

8961 static GLboolean _glewInit_GL_ARB_draw_buffers_blend ();

8962 static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex ();

8963 static GLboolean _glewInit_GL_ARB_draw_indirect ();

8964 static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments ();

8965 static GLboolean _glewInit_GL_ARB_framebuffer_object ();

8966 static GLboolean _glewInit_GL_ARB_geometry_shader4 ();

8967 static GLboolean _glewInit_GL_ARB_get_program_binary ();

8968 static GLboolean _glewInit_GL_ARB_get_texture_sub_image ();

8969 static GLboolean _glewInit_GL_ARB_gl_spirv ();

8970 static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 ();

8971 static GLboolean _glewInit_GL_ARB_gpu_shader_int64 ();

8972 static GLboolean _glewInit_GL_ARB_imaging ();

8973 static GLboolean _glewInit_GL_ARB_indirect_parameters ();

8974 static GLboolean _glewInit_GL_ARB_instanced_arrays ();

8975 static GLboolean _glewInit_GL_ARB_internalformat_query ();

8976 static GLboolean _glewInit_GL_ARB_internalformat_query2 ();

8977 static GLboolean _glewInit_GL_ARB_invalidate_subdata ();

8978 static GLboolean _glewInit_GL_ARB_map_buffer_range ();

8979 static GLboolean _glewInit_GL_ARB_matrix_palette ();

8980 static GLboolean _glewInit_GL_ARB_multi_bind ();

8981 static GLboolean _glewInit_GL_ARB_multi_draw_indirect ();

8982 static GLboolean _glewInit_GL_ARB_multisample ();

8983 static GLboolean _glewInit_GL_ARB_multitexture ();

8984 static GLboolean _glewInit_GL_ARB_occlusion_query ();

8985 static GLboolean _glewInit_GL_ARB_parallel_shader_compile ();

8986 static GLboolean _glewInit_GL_ARB_point_parameters ();

8987 static GLboolean _glewInit_GL_ARB_polygon_offset_clamp ();

8988 static GLboolean _glewInit_GL_ARB_program_interface_query ();

8989 static GLboolean _glewInit_GL_ARB_provoking_vertex ();

8990 static GLboolean _glewInit_GL_ARB_robustness ();

8991 static GLboolean _glewInit_GL_ARB_sample_locations ();

8992 static GLboolean _glewInit_GL_ARB_sample_shading ();

8993 static GLboolean _glewInit_GL_ARB_sampler_objects ();

8994 static GLboolean _glewInit_GL_ARB_separate_shader_objects ();

8995 static GLboolean _glewInit_GL_ARB_shader_atomic_counters ();

8996 static GLboolean _glewInit_GL_ARB_shader_image_load_store ();

8997 static GLboolean _glewInit_GL_ARB_shader_objects ();

8998 static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object ();

8999 static GLboolean _glewInit_GL_ARB_shader_subroutine ();

9000 static GLboolean _glewInit_GL_ARB_shading_language_include ();

9001 static GLboolean _glewInit_GL_ARB_sparse_buffer ();

9002 static GLboolean _glewInit_GL_ARB_sparse_texture ();

9003 static GLboolean _glewInit_GL_ARB_sync ();

9004 static GLboolean _glewInit_GL_ARB_tessellation_shader ();

9005 static GLboolean _glewInit_GL_ARB_texture_barrier ();

9006 static GLboolean _glewInit_GL_ARB_texture_buffer_object ();

9007 static GLboolean _glewInit_GL_ARB_texture_buffer_range ();

9008 static GLboolean _glewInit_GL_ARB_texture_compression ();

9009 static GLboolean _glewInit_GL_ARB_texture_multisample ();

9010 static GLboolean _glewInit_GL_ARB_texture_storage ();

9011 static GLboolean _glewInit_GL_ARB_texture_storage_multisample ();

9012 static GLboolean _glewInit_GL_ARB_texture_view ();

9013 static GLboolean _glewInit_GL_ARB_timer_query ();

9014 static GLboolean _glewInit_GL_ARB_transform_feedback2 ();

9015 static GLboolean _glewInit_GL_ARB_transform_feedback3 ();

9016 static GLboolean _glewInit_GL_ARB_transform_feedback_instanced ();

9017 static GLboolean _glewInit_GL_ARB_transpose_matrix ();

9018 static GLboolean _glewInit_GL_ARB_uniform_buffer_object ();

9019 static GLboolean _glewInit_GL_ARB_vertex_array_object ();

9020 static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit ();

9021 static GLboolean _glewInit_GL_ARB_vertex_attrib_binding ();

9022 static GLboolean _glewInit_GL_ARB_vertex_blend ();

9023 static GLboolean _glewInit_GL_ARB_vertex_buffer_object ();

9024 static GLboolean _glewInit_GL_ARB_vertex_program ();

9025 static GLboolean _glewInit_GL_ARB_vertex_shader ();

9026 static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev ();

9027 static GLboolean _glewInit_GL_ARB_viewport_array ();

9028 static GLboolean _glewInit_GL_ARB_window_pos ();

9029 static GLboolean _glewInit_GL_ATI_draw_buffers ();

9030 static GLboolean _glewInit_GL_ATI_element_array ();

9031 static GLboolean _glewInit_GL_ATI_envmap_bumpmap ();

9032 static GLboolean _glewInit_GL_ATI_fragment_shader ();

9033 static GLboolean _glewInit_GL_ATI_map_object_buffer ();

9034 static GLboolean _glewInit_GL_ATI_pn_triangles ();

9035 static GLboolean _glewInit_GL_ATI_separate_stencil ();

9036 static GLboolean _glewInit_GL_ATI_vertex_array_object ();

9037 static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object ();

9038 static GLboolean _glewInit_GL_ATI_vertex_streams ();

9039 static GLboolean _glewInit_GL_EXT_base_instance ();

9040 static GLboolean _glewInit_GL_EXT_bindable_uniform ();

9041 static GLboolean _glewInit_GL_EXT_blend_color ();

9042 static GLboolean _glewInit_GL_EXT_blend_equation_separate ();

9043 static GLboolean _glewInit_GL_EXT_blend_func_extended ();

9044 static GLboolean _glewInit_GL_EXT_blend_func_separate ();

9045 static GLboolean _glewInit_GL_EXT_blend_minmax ();

9046 static GLboolean _glewInit_GL_EXT_buffer_storage ();

9047 static GLboolean _glewInit_GL_EXT_clear_texture ();

9048 static GLboolean _glewInit_GL_EXT_color_subtable ();

9049 static GLboolean _glewInit_GL_EXT_compiled_vertex_array ();

9050 static GLboolean _glewInit_GL_EXT_convolution ();

9051 static GLboolean _glewInit_GL_EXT_coordinate_frame ();

9052 static GLboolean _glewInit_GL_EXT_copy_image ();

9053 static GLboolean _glewInit_GL_EXT_copy_texture ();

9054 static GLboolean _glewInit_GL_EXT_cull_vertex ();

9055 static GLboolean _glewInit_GL_EXT_debug_label ();

9056 static GLboolean _glewInit_GL_EXT_debug_marker ();

9057 static GLboolean _glewInit_GL_EXT_depth_bounds_test ();

9058 static GLboolean _glewInit_GL_EXT_direct_state_access ();

9059 static GLboolean _glewInit_GL_EXT_discard_framebuffer ();

9060 static GLboolean _glewInit_GL_EXT_draw_buffers ();

9061 static GLboolean _glewInit_GL_EXT_draw_buffers2 ();

9062 static GLboolean _glewInit_GL_EXT_draw_buffers_indexed ();

9063 static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex ();

9064 static GLboolean _glewInit_GL_EXT_draw_instanced ();

9065 static GLboolean _glewInit_GL_EXT_draw_range_elements ();

9066 static GLboolean _glewInit_GL_EXT_external_buffer ();

9067 static GLboolean _glewInit_GL_EXT_fog_coord ();

9068 static GLboolean _glewInit_GL_EXT_fragment_lighting ();

9069 static GLboolean _glewInit_GL_EXT_framebuffer_blit ();

9070 static GLboolean _glewInit_GL_EXT_framebuffer_multisample ();

9071 static GLboolean _glewInit_GL_EXT_framebuffer_object ();

9072 static GLboolean _glewInit_GL_EXT_geometry_shader4 ();

9073 static GLboolean _glewInit_GL_EXT_gpu_program_parameters ();

9074 static GLboolean _glewInit_GL_EXT_gpu_shader4 ();

9075 static GLboolean _glewInit_GL_EXT_histogram ();

9076 static GLboolean _glewInit_GL_EXT_index_func ();

9077 static GLboolean _glewInit_GL_EXT_index_material ();

9078 static GLboolean _glewInit_GL_EXT_instanced_arrays ();

9079 static GLboolean _glewInit_GL_EXT_light_texture ();

9080 static GLboolean _glewInit_GL_EXT_map_buffer_range ();

9081 static GLboolean _glewInit_GL_EXT_memory_object ();

9082 static GLboolean _glewInit_GL_EXT_memory_object_fd ();

9083 static GLboolean _glewInit_GL_EXT_memory_object_win32 ();

9084 static GLboolean _glewInit_GL_EXT_multi_draw_arrays ();

9085 static GLboolean _glewInit_GL_EXT_multi_draw_indirect ();

9086 static GLboolean _glewInit_GL_EXT_multisample ();

9087 static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture ();

9088 static GLboolean _glewInit_GL_EXT_multiview_draw_buffers ();

9089 static GLboolean _glewInit_GL_EXT_paletted_texture ();

9090 static GLboolean _glewInit_GL_EXT_pixel_transform ();

9091 static GLboolean _glewInit_GL_EXT_point_parameters ();

9092 static GLboolean _glewInit_GL_EXT_polygon_offset ();

9093 static GLboolean _glewInit_GL_EXT_polygon_offset_clamp ();

9094 static GLboolean _glewInit_GL_EXT_provoking_vertex ();

9095 static GLboolean _glewInit_GL_EXT_raster_multisample ();

9096 static GLboolean _glewInit_GL_EXT_scene_marker ();

9097 static GLboolean _glewInit_GL_EXT_secondary_color ();

9098 static GLboolean _glewInit_GL_EXT_semaphore ();

9099 static GLboolean _glewInit_GL_EXT_semaphore_fd ();

9100 static GLboolean _glewInit_GL_EXT_semaphore_win32 ();

9101 static GLboolean _glewInit_GL_EXT_separate_shader_objects ();

9102 static GLboolean _glewInit_GL_EXT_shader_image_load_store ();

9103 static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 ();

9104 static GLboolean _glewInit_GL_EXT_sparse_texture ();

9105 static GLboolean _glewInit_GL_EXT_stencil_two_side ();

9106 static GLboolean _glewInit_GL_EXT_subtexture ();

9107 static GLboolean _glewInit_GL_EXT_texture3D ();

9108 static GLboolean _glewInit_GL_EXT_texture_array ();

9109 static GLboolean _glewInit_GL_EXT_texture_buffer_object ();

9110 static GLboolean _glewInit_GL_EXT_texture_integer ();

9111 static GLboolean _glewInit_GL_EXT_texture_object ();

9112 static GLboolean _glewInit_GL_EXT_texture_perturb_normal ();

9113 static GLboolean _glewInit_GL_EXT_texture_storage ();

9114 static GLboolean _glewInit_GL_EXT_texture_view ();

9115 static GLboolean _glewInit_GL_EXT_timer_query ();

9116 static GLboolean _glewInit_GL_EXT_transform_feedback ();

9117 static GLboolean _glewInit_GL_EXT_vertex_array ();

9118 static GLboolean _glewInit_GL_EXT_vertex_array_setXXX ();

9119 static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit ();

9120 static GLboolean _glewInit_GL_EXT_vertex_shader ();

9121 static GLboolean _glewInit_GL_EXT_vertex_weighting ();

9122 static GLboolean _glewInit_GL_EXT_win32_keyed_mutex ();

9123 static GLboolean _glewInit_GL_EXT_window_rectangles ();

9124 static GLboolean _glewInit_GL_EXT_x11_sync_object ();

9125 static GLboolean _glewInit_GL_GREMEDY_frame_terminator ();

9126 static GLboolean _glewInit_GL_GREMEDY_string_marker ();

9127 static GLboolean _glewInit_GL_HP_image_transform ();

9128 static GLboolean _glewInit_GL_IBM_multimode_draw_arrays ();

9129 static GLboolean _glewInit_GL_IBM_vertex_array_lists ();

9130 static GLboolean _glewInit_GL_INTEL_map_texture ();

9131 static GLboolean _glewInit_GL_INTEL_parallel_arrays ();

9132 static GLboolean _glewInit_GL_INTEL_performance_query ();

9133 static GLboolean _glewInit_GL_INTEL_texture_scissor ();

9134 static GLboolean _glewInit_GL_KHR_blend_equation_advanced ();

9135 static GLboolean _glewInit_GL_KHR_debug ();

9136 static GLboolean _glewInit_GL_KHR_parallel_shader_compile ();

9137 static GLboolean _glewInit_GL_KHR_robustness ();

9138 static GLboolean _glewInit_GL_KTX_buffer_region ();

9139 static GLboolean _glewInit_GL_MESA_resize_buffers ();

9140 static GLboolean _glewInit_GL_MESA_window_pos ();

9141 static GLboolean _glewInit_GL_NVX_conditional_render ();

9142 static GLboolean _glewInit_GL_NVX_linked_gpu_multicast ();

9143 static GLboolean _glewInit_GL_NV_3dvision_settings ();

9144 static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect ();

9145 static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count ();

9146 static GLboolean _glewInit_GL_NV_bindless_texture ();

9147 static GLboolean _glewInit_GL_NV_blend_equation_advanced ();

9148 static GLboolean _glewInit_GL_NV_clip_space_w_scaling ();

9149 static GLboolean _glewInit_GL_NV_command_list ();

9150 static GLboolean _glewInit_GL_NV_conditional_render ();

9151 static GLboolean _glewInit_GL_NV_conservative_raster ();

9152 static GLboolean _glewInit_GL_NV_conservative_raster_dilate ();

9153 static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles ();

9154 static GLboolean _glewInit_GL_NV_copy_buffer ();

9155 static GLboolean _glewInit_GL_NV_copy_image ();

9156 static GLboolean _glewInit_GL_NV_depth_buffer_float ();

9157 static GLboolean _glewInit_GL_NV_draw_buffers ();

9158 static GLboolean _glewInit_GL_NV_draw_instanced ();

9159 static GLboolean _glewInit_GL_NV_draw_texture ();

9160 static GLboolean _glewInit_GL_NV_draw_vulkan_image ();

9161 static GLboolean _glewInit_GL_NV_evaluators ();

9162 static GLboolean _glewInit_GL_NV_explicit_multisample ();

9163 static GLboolean _glewInit_GL_NV_fence ();

9164 static GLboolean _glewInit_GL_NV_fragment_coverage_to_color ();

9165 static GLboolean _glewInit_GL_NV_fragment_program ();

9166 static GLboolean _glewInit_GL_NV_framebuffer_blit ();

9167 static GLboolean _glewInit_GL_NV_framebuffer_multisample ();

9168 static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage ();

9169 static GLboolean _glewInit_GL_NV_geometry_program4 ();

9170 static GLboolean _glewInit_GL_NV_gpu_multicast ();

9171 static GLboolean _glewInit_GL_NV_gpu_program4 ();

9172 static GLboolean _glewInit_GL_NV_gpu_shader5 ();

9173 static GLboolean _glewInit_GL_NV_half_float ();

9174 static GLboolean _glewInit_GL_NV_instanced_arrays ();

9175 static GLboolean _glewInit_GL_NV_internalformat_sample_query ();

9176 static GLboolean _glewInit_GL_NV_non_square_matrices ();

9177 static GLboolean _glewInit_GL_NV_occlusion_query ();

9178 static GLboolean _glewInit_GL_NV_parameter_buffer_object ();

9179 static GLboolean _glewInit_GL_NV_path_rendering ();

9180 static GLboolean _glewInit_GL_NV_pixel_data_range ();

9181 static GLboolean _glewInit_GL_NV_point_sprite ();

9182 static GLboolean _glewInit_GL_NV_polygon_mode ();

9183 static GLboolean _glewInit_GL_NV_present_video ();

9184 static GLboolean _glewInit_GL_NV_primitive_restart ();

9185 static GLboolean _glewInit_GL_NV_register_combiners ();

9186 static GLboolean _glewInit_GL_NV_register_combiners2 ();

9187 static GLboolean _glewInit_GL_NV_sample_locations ();

9188 static GLboolean _glewInit_GL_NV_shader_buffer_load ();

9189 static GLboolean _glewInit_GL_NV_texture_array ();

9190 static GLboolean _glewInit_GL_NV_texture_barrier ();

9191 static GLboolean _glewInit_GL_NV_texture_multisample ();

9192 static GLboolean _glewInit_GL_NV_transform_feedback ();

9193 static GLboolean _glewInit_GL_NV_transform_feedback2 ();

9194 static GLboolean _glewInit_GL_NV_vdpau_interop ();

9195 static GLboolean _glewInit_GL_NV_vertex_array_range ();

9196 static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit ();

9197 static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory ();

9198 static GLboolean _glewInit_GL_NV_vertex_program ();

9199 static GLboolean _glewInit_GL_NV_video_capture ();

9200 static GLboolean _glewInit_GL_NV_viewport_array ();

9201 static GLboolean _glewInit_GL_NV_viewport_swizzle ();

9202 static GLboolean _glewInit_GL_OVR_multiview ();

9203 static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture ();

9204 static GLboolean _glewInit_GL_QCOM_alpha_test ();

9205 static GLboolean _glewInit_GL_QCOM_driver_control ();

9206 static GLboolean _glewInit_GL_QCOM_extended_get ();

9207 static GLboolean _glewInit_GL_QCOM_extended_get2 ();

9208 static GLboolean _glewInit_GL_QCOM_framebuffer_foveated ();

9209 static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent ();

9210 static GLboolean _glewInit_GL_QCOM_tiled_rendering ();

9211 static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility ();

9212 static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility ();

9213 static GLboolean _glewInit_GL_REGAL_error_string ();

9214 static GLboolean _glewInit_GL_REGAL_extension_query ();

9215 static GLboolean _glewInit_GL_REGAL_log ();

9216 static GLboolean _glewInit_GL_REGAL_proc_address ();

9217 static GLboolean _glewInit_GL_SGIS_detail_texture ();

9218 static GLboolean _glewInit_GL_SGIS_fog_function ();

9219 static GLboolean _glewInit_GL_SGIS_multisample ();

9220 static GLboolean _glewInit_GL_SGIS_multitexture ();

9221 static GLboolean _glewInit_GL_SGIS_shared_multisample ();

9222 static GLboolean _glewInit_GL_SGIS_sharpen_texture ();

9223 static GLboolean _glewInit_GL_SGIS_texture4D ();

9224 static GLboolean _glewInit_GL_SGIS_texture_filter4 ();

9225 static GLboolean _glewInit_GL_SGIX_async ();

9226 static GLboolean _glewInit_GL_SGIX_datapipe ();

9227 static GLboolean _glewInit_GL_SGIX_flush_raster ();

9228 static GLboolean _glewInit_GL_SGIX_fog_layers ();

9229 static GLboolean _glewInit_GL_SGIX_fog_texture ();

9230 static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting ();

9231 static GLboolean _glewInit_GL_SGIX_framezoom ();

9232 static GLboolean _glewInit_GL_SGIX_igloo_interface ();

9233 static GLboolean _glewInit_GL_SGIX_mpeg1 ();

9234 static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex ();

9235 static GLboolean _glewInit_GL_SGIX_pixel_texture ();

9236 static GLboolean _glewInit_GL_SGIX_polynomial_ffd ();

9237 static GLboolean _glewInit_GL_SGIX_quad_mesh ();

9238 static GLboolean _glewInit_GL_SGIX_reference_plane ();

9239 static GLboolean _glewInit_GL_SGIX_sprite ();

9240 static GLboolean _glewInit_GL_SGIX_tag_sample_buffer ();

9241 static GLboolean _glewInit_GL_SGIX_vector_ops ();

9242 static GLboolean _glewInit_GL_SGIX_vertex_array_object ();

9243 static GLboolean _glewInit_GL_SGI_color_table ();

9244 static GLboolean _glewInit_GL_SGI_fft ();

9245 static GLboolean _glewInit_GL_SUNX_constant_data ();

9246 static GLboolean _glewInit_GL_SUN_global_alpha ();

9247 static GLboolean _glewInit_GL_SUN_read_video_pixels ();

9248 static GLboolean _glewInit_GL_SUN_triangle_list ();

9249 static GLboolean _glewInit_GL_SUN_vertex ();

9250 static GLboolean _glewInit_GL_WIN_swap_hint ();

9251

9252 #ifdef GL_VERSION_1_2

9253

9254 static GLboolean _glewInit_GL_VERSION_1_2 ()

9255 {

9256 GLboolean r = GL_FALSE;

9257

9258 r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r;

9259 r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r;

9260 r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r;

9261 r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r;

9262

9263 return r;

9264 }

9265

9266 #endif /* GL_VERSION_1_2 */

9267

9268 #ifdef GL_VERSION_1_3

9269

9270 static GLboolean _glewInit_GL_VERSION_1_3 ()

9271 {

9272 GLboolean r = GL_FALSE;

9273

9274 r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r;

9275 r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r;

9276 r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r;

9277 r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r;

9278 r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r;

9279 r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r;

9280 r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r;

9281 r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r;

9282 r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r;

9283 r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r;

9284 r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r;

9285 r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r;

9286 r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r;

9287 r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r;

9288 r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r;

9289 r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r;

9290 r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r;

9291 r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r;

9292 r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r;

9293 r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r;

9294 r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r;

9295 r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r;

9296 r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r;

9297 r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r;

9298 r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r;

9299 r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r;

9300 r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r;

9301 r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r;

9302 r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r;

9303 r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r;

9304 r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r;

9305 r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r;

9306 r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r;

9307 r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r;

9308 r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r;

9309 r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r;

9310 r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r;

9311 r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r;

9312 r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r;

9313 r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r;

9314 r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r;

9315 r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r;

9316 r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r;

9317 r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r;

9318 r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r;

9319 r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r;

9320

9321 return r;

9322 }

9323

9324 #endif /* GL_VERSION_1_3 */

9325

9326 #ifdef GL_VERSION_1_4

9327

9328 static GLboolean _glewInit_GL_VERSION_1_4 ()

9329 {

9330 GLboolean r = GL_FALSE;

9331

9332 r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r;

9333 r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;

9334 r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r;

9335 r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r;

9336 r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r;

9337 r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r;

9338 r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r;

9339 r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r;

9340 r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r;

9341 r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r;

9342 r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r;

9343 r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r;

9344 r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r;

9345 r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r;

9346 r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r;

9347 r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r;

9348 r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r;

9349 r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r;

9350 r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r;

9351 r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r;

9352 r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r;

9353 r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r;

9354 r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r;

9355 r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r;

9356 r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r;

9357 r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r;

9358 r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r;

9359 r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r;

9360 r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r;

9361 r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r;

9362 r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r;

9363 r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r;

9364 r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r;

9365 r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r;

9366 r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r;

9367 r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r;

9368 r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r;

9369 r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r;

9370 r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r;

9371 r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r;

9372 r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r;

9373 r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r;

9374 r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r;

9375 r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r;

9376 r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r;

9377 r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r;

9378 r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r;

9379

9380 return r;

9381 }

9382

9383 #endif /* GL_VERSION_1_4 */

9384

9385 #ifdef GL_VERSION_1_5

9386

9387 static GLboolean _glewInit_GL_VERSION_1_5 ()

9388 {

9389 GLboolean r = GL_FALSE;

9390

9391 r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r;

9392 r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r;

9393 r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r;

9394 r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r;

9395 r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r;

9396 r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r;

9397 r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r;

9398 r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r;

9399 r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r;

9400 r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r;

9401 r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r;

9402 r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r;

9403 r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r;

9404 r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r;

9405 r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r;

9406 r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r;

9407 r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r;

9408 r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r;

9409 r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r;

9410

9411 return r;

9412 }

9413

9414 #endif /* GL_VERSION_1_5 */

9415

9416 #ifdef GL_VERSION_2_0

9417

9418 static GLboolean _glewInit_GL_VERSION_2_0 ()

9419 {

9420 GLboolean r = GL_FALSE;

9421

9422 r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r;

9423 r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r;

9424 r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r;

9425 r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r;

9426 r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r;

9427 r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r;

9428 r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r;

9429 r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r;

9430 r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r;

9431 r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r;

9432 r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r;

9433 r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r;

9434 r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r;

9435 r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r;

9436 r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r;

9437 r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r;

9438 r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r;

9439 r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r;

9440 r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r;

9441 r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r;

9442 r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r;

9443 r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r;

9444 r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r;

9445 r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r;

9446 r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r;

9447 r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r;

9448 r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r;

9449 r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r;

9450 r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r;

9451 r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r;

9452 r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r;

9453 r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r;

9454 r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r;

9455 r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r;

9456 r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r;

9457 r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r;

9458 r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r;

9459 r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r;

9460 r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r;

9461 r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r;

9462 r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r;

9463 r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r;

9464 r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r;

9465 r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r;

9466 r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r;

9467 r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r;

9468 r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r;

9469 r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r;

9470 r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r;

9471 r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r;

9472 r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r;

9473 r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r;

9474 r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r;

9475 r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r;

9476 r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r;

9477 r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r;

9478 r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r;

9479 r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r;

9480 r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r;

9481 r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r;

9482 r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r;

9483 r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r;

9484 r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r;

9485 r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r;

9486 r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r;

9487 r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r;

9488 r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r;

9489 r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r;

9490 r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r;

9491 r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r;

9492 r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r;

9493 r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r;

9494 r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r;

9495 r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r;

9496 r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r;

9497 r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r;

9498 r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r;

9499 r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r;

9500 r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r;

9501 r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r;

9502 r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r;

9503 r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r;

9504 r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r;

9505 r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r;

9506 r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r;

9507 r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r;

9508 r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r;

9509 r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r;

9510 r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r;

9511 r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r;

9512 r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r;

9513 r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r;

9514 r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r;

9515

9516 return r;

9517 }

9518

9519 #endif /* GL_VERSION_2_0 */

9520

9521 #ifdef GL_VERSION_2_1

9522

9523 static GLboolean _glewInit_GL_VERSION_2_1 ()

9524 {

9525 GLboolean r = GL_FALSE;

9526

9527 r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r;

9528 r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r;

9529 r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r;

9530 r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r;

9531 r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r;

9532 r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r;

9533

9534 return r;

9535 }

9536

9537 #endif /* GL_VERSION_2_1 */

9538

9539 #ifdef GL_VERSION_3_0

9540

9541 static GLboolean _glewInit_GL_VERSION_3_0 ()

9542 {

9543 GLboolean r = GL_FALSE;

9544

9545 r = _glewInit_GL_ARB_framebuffer_object() || r;

9546 r = _glewInit_GL_ARB_map_buffer_range() || r;

9547 r = _glewInit_GL_ARB_uniform_buffer_object() || r;

9548 r = _glewInit_GL_ARB_vertex_array_object() || r;

9549

9550 r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r;

9551 r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r;

9552 r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r;

9553 r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r;

9554 r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r;

9555 r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r;

9556 r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r;

9557 r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r;

9558 r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r;

9559 r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r;

9560 r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r;

9561 r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r;

9562 r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r;

9563 r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r;

9564 r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r;

9565 r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r;

9566 r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r;

9567 r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r;

9568 r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r;

9569 r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r;

9570 r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r;

9571 r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r;

9572 r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r;

9573 r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r;

9574 r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r;

9575 r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r;

9576 r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r;

9577 r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r;

9578 r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r;

9579 r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r;

9580 r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r;

9581 r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r;

9582 r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r;

9583 r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r;

9584 r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r;

9585 r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r;

9586 r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r;

9587 r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r;

9588 r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r;

9589 r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r;

9590 r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r;

9591 r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r;

9592 r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r;

9593 r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r;

9594 r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r;

9595 r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r;

9596 r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r;

9597 r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r;

9598 r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r;

9599 r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r;

9600 r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r;

9601 r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r;

9602 r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r;

9603 r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r;

9604 r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r;

9605

9606 return r;

9607 }

9608

9609 #endif /* GL_VERSION_3_0 */

9610

9611 #ifdef GL_VERSION_3_1

9612

9613 static GLboolean _glewInit_GL_VERSION_3_1 ()

9614 {

9615 GLboolean r = GL_FALSE;

9616

9617 r = _glewInit_GL_ARB_copy_buffer() || r;

9618

9619 r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r;

9620 r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r;

9621 r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r;

9622 r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r;

9623

9624 return r;

9625 }

9626

9627 #endif /* GL_VERSION_3_1 */

9628

9629 #ifdef GL_VERSION_3_2

9630

9631 static GLboolean _glewInit_GL_VERSION_3_2 ()

9632 {

9633 GLboolean r = GL_FALSE;

9634

9635 r = _glewInit_GL_ARB_draw_elements_base_vertex() || r;

9636 r = _glewInit_GL_ARB_provoking_vertex() || r;

9637 r = _glewInit_GL_ARB_sync() || r;

9638 r = _glewInit_GL_ARB_texture_multisample() || r;

9639

9640 r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r;

9641 r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r;

9642 r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r;

9643

9644 return r;

9645 }

9646

9647 #endif /* GL_VERSION_3_2 */

9648

9649 #ifdef GL_VERSION_3_3

9650

9651 static GLboolean _glewInit_GL_VERSION_3_3 ()

9652 {

9653 GLboolean r = GL_FALSE;

9654

9655 r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r;

9656

9657 return r;

9658 }

9659

9660 #endif /* GL_VERSION_3_3 */

9661

9662 #ifdef GL_VERSION_4_0

9663

9664 static GLboolean _glewInit_GL_VERSION_4_0 ()

9665 {

9666 GLboolean r = GL_FALSE;

9667

9668 r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r;

9669 r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r;

9670 r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r;

9671 r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r;

9672 r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r;

9673

9674 return r;

9675 }

9676

9677 #endif /* GL_VERSION_4_0 */

9678

9679 #ifdef GL_VERSION_4_5

9680

9681 static GLboolean _glewInit_GL_VERSION_4_5 ()

9682 {

9683 GLboolean r = GL_FALSE;

9684

9685 r = ((glGetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatus")) == NULL) || r;

9686 r = ((glGetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImage")) == NULL) || r;

9687 r = ((glGetnTexImage = (PFNGLGETNTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImage")) == NULL) || r;

9688 r = ((glGetnUniformdv = (PFNGLGETNUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdv")) == NULL) || r;

9689

9690 return r;

9691 }

9692

9693 #endif /* GL_VERSION_4_5 */

9694

9695 #ifdef GL_VERSION_4_6

9696

9697 static GLboolean _glewInit_GL_VERSION_4_6 ()

9698 {

9699 GLboolean r = GL_FALSE;

9700

9701 r = ((glMultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectCount")) == NULL) || r;

9702 r = ((glMultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectCount")) == NULL) || r;

9703 r = ((glSpecializeShader = (PFNGLSPECIALIZESHADERPROC)glewGetProcAddress((const GLubyte*)"glSpecializeShader")) == NULL) || r;

9704

9705 return r;

9706 }

9707

9708 #endif /* GL_VERSION_4_6 */

9709

9710 #ifdef GL_3DFX_tbuffer

9711

9712 static GLboolean _glewInit_GL_3DFX_tbuffer ()

9713 {

9714 GLboolean r = GL_FALSE;

9715

9716 r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r;

9717

9718 return r;

9719 }

9720

9721 #endif /* GL_3DFX_tbuffer */

9722

9723 #ifdef GL_AMD_debug_output

9724

9725 static GLboolean _glewInit_GL_AMD_debug_output ()

9726 {

9727 GLboolean r = GL_FALSE;

9728

9729 r = ((glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackAMD")) == NULL) || r;

9730 r = ((glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageEnableAMD")) == NULL) || r;

9731 r = ((glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertAMD")) == NULL) || r;

9732 r = ((glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogAMD")) == NULL) || r;

9733

9734 return r;

9735 }

9736

9737 #endif /* GL_AMD_debug_output */

9738

9739 #ifdef GL_AMD_draw_buffers_blend

9740

9741 static GLboolean _glewInit_GL_AMD_draw_buffers_blend ()

9742 {

9743 GLboolean r = GL_FALSE;

9744

9745 r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r;

9746 r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r;

9747 r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r;

9748 r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r;

9749

9750 return r;

9751 }

9752

9753 #endif /* GL_AMD_draw_buffers_blend */

9754

9755 #ifdef GL_AMD_framebuffer_sample_positions

9756

9757 static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions ()

9758 {

9759 GLboolean r = GL_FALSE;

9760

9761 r = ((glFramebufferSamplePositionsfvAMD = (PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSamplePositionsfvAMD")) == NULL) || r;

9762 r = ((glGetFramebufferParameterfvAMD = (PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterfvAMD")) == NULL) || r;

9763 r = ((glGetNamedFramebufferParameterfvAMD = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameterfvAMD")) == NULL) || r;

9764 r = ((glNamedFramebufferSamplePositionsfvAMD = (PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSamplePositionsfvAMD")) == NULL) || r;

9765

9766 return r;

9767 }

9768

9769 #endif /* GL_AMD_framebuffer_sample_positions */

9770

9771 #ifdef GL_AMD_interleaved_elements

9772

9773 static GLboolean _glewInit_GL_AMD_interleaved_elements ()

9774 {

9775 GLboolean r = GL_FALSE;

9776

9777 r = ((glVertexAttribParameteriAMD = (PFNGLVERTEXATTRIBPARAMETERIAMDPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribParameteriAMD")) == NULL) || r;

9778

9779 return r;

9780 }

9781

9782 #endif /* GL_AMD_interleaved_elements */

9783

9784 #ifdef GL_AMD_multi_draw_indirect

9785

9786 static GLboolean _glewInit_GL_AMD_multi_draw_indirect ()

9787 {

9788 GLboolean r = GL_FALSE;

9789

9790 r = ((glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectAMD")) == NULL) || r;

9791 r = ((glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectAMD")) == NULL) || r;

9792

9793 return r;

9794 }

9795

9796 #endif /* GL_AMD_multi_draw_indirect */

9797

9798 #ifdef GL_AMD_name_gen_delete

9799

9800 static GLboolean _glewInit_GL_AMD_name_gen_delete ()

9801 {

9802 GLboolean r = GL_FALSE;

9803

9804 r = ((glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamesAMD")) == NULL) || r;

9805 r = ((glGenNamesAMD = (PFNGLGENNAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glGenNamesAMD")) == NULL) || r;

9806 r = ((glIsNameAMD = (PFNGLISNAMEAMDPROC)glewGetProcAddress((const GLubyte*)"glIsNameAMD")) == NULL) || r;

9807

9808 return r;

9809 }

9810

9811 #endif /* GL_AMD_name_gen_delete */

9812

9813 #ifdef GL_AMD_occlusion_query_event

9814

9815 static GLboolean _glewInit_GL_AMD_occlusion_query_event ()

9816 {

9817 GLboolean r = GL_FALSE;

9818

9819 r = ((glQueryObjectParameteruiAMD = (PFNGLQUERYOBJECTPARAMETERUIAMDPROC)glewGetProcAddress((const GLubyte*)"glQueryObjectParameteruiAMD")) == NULL) || r;

9820

9821 return r;

9822 }

9823

9824 #endif /* GL_AMD_occlusion_query_event */

9825

9826 #ifdef GL_AMD_performance_monitor

9827

9828 static GLboolean _glewInit_GL_AMD_performance_monitor ()

9829 {

9830 GLboolean r = GL_FALSE;

9831

9832 r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r;

9833 r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r;

9834 r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r;

9835 r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r;

9836 r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r;

9837 r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r;

9838 r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r;

9839 r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r;

9840 r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r;

9841 r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r;

9842 r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r;

9843

9844 return r;

9845 }

9846

9847 #endif /* GL_AMD_performance_monitor */

9848

9849 #ifdef GL_AMD_sample_positions

9850

9851 static GLboolean _glewInit_GL_AMD_sample_positions ()

9852 {

9853 GLboolean r = GL_FALSE;

9854

9855 r = ((glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC)glewGetProcAddress((const GLubyte*)"glSetMultisamplefvAMD")) == NULL) || r;

9856

9857 return r;

9858 }

9859

9860 #endif /* GL_AMD_sample_positions */

9861

9862 #ifdef GL_AMD_sparse_texture

9863

9864 static GLboolean _glewInit_GL_AMD_sparse_texture ()

9865 {

9866 GLboolean r = GL_FALSE;

9867

9868 r = ((glTexStorageSparseAMD = (PFNGLTEXSTORAGESPARSEAMDPROC)glewGetProcAddress((const GLubyte*)"glTexStorageSparseAMD")) == NULL) || r;

9869 r = ((glTextureStorageSparseAMD = (PFNGLTEXTURESTORAGESPARSEAMDPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageSparseAMD")) == NULL) || r;

9870

9871 return r;

9872 }

9873

9874 #endif /* GL_AMD_sparse_texture */

9875

9876 #ifdef GL_AMD_stencil_operation_extended

9877

9878 static GLboolean _glewInit_GL_AMD_stencil_operation_extended ()

9879 {

9880 GLboolean r = GL_FALSE;

9881

9882 r = ((glStencilOpValueAMD = (PFNGLSTENCILOPVALUEAMDPROC)glewGetProcAddress((const GLubyte*)"glStencilOpValueAMD")) == NULL) || r;

9883

9884 return r;

9885 }

9886

9887 #endif /* GL_AMD_stencil_operation_extended */

9888

9889 #ifdef GL_AMD_vertex_shader_tessellator

9890

9891 static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator ()

9892 {

9893 GLboolean r = GL_FALSE;

9894

9895 r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r;

9896 r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r;

9897

9898 return r;

9899 }

9900

9901 #endif /* GL_AMD_vertex_shader_tessellator */

9902

9903 #ifdef GL_ANGLE_framebuffer_blit

9904

9905 static GLboolean _glewInit_GL_ANGLE_framebuffer_blit ()

9906 {

9907 GLboolean r = GL_FALSE;

9908

9909 r = ((glBlitFramebufferANGLE = (PFNGLBLITFRAMEBUFFERANGLEPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferANGLE")) == NULL) || r;

9910

9911 return r;

9912 }

9913

9914 #endif /* GL_ANGLE_framebuffer_blit */

9915

9916 #ifdef GL_ANGLE_framebuffer_multisample

9917

9918 static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample ()

9919 {

9920 GLboolean r = GL_FALSE;

9921

9922 r = ((glRenderbufferStorageMultisampleANGLE = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleANGLE")) == NULL) || r;

9923

9924 return r;

9925 }

9926

9927 #endif /* GL_ANGLE_framebuffer_multisample */

9928

9929 #ifdef GL_ANGLE_instanced_arrays

9930

9931 static GLboolean _glewInit_GL_ANGLE_instanced_arrays ()

9932 {

9933 GLboolean r = GL_FALSE;

9934

9935 r = ((glDrawArraysInstancedANGLE = (PFNGLDRAWARRAYSINSTANCEDANGLEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedANGLE")) == NULL) || r;

9936 r = ((glDrawElementsInstancedANGLE = (PFNGLDRAWELEMENTSINSTANCEDANGLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedANGLE")) == NULL) || r;

9937 r = ((glVertexAttribDivisorANGLE = (PFNGLVERTEXATTRIBDIVISORANGLEPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorANGLE")) == NULL) || r;

9938

9939 return r;

9940 }

9941

9942 #endif /* GL_ANGLE_instanced_arrays */

9943

9944 #ifdef GL_ANGLE_timer_query

9945

9946 static GLboolean _glewInit_GL_ANGLE_timer_query ()

9947 {

9948 GLboolean r = GL_FALSE;

9949

9950 r = ((glBeginQueryANGLE = (PFNGLBEGINQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryANGLE")) == NULL) || r;

9951 r = ((glDeleteQueriesANGLE = (PFNGLDELETEQUERIESANGLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesANGLE")) == NULL) || r;

9952 r = ((glEndQueryANGLE = (PFNGLENDQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glEndQueryANGLE")) == NULL) || r;

9953 r = ((glGenQueriesANGLE = (PFNGLGENQUERIESANGLEPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesANGLE")) == NULL) || r;

9954 r = ((glGetQueryObjecti64vANGLE = (PFNGLGETQUERYOBJECTI64VANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vANGLE")) == NULL) || r;

9955 r = ((glGetQueryObjectivANGLE = (PFNGLGETQUERYOBJECTIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivANGLE")) == NULL) || r;

9956 r = ((glGetQueryObjectui64vANGLE = (PFNGLGETQUERYOBJECTUI64VANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vANGLE")) == NULL) || r;

9957 r = ((glGetQueryObjectuivANGLE = (PFNGLGETQUERYOBJECTUIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivANGLE")) == NULL) || r;

9958 r = ((glGetQueryivANGLE = (PFNGLGETQUERYIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivANGLE")) == NULL) || r;

9959 r = ((glIsQueryANGLE = (PFNGLISQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glIsQueryANGLE")) == NULL) || r;

9960 r = ((glQueryCounterANGLE = (PFNGLQUERYCOUNTERANGLEPROC)glewGetProcAddress((const GLubyte*)"glQueryCounterANGLE")) == NULL) || r;

9961

9962 return r;

9963 }

9964

9965 #endif /* GL_ANGLE_timer_query */

9966

9967 #ifdef GL_ANGLE_translated_shader_source

9968

9969 static GLboolean _glewInit_GL_ANGLE_translated_shader_source ()

9970 {

9971 GLboolean r = GL_FALSE;

9972

9973 r = ((glGetTranslatedShaderSourceANGLE = (PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetTranslatedShaderSourceANGLE")) == NULL) || r;

9974

9975 return r;

9976 }

9977

9978 #endif /* GL_ANGLE_translated_shader_source */

9979

9980 #ifdef GL_APPLE_copy_texture_levels

9981

9982 static GLboolean _glewInit_GL_APPLE_copy_texture_levels ()

9983 {

9984 GLboolean r = GL_FALSE;

9985

9986 r = ((glCopyTextureLevelsAPPLE = (PFNGLCOPYTEXTURELEVELSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureLevelsAPPLE")) == NULL) || r;

9987

9988 return r;

9989 }

9990

9991 #endif /* GL_APPLE_copy_texture_levels */

9992

9993 #ifdef GL_APPLE_element_array

9994

9995 static GLboolean _glewInit_GL_APPLE_element_array ()

9996 {

9997 GLboolean r = GL_FALSE;

9998

9999 r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r;

10000 r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r;

10001 r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r;

10002 r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r;

10003 r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r;

10004

10005 return r;

10006 }

10007

10008 #endif /* GL_APPLE_element_array */

10009

10010 #ifdef GL_APPLE_fence

10011

10012 static GLboolean _glewInit_GL_APPLE_fence ()

10013 {

10014 GLboolean r = GL_FALSE;

10015

10016 r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r;

10017 r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r;

10018 r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r;

10019 r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r;

10020 r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r;

10021 r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r;

10022 r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r;

10023 r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r;

10024

10025 return r;

10026 }

10027

10028 #endif /* GL_APPLE_fence */

10029

10030 #ifdef GL_APPLE_flush_buffer_range

10031

10032 static GLboolean _glewInit_GL_APPLE_flush_buffer_range ()

10033 {

10034 GLboolean r = GL_FALSE;

10035

10036 r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r;

10037 r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r;

10038

10039 return r;

10040 }

10041

10042 #endif /* GL_APPLE_flush_buffer_range */

10043

10044 #ifdef GL_APPLE_framebuffer_multisample

10045

10046 static GLboolean _glewInit_GL_APPLE_framebuffer_multisample ()

10047 {

10048 GLboolean r = GL_FALSE;

10049

10050 r = ((glRenderbufferStorageMultisampleAPPLE = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleAPPLE")) == NULL) || r;

10051 r = ((glResolveMultisampleFramebufferAPPLE = (PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glResolveMultisampleFramebufferAPPLE")) == NULL) || r;

10052

10053 return r;

10054 }

10055

10056 #endif /* GL_APPLE_framebuffer_multisample */

10057

10058 #ifdef GL_APPLE_object_purgeable

10059

10060 static GLboolean _glewInit_GL_APPLE_object_purgeable ()

10061 {

10062 GLboolean r = GL_FALSE;

10063

10064 r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r;

10065 r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r;

10066 r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r;

10067

10068 return r;

10069 }

10070

10071 #endif /* GL_APPLE_object_purgeable */

10072

10073 #ifdef GL_APPLE_sync

10074

10075 static GLboolean _glewInit_GL_APPLE_sync ()

10076 {

10077 GLboolean r = GL_FALSE;

10078

10079 r = ((glClientWaitSyncAPPLE = (PFNGLCLIENTWAITSYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSyncAPPLE")) == NULL) || r;

10080 r = ((glDeleteSyncAPPLE = (PFNGLDELETESYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteSyncAPPLE")) == NULL) || r;

10081 r = ((glFenceSyncAPPLE = (PFNGLFENCESYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFenceSyncAPPLE")) == NULL) || r;

10082 r = ((glGetInteger64vAPPLE = (PFNGLGETINTEGER64VAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64vAPPLE")) == NULL) || r;

10083 r = ((glGetSyncivAPPLE = (PFNGLGETSYNCIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetSyncivAPPLE")) == NULL) || r;

10084 r = ((glIsSyncAPPLE = (PFNGLISSYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsSyncAPPLE")) == NULL) || r;

10085 r = ((glWaitSyncAPPLE = (PFNGLWAITSYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glWaitSyncAPPLE")) == NULL) || r;

10086

10087 return r;

10088 }

10089

10090 #endif /* GL_APPLE_sync */

10091

10092 #ifdef GL_APPLE_texture_range

10093

10094 static GLboolean _glewInit_GL_APPLE_texture_range ()

10095 {

10096 GLboolean r = GL_FALSE;

10097

10098 r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r;

10099 r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r;

10100

10101 return r;

10102 }

10103

10104 #endif /* GL_APPLE_texture_range */

10105

10106 #ifdef GL_APPLE_vertex_array_object

10107

10108 static GLboolean _glewInit_GL_APPLE_vertex_array_object ()

10109 {

10110 GLboolean r = GL_FALSE;

10111

10112 r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r;

10113 r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r;

10114 r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r;

10115 r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r;

10116

10117 return r;

10118 }

10119

10120 #endif /* GL_APPLE_vertex_array_object */

10121

10122 #ifdef GL_APPLE_vertex_array_range

10123

10124 static GLboolean _glewInit_GL_APPLE_vertex_array_range ()

10125 {

10126 GLboolean r = GL_FALSE;

10127

10128 r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r;

10129 r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r;

10130 r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r;

10131

10132 return r;

10133 }

10134

10135 #endif /* GL_APPLE_vertex_array_range */

10136

10137 #ifdef GL_APPLE_vertex_program_evaluators

10138

10139 static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators ()

10140 {

10141 GLboolean r = GL_FALSE;

10142

10143 r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r;

10144 r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r;

10145 r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r;

10146 r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r;

10147 r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r;

10148 r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r;

10149 r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r;

10150

10151 return r;

10152 }

10153

10154 #endif /* GL_APPLE_vertex_program_evaluators */

10155

10156 #ifdef GL_ARB_ES2_compatibility

10157

10158 static GLboolean _glewInit_GL_ARB_ES2_compatibility ()

10159 {

10160 GLboolean r = GL_FALSE;

10161

10162 r = ((glClearDepthf = (PFNGLCLEARDEPTHFPROC)glewGetProcAddress((const GLubyte*)"glClearDepthf")) == NULL) || r;

10163 r = ((glDepthRangef = (PFNGLDEPTHRANGEFPROC)glewGetProcAddress((const GLubyte*)"glDepthRangef")) == NULL) || r;

10164 r = ((glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glewGetProcAddress((const GLubyte*)"glGetShaderPrecisionFormat")) == NULL) || r;

10165 r = ((glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glewGetProcAddress((const GLubyte*)"glReleaseShaderCompiler")) == NULL) || r;

10166 r = ((glShaderBinary = (PFNGLSHADERBINARYPROC)glewGetProcAddress((const GLubyte*)"glShaderBinary")) == NULL) || r;

10167

10168 return r;

10169 }

10170

10171 #endif /* GL_ARB_ES2_compatibility */

10172

10173 #ifdef GL_ARB_ES3_1_compatibility

10174

10175 static GLboolean _glewInit_GL_ARB_ES3_1_compatibility ()

10176 {

10177 GLboolean r = GL_FALSE;

10178

10179 r = ((glMemoryBarrierByRegion = (PFNGLMEMORYBARRIERBYREGIONPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierByRegion")) == NULL) || r;

10180

10181 return r;

10182 }

10183

10184 #endif /* GL_ARB_ES3_1_compatibility */

10185

10186 #ifdef GL_ARB_ES3_2_compatibility

10187

10188 static GLboolean _glewInit_GL_ARB_ES3_2_compatibility ()

10189 {

10190 GLboolean r = GL_FALSE;

10191

10192 r = ((glPrimitiveBoundingBoxARB = (PFNGLPRIMITIVEBOUNDINGBOXARBPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveBoundingBoxARB")) == NULL) || r;

10193

10194 return r;

10195 }

10196

10197 #endif /* GL_ARB_ES3_2_compatibility */

10198

10199 #ifdef GL_ARB_base_instance

10200

10201 static GLboolean _glewInit_GL_ARB_base_instance ()

10202 {

10203 GLboolean r = GL_FALSE;

10204

10205 r = ((glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstance")) == NULL) || r;

10206 r = ((glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstance")) == NULL) || r;

10207 r = ((glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstance")) == NULL) || r;

10208

10209 return r;

10210 }

10211

10212 #endif /* GL_ARB_base_instance */

10213

10214 #ifdef GL_ARB_bindless_texture

10215

10216 static GLboolean _glewInit_GL_ARB_bindless_texture ()

10217 {

10218 GLboolean r = GL_FALSE;

10219

10220 r = ((glGetImageHandleARB = (PFNGLGETIMAGEHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleARB")) == NULL) || r;

10221 r = ((glGetTextureHandleARB = (PFNGLGETTEXTUREHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleARB")) == NULL) || r;

10222 r = ((glGetTextureSamplerHandleARB = (PFNGLGETTEXTURESAMPLERHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleARB")) == NULL) || r;

10223 r = ((glGetVertexAttribLui64vARB = (PFNGLGETVERTEXATTRIBLUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vARB")) == NULL) || r;

10224 r = ((glIsImageHandleResidentARB = (PFNGLISIMAGEHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentARB")) == NULL) || r;

10225 r = ((glIsTextureHandleResidentARB = (PFNGLISTEXTUREHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentARB")) == NULL) || r;

10226 r = ((glMakeImageHandleNonResidentARB = (PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentARB")) == NULL) || r;

10227 r = ((glMakeImageHandleResidentARB = (PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentARB")) == NULL) || r;

10228 r = ((glMakeTextureHandleNonResidentARB = (PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentARB")) == NULL) || r;

10229 r = ((glMakeTextureHandleResidentARB = (PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentARB")) == NULL) || r;

10230 r = ((glProgramUniformHandleui64ARB = (PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64ARB")) == NULL) || r;

10231 r = ((glProgramUniformHandleui64vARB = (PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vARB")) == NULL) || r;

10232 r = ((glUniformHandleui64ARB = (PFNGLUNIFORMHANDLEUI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64ARB")) == NULL) || r;

10233 r = ((glUniformHandleui64vARB = (PFNGLUNIFORMHANDLEUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vARB")) == NULL) || r;

10234 r = ((glVertexAttribL1ui64ARB = (PFNGLVERTEXATTRIBL1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64ARB")) == NULL) || r;

10235 r = ((glVertexAttribL1ui64vARB = (PFNGLVERTEXATTRIBL1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vARB")) == NULL) || r;

10236

10237 return r;

10238 }

10239

10240 #endif /* GL_ARB_bindless_texture */

10241

10242 #ifdef GL_ARB_blend_func_extended

10243

10244 static GLboolean _glewInit_GL_ARB_blend_func_extended ()

10245 {

10246 GLboolean r = GL_FALSE;

10247

10248 r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r;

10249 r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r;

10250

10251 return r;

10252 }

10253

10254 #endif /* GL_ARB_blend_func_extended */

10255

10256 #ifdef GL_ARB_buffer_storage

10257

10258 static GLboolean _glewInit_GL_ARB_buffer_storage ()

10259 {

10260 GLboolean r = GL_FALSE;

10261

10262 r = ((glBufferStorage = (PFNGLBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glBufferStorage")) == NULL) || r;

10263

10264 return r;

10265 }

10266

10267 #endif /* GL_ARB_buffer_storage */

10268

10269 #ifdef GL_ARB_cl_event

10270

10271 static GLboolean _glewInit_GL_ARB_cl_event ()

10272 {

10273 GLboolean r = GL_FALSE;

10274

10275 r = ((glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateSyncFromCLeventARB")) == NULL) || r;

10276

10277 return r;

10278 }

10279

10280 #endif /* GL_ARB_cl_event */

10281

10282 #ifdef GL_ARB_clear_buffer_object

10283

10284 static GLboolean _glewInit_GL_ARB_clear_buffer_object ()

10285 {

10286 GLboolean r = GL_FALSE;

10287

10288 r = ((glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferData")) == NULL) || r;

10289 r = ((glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferSubData")) == NULL) || r;

10290 r = ((glClearNamedBufferDataEXT = (PFNGLCLEARNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferDataEXT")) == NULL) || r;

10291 r = ((glClearNamedBufferSubDataEXT = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferSubDataEXT")) == NULL) || r;

10292

10293 return r;

10294 }

10295

10296 #endif /* GL_ARB_clear_buffer_object */

10297

10298 #ifdef GL_ARB_clear_texture

10299

10300 static GLboolean _glewInit_GL_ARB_clear_texture ()

10301 {

10302 GLboolean r = GL_FALSE;

10303

10304 r = ((glClearTexImage = (PFNGLCLEARTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glClearTexImage")) == NULL) || r;

10305 r = ((glClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glClearTexSubImage")) == NULL) || r;

10306

10307 return r;

10308 }

10309

10310 #endif /* GL_ARB_clear_texture */

10311

10312 #ifdef GL_ARB_clip_control

10313

10314 static GLboolean _glewInit_GL_ARB_clip_control ()

10315 {

10316 GLboolean r = GL_FALSE;

10317

10318 r = ((glClipControl = (PFNGLCLIPCONTROLPROC)glewGetProcAddress((const GLubyte*)"glClipControl")) == NULL) || r;

10319

10320 return r;

10321 }

10322

10323 #endif /* GL_ARB_clip_control */

10324

10325 #ifdef GL_ARB_color_buffer_float

10326

10327 static GLboolean _glewInit_GL_ARB_color_buffer_float ()

10328 {

10329 GLboolean r = GL_FALSE;

10330

10331 r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r;

10332

10333 return r;

10334 }

10335

10336 #endif /* GL_ARB_color_buffer_float */

10337

10338 #ifdef GL_ARB_compute_shader

10339

10340 static GLboolean _glewInit_GL_ARB_compute_shader ()

10341 {

10342 GLboolean r = GL_FALSE;

10343

10344 r = ((glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)glewGetProcAddress((const GLubyte*)"glDispatchCompute")) == NULL) || r;

10345 r = ((glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeIndirect")) == NULL) || r;

10346

10347 return r;

10348 }

10349

10350 #endif /* GL_ARB_compute_shader */

10351

10352 #ifdef GL_ARB_compute_variable_group_size

10353

10354 static GLboolean _glewInit_GL_ARB_compute_variable_group_size ()

10355 {

10356 GLboolean r = GL_FALSE;

10357

10358 r = ((glDispatchComputeGroupSizeARB = (PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeGroupSizeARB")) == NULL) || r;

10359

10360 return r;

10361 }

10362

10363 #endif /* GL_ARB_compute_variable_group_size */

10364

10365 #ifdef GL_ARB_copy_buffer

10366

10367 static GLboolean _glewInit_GL_ARB_copy_buffer ()

10368 {

10369 GLboolean r = GL_FALSE;

10370

10371 r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r;

10372

10373 return r;

10374 }

10375

10376 #endif /* GL_ARB_copy_buffer */

10377

10378 #ifdef GL_ARB_copy_image

10379

10380 static GLboolean _glewInit_GL_ARB_copy_image ()

10381 {

10382 GLboolean r = GL_FALSE;

10383

10384 r = ((glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubData")) == NULL) || r;

10385

10386 return r;

10387 }

10388

10389 #endif /* GL_ARB_copy_image */

10390

10391 #ifdef GL_ARB_debug_output

10392

10393 static GLboolean _glewInit_GL_ARB_debug_output ()

10394 {

10395 GLboolean r = GL_FALSE;

10396

10397 r = ((glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackARB")) == NULL) || r;

10398 r = ((glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControlARB")) == NULL) || r;

10399 r = ((glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertARB")) == NULL) || r;

10400 r = ((glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogARB")) == NULL) || r;

10401

10402 return r;

10403 }

10404

10405 #endif /* GL_ARB_debug_output */

10406

10407 #ifdef GL_ARB_direct_state_access

10408

10409 static GLboolean _glewInit_GL_ARB_direct_state_access ()

10410 {

10411 GLboolean r = GL_FALSE;

10412

10413 r = ((glBindTextureUnit = (PFNGLBINDTEXTUREUNITPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnit")) == NULL) || r;

10414 r = ((glBlitNamedFramebuffer = (PFNGLBLITNAMEDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitNamedFramebuffer")) == NULL) || r;

10415 r = ((glCheckNamedFramebufferStatus = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatus")) == NULL) || r;

10416 r = ((glClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferData")) == NULL) || r;

10417 r = ((glClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferSubData")) == NULL) || r;

10418 r = ((glClearNamedFramebufferfi = (PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferfi")) == NULL) || r;

10419 r = ((glClearNamedFramebufferfv = (PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferfv")) == NULL) || r;

10420 r = ((glClearNamedFramebufferiv = (PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferiv")) == NULL) || r;

10421 r = ((glClearNamedFramebufferuiv = (PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferuiv")) == NULL) || r;

10422 r = ((glCompressedTextureSubImage1D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1D")) == NULL) || r;

10423 r = ((glCompressedTextureSubImage2D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2D")) == NULL) || r;

10424 r = ((glCompressedTextureSubImage3D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3D")) == NULL) || r;

10425 r = ((glCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyNamedBufferSubData")) == NULL) || r;

10426 r = ((glCopyTextureSubImage1D = (PFNGLCOPYTEXTURESUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1D")) == NULL) || r;

10427 r = ((glCopyTextureSubImage2D = (PFNGLCOPYTEXTURESUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2D")) == NULL) || r;

10428 r = ((glCopyTextureSubImage3D = (PFNGLCOPYTEXTURESUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3D")) == NULL) || r;

10429 r = ((glCreateBuffers = (PFNGLCREATEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glCreateBuffers")) == NULL) || r;

10430 r = ((glCreateFramebuffers = (PFNGLCREATEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glCreateFramebuffers")) == NULL) || r;

10431 r = ((glCreateProgramPipelines = (PFNGLCREATEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramPipelines")) == NULL) || r;

10432 r = ((glCreateQueries = (PFNGLCREATEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glCreateQueries")) == NULL) || r;

10433 r = ((glCreateRenderbuffers = (PFNGLCREATERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glCreateRenderbuffers")) == NULL) || r;

10434 r = ((glCreateSamplers = (PFNGLCREATESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glCreateSamplers")) == NULL) || r;

10435 r = ((glCreateTextures = (PFNGLCREATETEXTURESPROC)glewGetProcAddress((const GLubyte*)"glCreateTextures")) == NULL) || r;

10436 r = ((glCreateTransformFeedbacks = (PFNGLCREATETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glCreateTransformFeedbacks")) == NULL) || r;

10437 r = ((glCreateVertexArrays = (PFNGLCREATEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glCreateVertexArrays")) == NULL) || r;

10438 r = ((glDisableVertexArrayAttrib = (PFNGLDISABLEVERTEXARRAYATTRIBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttrib")) == NULL) || r;

10439 r = ((glEnableVertexArrayAttrib = (PFNGLENABLEVERTEXARRAYATTRIBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttrib")) == NULL) || r;

10440 r = ((glFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRange")) == NULL) || r;

10441 r = ((glGenerateTextureMipmap = (PFNGLGENERATETEXTUREMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmap")) == NULL) || r;

10442 r = ((glGetCompressedTextureImage = (PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImage")) == NULL) || r;

10443 r = ((glGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameteri64v")) == NULL) || r;

10444 r = ((glGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameteriv")) == NULL) || r;

10445 r = ((glGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointerv")) == NULL) || r;

10446 r = ((glGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubData")) == NULL) || r;

10447 r = ((glGetNamedFramebufferAttachmentParameteriv = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameteriv")) == NULL) || r;

10448 r = ((glGetNamedFramebufferParameteriv = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameteriv")) == NULL) || r;

10449 r = ((glGetNamedRenderbufferParameteriv = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameteriv")) == NULL) || r;

10450 r = ((glGetQueryBufferObjecti64v = (PFNGLGETQUERYBUFFEROBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjecti64v")) == NULL) || r;

10451 r = ((glGetQueryBufferObjectiv = (PFNGLGETQUERYBUFFEROBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjectiv")) == NULL) || r;

10452 r = ((glGetQueryBufferObjectui64v = (PFNGLGETQUERYBUFFEROBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjectui64v")) == NULL) || r;

10453 r = ((glGetQueryBufferObjectuiv = (PFNGLGETQUERYBUFFEROBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjectuiv")) == NULL) || r;

10454 r = ((glGetTextureImage = (PFNGLGETTEXTUREIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImage")) == NULL) || r;

10455 r = ((glGetTextureLevelParameterfv = (PFNGLGETTEXTURELEVELPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfv")) == NULL) || r;

10456 r = ((glGetTextureLevelParameteriv = (PFNGLGETTEXTURELEVELPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameteriv")) == NULL) || r;

10457 r = ((glGetTextureParameterIiv = (PFNGLGETTEXTUREPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIiv")) == NULL) || r;

10458 r = ((glGetTextureParameterIuiv = (PFNGLGETTEXTUREPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuiv")) == NULL) || r;

10459 r = ((glGetTextureParameterfv = (PFNGLGETTEXTUREPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfv")) == NULL) || r;

10460 r = ((glGetTextureParameteriv = (PFNGLGETTEXTUREPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameteriv")) == NULL) || r;

10461 r = ((glGetTransformFeedbacki64_v = (PFNGLGETTRANSFORMFEEDBACKI64_VPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbacki64_v")) == NULL) || r;

10462 r = ((glGetTransformFeedbacki_v = (PFNGLGETTRANSFORMFEEDBACKI_VPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbacki_v")) == NULL) || r;

10463 r = ((glGetTransformFeedbackiv = (PFNGLGETTRANSFORMFEEDBACKIVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackiv")) == NULL) || r;

10464 r = ((glGetVertexArrayIndexed64iv = (PFNGLGETVERTEXARRAYINDEXED64IVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIndexed64iv")) == NULL) || r;

10465 r = ((glGetVertexArrayIndexediv = (PFNGLGETVERTEXARRAYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIndexediv")) == NULL) || r;

10466 r = ((glGetVertexArrayiv = (PFNGLGETVERTEXARRAYIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayiv")) == NULL) || r;

10467 r = ((glInvalidateNamedFramebufferData = (PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateNamedFramebufferData")) == NULL) || r;

10468 r = ((glInvalidateNamedFramebufferSubData = (PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateNamedFramebufferSubData")) == NULL) || r;

10469 r = ((glMapNamedBuffer = (PFNGLMAPNAMEDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBuffer")) == NULL) || r;

10470 r = ((glMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRange")) == NULL) || r;

10471 r = ((glNamedBufferData = (PFNGLNAMEDBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferData")) == NULL) || r;

10472 r = ((glNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorage")) == NULL) || r;

10473 r = ((glNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubData")) == NULL) || r;

10474 r = ((glNamedFramebufferDrawBuffer = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferDrawBuffer")) == NULL) || r;

10475 r = ((glNamedFramebufferDrawBuffers = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferDrawBuffers")) == NULL) || r;

10476 r = ((glNamedFramebufferParameteri = (PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferParameteri")) == NULL) || r;

10477 r = ((glNamedFramebufferReadBuffer = (PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferReadBuffer")) == NULL) || r;

10478 r = ((glNamedFramebufferRenderbuffer = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbuffer")) == NULL) || r;

10479 r = ((glNamedFramebufferTexture = (PFNGLNAMEDFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture")) == NULL) || r;

10480 r = ((glNamedFramebufferTextureLayer = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayer")) == NULL) || r;

10481 r = ((glNamedRenderbufferStorage = (PFNGLNAMEDRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorage")) == NULL) || r;

10482 r = ((glNamedRenderbufferStorageMultisample = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisample")) == NULL) || r;

10483 r = ((glTextureBuffer = (PFNGLTEXTUREBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTextureBuffer")) == NULL) || r;

10484 r = ((glTextureBufferRange = (PFNGLTEXTUREBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferRange")) == NULL) || r;

10485 r = ((glTextureParameterIiv = (PFNGLTEXTUREPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIiv")) == NULL) || r;

10486 r = ((glTextureParameterIuiv = (PFNGLTEXTUREPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuiv")) == NULL) || r;

10487 r = ((glTextureParameterf = (PFNGLTEXTUREPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterf")) == NULL) || r;

10488 r = ((glTextureParameterfv = (PFNGLTEXTUREPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfv")) == NULL) || r;

10489 r = ((glTextureParameteri = (PFNGLTEXTUREPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteri")) == NULL) || r;

10490 r = ((glTextureParameteriv = (PFNGLTEXTUREPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriv")) == NULL) || r;

10491 r = ((glTextureStorage1D = (PFNGLTEXTURESTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1D")) == NULL) || r;

10492 r = ((glTextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2D")) == NULL) || r;

10493 r = ((glTextureStorage2DMultisample = (PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DMultisample")) == NULL) || r;

10494 r = ((glTextureStorage3D = (PFNGLTEXTURESTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3D")) == NULL) || r;

10495 r = ((glTextureStorage3DMultisample = (PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DMultisample")) == NULL) || r;

10496 r = ((glTextureSubImage1D = (PFNGLTEXTURESUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1D")) == NULL) || r;

10497 r = ((glTextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2D")) == NULL) || r;

10498 r = ((glTextureSubImage3D = (PFNGLTEXTURESUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3D")) == NULL) || r;

10499 r = ((glTransformFeedbackBufferBase = (PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackBufferBase")) == NULL) || r;

10500 r = ((glTransformFeedbackBufferRange = (PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackBufferRange")) == NULL) || r;

10501 r = ((glUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBuffer")) == NULL) || r;

10502 r = ((glVertexArrayAttribBinding = (PFNGLVERTEXARRAYATTRIBBINDINGPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribBinding")) == NULL) || r;

10503 r = ((glVertexArrayAttribFormat = (PFNGLVERTEXARRAYATTRIBFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribFormat")) == NULL) || r;

10504 r = ((glVertexArrayAttribIFormat = (PFNGLVERTEXARRAYATTRIBIFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribIFormat")) == NULL) || r;

10505 r = ((glVertexArrayAttribLFormat = (PFNGLVERTEXARRAYATTRIBLFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribLFormat")) == NULL) || r;

10506 r = ((glVertexArrayBindingDivisor = (PFNGLVERTEXARRAYBINDINGDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayBindingDivisor")) == NULL) || r;

10507 r = ((glVertexArrayElementBuffer = (PFNGLVERTEXARRAYELEMENTBUFFERPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayElementBuffer")) == NULL) || r;

10508 r = ((glVertexArrayVertexBuffer = (PFNGLVERTEXARRAYVERTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexBuffer")) == NULL) || r;

10509 r = ((glVertexArrayVertexBuffers = (PFNGLVERTEXARRAYVERTEXBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexBuffers")) == NULL) || r;

10510

10511 return r;

10512 }

10513

10514 #endif /* GL_ARB_direct_state_access */

10515

10516 #ifdef GL_ARB_draw_buffers

10517

10518 static GLboolean _glewInit_GL_ARB_draw_buffers ()

10519 {

10520 GLboolean r = GL_FALSE;

10521

10522 r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r;

10523

10524 return r;

10525 }

10526

10527 #endif /* GL_ARB_draw_buffers */

10528

10529 #ifdef GL_ARB_draw_buffers_blend

10530

10531 static GLboolean _glewInit_GL_ARB_draw_buffers_blend ()

10532 {

10533 GLboolean r = GL_FALSE;

10534

10535 r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r;

10536 r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r;

10537 r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r;

10538 r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r;

10539

10540 return r;

10541 }

10542

10543 #endif /* GL_ARB_draw_buffers_blend */

10544

10545 #ifdef GL_ARB_draw_elements_base_vertex

10546

10547 static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex ()

10548 {

10549 GLboolean r = GL_FALSE;

10550

10551 r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r;

10552 r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r;

10553 r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r;

10554 r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r;

10555

10556 return r;

10557 }

10558

10559 #endif /* GL_ARB_draw_elements_base_vertex */

10560

10561 #ifdef GL_ARB_draw_indirect

10562

10563 static GLboolean _glewInit_GL_ARB_draw_indirect ()

10564 {

10565 GLboolean r = GL_FALSE;

10566

10567 r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r;

10568 r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r;

10569

10570 return r;

10571 }

10572

10573 #endif /* GL_ARB_draw_indirect */

10574

10575 #ifdef GL_ARB_framebuffer_no_attachments

10576

10577 static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments ()

10578 {

10579 GLboolean r = GL_FALSE;

10580

10581 r = ((glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glFramebufferParameteri")) == NULL) || r;

10582 r = ((glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameteriv")) == NULL) || r;

10583 r = ((glGetNamedFramebufferParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameterivEXT")) == NULL) || r;

10584 r = ((glNamedFramebufferParameteriEXT = (PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferParameteriEXT")) == NULL) || r;

10585

10586 return r;

10587 }

10588

10589 #endif /* GL_ARB_framebuffer_no_attachments */

10590

10591 #ifdef GL_ARB_framebuffer_object

10592

10593 static GLboolean _glewInit_GL_ARB_framebuffer_object ()

10594 {

10595 GLboolean r = GL_FALSE;

10596

10597 r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r;

10598 r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r;

10599 r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r;

10600 r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r;

10601 r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r;

10602 r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r;

10603 r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r;

10604 r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r;

10605 r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r;

10606 r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r;

10607 r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r;

10608 r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r;

10609 r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r;

10610 r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r;

10611 r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r;

10612 r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r;

10613 r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r;

10614 r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r;

10615 r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r;

10616 r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r;

10617

10618 return r;

10619 }

10620

10621 #endif /* GL_ARB_framebuffer_object */

10622

10623 #ifdef GL_ARB_geometry_shader4

10624

10625 static GLboolean _glewInit_GL_ARB_geometry_shader4 ()

10626 {

10627 GLboolean r = GL_FALSE;

10628

10629 r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r;

10630 r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r;

10631 r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r;

10632 r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r;

10633

10634 return r;

10635 }

10636

10637 #endif /* GL_ARB_geometry_shader4 */

10638

10639 #ifdef GL_ARB_get_program_binary

10640

10641 static GLboolean _glewInit_GL_ARB_get_program_binary ()

10642 {

10643 GLboolean r = GL_FALSE;

10644

10645 r = ((glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinary")) == NULL) || r;

10646 r = ((glProgramBinary = (PFNGLPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glProgramBinary")) == NULL) || r;

10647 r = ((glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteri")) == NULL) || r;

10648

10649 return r;

10650 }

10651

10652 #endif /* GL_ARB_get_program_binary */

10653

10654 #ifdef GL_ARB_get_texture_sub_image

10655

10656 static GLboolean _glewInit_GL_ARB_get_texture_sub_image ()

10657 {

10658 GLboolean r = GL_FALSE;

10659

10660 r = ((glGetCompressedTextureSubImage = (PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureSubImage")) == NULL) || r;

10661 r = ((glGetTextureSubImage = (PFNGLGETTEXTURESUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSubImage")) == NULL) || r;

10662

10663 return r;

10664 }

10665

10666 #endif /* GL_ARB_get_texture_sub_image */

10667

10668 #ifdef GL_ARB_gl_spirv

10669

10670 static GLboolean _glewInit_GL_ARB_gl_spirv ()

10671 {

10672 GLboolean r = GL_FALSE;

10673

10674 r = ((glSpecializeShaderARB = (PFNGLSPECIALIZESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glSpecializeShaderARB")) == NULL) || r;

10675

10676 return r;

10677 }

10678

10679 #endif /* GL_ARB_gl_spirv */

10680

10681 #ifdef GL_ARB_gpu_shader_fp64

10682

10683 static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 ()

10684 {

10685 GLboolean r = GL_FALSE;

10686

10687 r = ((glGetUniformdv = (PFNGLGETUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformdv")) == NULL) || r;

10688 r = ((glUniform1d = (PFNGLUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glUniform1d")) == NULL) || r;

10689 r = ((glUniform1dv = (PFNGLUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glUniform1dv")) == NULL) || r;

10690 r = ((glUniform2d = (PFNGLUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glUniform2d")) == NULL) || r;

10691 r = ((glUniform2dv = (PFNGLUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glUniform2dv")) == NULL) || r;

10692 r = ((glUniform3d = (PFNGLUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glUniform3d")) == NULL) || r;

10693 r = ((glUniform3dv = (PFNGLUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glUniform3dv")) == NULL) || r;

10694 r = ((glUniform4d = (PFNGLUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glUniform4d")) == NULL) || r;

10695 r = ((glUniform4dv = (PFNGLUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glUniform4dv")) == NULL) || r;

10696 r = ((glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2dv")) == NULL) || r;

10697 r = ((glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3dv")) == NULL) || r;

10698 r = ((glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4dv")) == NULL) || r;

10699 r = ((glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3dv")) == NULL) || r;

10700 r = ((glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2dv")) == NULL) || r;

10701 r = ((glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4dv")) == NULL) || r;

10702 r = ((glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4dv")) == NULL) || r;

10703 r = ((glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2dv")) == NULL) || r;

10704 r = ((glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3dv")) == NULL) || r;

10705

10706 return r;

10707 }

10708

10709 #endif /* GL_ARB_gpu_shader_fp64 */

10710

10711 #ifdef GL_ARB_gpu_shader_int64

10712

10713 static GLboolean _glewInit_GL_ARB_gpu_shader_int64 ()

10714 {

10715 GLboolean r = GL_FALSE;

10716

10717 r = ((glGetUniformi64vARB = (PFNGLGETUNIFORMI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vARB")) == NULL) || r;

10718 r = ((glGetUniformui64vARB = (PFNGLGETUNIFORMUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vARB")) == NULL) || r;

10719 r = ((glGetnUniformi64vARB = (PFNGLGETNUNIFORMI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformi64vARB")) == NULL) || r;

10720 r = ((glGetnUniformui64vARB = (PFNGLGETNUNIFORMUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformui64vARB")) == NULL) || r;

10721 r = ((glProgramUniform1i64ARB = (PFNGLPROGRAMUNIFORM1I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64ARB")) == NULL) || r;

10722 r = ((glProgramUniform1i64vARB = (PFNGLPROGRAMUNIFORM1I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vARB")) == NULL) || r;

10723 r = ((glProgramUniform1ui64ARB = (PFNGLPROGRAMUNIFORM1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64ARB")) == NULL) || r;

10724 r = ((glProgramUniform1ui64vARB = (PFNGLPROGRAMUNIFORM1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vARB")) == NULL) || r;

10725 r = ((glProgramUniform2i64ARB = (PFNGLPROGRAMUNIFORM2I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64ARB")) == NULL) || r;

10726 r = ((glProgramUniform2i64vARB = (PFNGLPROGRAMUNIFORM2I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vARB")) == NULL) || r;

10727 r = ((glProgramUniform2ui64ARB = (PFNGLPROGRAMUNIFORM2UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64ARB")) == NULL) || r;

10728 r = ((glProgramUniform2ui64vARB = (PFNGLPROGRAMUNIFORM2UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vARB")) == NULL) || r;

10729 r = ((glProgramUniform3i64ARB = (PFNGLPROGRAMUNIFORM3I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64ARB")) == NULL) || r;

10730 r = ((glProgramUniform3i64vARB = (PFNGLPROGRAMUNIFORM3I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vARB")) == NULL) || r;

10731 r = ((glProgramUniform3ui64ARB = (PFNGLPROGRAMUNIFORM3UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64ARB")) == NULL) || r;

10732 r = ((glProgramUniform3ui64vARB = (PFNGLPROGRAMUNIFORM3UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vARB")) == NULL) || r;

10733 r = ((glProgramUniform4i64ARB = (PFNGLPROGRAMUNIFORM4I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64ARB")) == NULL) || r;

10734 r = ((glProgramUniform4i64vARB = (PFNGLPROGRAMUNIFORM4I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vARB")) == NULL) || r;

10735 r = ((glProgramUniform4ui64ARB = (PFNGLPROGRAMUNIFORM4UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64ARB")) == NULL) || r;

10736 r = ((glProgramUniform4ui64vARB = (PFNGLPROGRAMUNIFORM4UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vARB")) == NULL) || r;

10737 r = ((glUniform1i64ARB = (PFNGLUNIFORM1I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64ARB")) == NULL) || r;

10738 r = ((glUniform1i64vARB = (PFNGLUNIFORM1I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vARB")) == NULL) || r;

10739 r = ((glUniform1ui64ARB = (PFNGLUNIFORM1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64ARB")) == NULL) || r;

10740 r = ((glUniform1ui64vARB = (PFNGLUNIFORM1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vARB")) == NULL) || r;

10741 r = ((glUniform2i64ARB = (PFNGLUNIFORM2I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64ARB")) == NULL) || r;

10742 r = ((glUniform2i64vARB = (PFNGLUNIFORM2I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vARB")) == NULL) || r;

10743 r = ((glUniform2ui64ARB = (PFNGLUNIFORM2UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64ARB")) == NULL) || r;

10744 r = ((glUniform2ui64vARB = (PFNGLUNIFORM2UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vARB")) == NULL) || r;

10745 r = ((glUniform3i64ARB = (PFNGLUNIFORM3I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64ARB")) == NULL) || r;

10746 r = ((glUniform3i64vARB = (PFNGLUNIFORM3I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vARB")) == NULL) || r;

10747 r = ((glUniform3ui64ARB = (PFNGLUNIFORM3UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64ARB")) == NULL) || r;

10748 r = ((glUniform3ui64vARB = (PFNGLUNIFORM3UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vARB")) == NULL) || r;

10749 r = ((glUniform4i64ARB = (PFNGLUNIFORM4I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64ARB")) == NULL) || r;

10750 r = ((glUniform4i64vARB = (PFNGLUNIFORM4I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vARB")) == NULL) || r;

10751 r = ((glUniform4ui64ARB = (PFNGLUNIFORM4UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64ARB")) == NULL) || r;

10752 r = ((glUniform4ui64vARB = (PFNGLUNIFORM4UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vARB")) == NULL) || r;

10753

10754 return r;

10755 }

10756

10757 #endif /* GL_ARB_gpu_shader_int64 */

10758

10759 #ifdef GL_ARB_imaging

10760

10761 static GLboolean _glewInit_GL_ARB_imaging ()

10762 {

10763 GLboolean r = GL_FALSE;

10764

10765 r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;

10766 r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r;

10767 r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r;

10768 r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r;

10769 r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r;

10770 r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r;

10771 r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r;

10772 r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r;

10773 r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r;

10774 r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r;

10775 r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r;

10776 r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r;

10777 r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r;

10778 r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r;

10779 r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r;

10780 r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r;

10781 r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r;

10782 r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r;

10783 r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r;

10784 r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r;

10785 r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r;

10786 r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r;

10787 r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r;

10788 r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r;

10789 r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r;

10790 r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r;

10791 r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r;

10792 r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r;

10793 r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r;

10794 r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r;

10795 r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r;

10796 r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r;

10797 r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r;

10798

10799 return r;

10800 }

10801

10802 #endif /* GL_ARB_imaging */

10803

10804 #ifdef GL_ARB_indirect_parameters

10805

10806 static GLboolean _glewInit_GL_ARB_indirect_parameters ()

10807 {

10808 GLboolean r = GL_FALSE;

10809

10810 r = ((glMultiDrawArraysIndirectCountARB = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectCountARB")) == NULL) || r;

10811 r = ((glMultiDrawElementsIndirectCountARB = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectCountARB")) == NULL) || r;

10812

10813 return r;

10814 }

10815

10816 #endif /* GL_ARB_indirect_parameters */

10817

10818 #ifdef GL_ARB_instanced_arrays

10819

10820 static GLboolean _glewInit_GL_ARB_instanced_arrays ()

10821 {

10822 GLboolean r = GL_FALSE;

10823

10824 r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r;

10825 r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r;

10826 r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r;

10827

10828 return r;

10829 }

10830

10831 #endif /* GL_ARB_instanced_arrays */

10832

10833 #ifdef GL_ARB_internalformat_query

10834

10835 static GLboolean _glewInit_GL_ARB_internalformat_query ()

10836 {

10837 GLboolean r = GL_FALSE;

10838

10839 r = ((glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformativ")) == NULL) || r;

10840

10841 return r;

10842 }

10843

10844 #endif /* GL_ARB_internalformat_query */

10845

10846 #ifdef GL_ARB_internalformat_query2

10847

10848 static GLboolean _glewInit_GL_ARB_internalformat_query2 ()

10849 {

10850 GLboolean r = GL_FALSE;

10851

10852 r = ((glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformati64v")) == NULL) || r;

10853

10854 return r;

10855 }

10856

10857 #endif /* GL_ARB_internalformat_query2 */

10858

10859 #ifdef GL_ARB_invalidate_subdata

10860

10861 static GLboolean _glewInit_GL_ARB_invalidate_subdata ()

10862 {

10863 GLboolean r = GL_FALSE;

10864

10865 r = ((glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferData")) == NULL) || r;

10866 r = ((glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferSubData")) == NULL) || r;

10867 r = ((glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateFramebuffer")) == NULL) || r;

10868 r = ((glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateSubFramebuffer")) == NULL) || r;

10869 r = ((glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexImage")) == NULL) || r;

10870 r = ((glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexSubImage")) == NULL) || r;

10871

10872 return r;

10873 }

10874

10875 #endif /* GL_ARB_invalidate_subdata */

10876

10877 #ifdef GL_ARB_map_buffer_range

10878

10879 static GLboolean _glewInit_GL_ARB_map_buffer_range ()

10880 {

10881 GLboolean r = GL_FALSE;

10882

10883 r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r;

10884 r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r;

10885

10886 return r;

10887 }

10888

10889 #endif /* GL_ARB_map_buffer_range */

10890

10891 #ifdef GL_ARB_matrix_palette

10892

10893 static GLboolean _glewInit_GL_ARB_matrix_palette ()

10894 {

10895 GLboolean r = GL_FALSE;

10896

10897 r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r;

10898 r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r;

10899 r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r;

10900 r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r;

10901 r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r;

10902

10903 return r;

10904 }

10905

10906 #endif /* GL_ARB_matrix_palette */

10907

10908 #ifdef GL_ARB_multi_bind

10909

10910 static GLboolean _glewInit_GL_ARB_multi_bind ()

10911 {

10912 GLboolean r = GL_FALSE;

10913

10914 r = ((glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBuffersBase")) == NULL) || r;

10915 r = ((glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBuffersRange")) == NULL) || r;

10916 r = ((glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextures")) == NULL) || r;

10917 r = ((glBindSamplers = (PFNGLBINDSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glBindSamplers")) == NULL) || r;

10918 r = ((glBindTextures = (PFNGLBINDTEXTURESPROC)glewGetProcAddress((const GLubyte*)"glBindTextures")) == NULL) || r;

10919 r = ((glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffers")) == NULL) || r;

10920

10921 return r;

10922 }

10923

10924 #endif /* GL_ARB_multi_bind */

10925

10926 #ifdef GL_ARB_multi_draw_indirect

10927

10928 static GLboolean _glewInit_GL_ARB_multi_draw_indirect ()

10929 {

10930 GLboolean r = GL_FALSE;

10931

10932 r = ((glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirect")) == NULL) || r;

10933 r = ((glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirect")) == NULL) || r;

10934

10935 return r;

10936 }

10937

10938 #endif /* GL_ARB_multi_draw_indirect */

10939

10940 #ifdef GL_ARB_multisample

10941

10942 static GLboolean _glewInit_GL_ARB_multisample ()

10943 {

10944 GLboolean r = GL_FALSE;

10945

10946 r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r;

10947

10948 return r;

10949 }

10950

10951 #endif /* GL_ARB_multisample */

10952

10953 #ifdef GL_ARB_multitexture

10954

10955 static GLboolean _glewInit_GL_ARB_multitexture ()

10956 {

10957 GLboolean r = GL_FALSE;

10958

10959 r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r;

10960 r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r;

10961 r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r;

10962 r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r;

10963 r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r;

10964 r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r;

10965 r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r;

10966 r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r;

10967 r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r;

10968 r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r;

10969 r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r;

10970 r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r;

10971 r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r;

10972 r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r;

10973 r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r;

10974 r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r;

10975 r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r;

10976 r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r;

10977 r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r;

10978 r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r;

10979 r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r;

10980 r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r;

10981 r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r;

10982 r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;

10983 r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;

10984 r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;

10985 r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;

10986 r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;

10987 r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;

10988 r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;

10989 r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;

10990 r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;

10991 r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;

10992 r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;

10993

10994 return r;

10995 }

10996

10997 #endif /* GL_ARB_multitexture */

10998

10999 #ifdef GL_ARB_occlusion_query

11000

11001 static GLboolean _glewInit_GL_ARB_occlusion_query ()

11002 {

11003 GLboolean r = GL_FALSE;

11004

11005 r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;

11006 r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;

11007 r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;

11008 r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;

11009 r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;

11010 r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;

11011 r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;

11012 r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;

11013

11014 return r;

11015 }

11016

11017 #endif /* GL_ARB_occlusion_query */

11018

11019 #ifdef GL_ARB_parallel_shader_compile

11020

11021 static GLboolean _glewInit_GL_ARB_parallel_shader_compile ()

11022 {

11023 GLboolean r = GL_FALSE;

11024

11025 r = ((glMaxShaderCompilerThreadsARB = (PFNGLMAXSHADERCOMPILERTHREADSARBPROC)glewGetProcAddress((const GLubyte*)"glMaxShaderCompilerThreadsARB")) == NULL) || r;

11026

11027 return r;

11028 }

11029

11030 #endif /* GL_ARB_parallel_shader_compile */

11031

11032 #ifdef GL_ARB_point_parameters

11033

11034 static GLboolean _glewInit_GL_ARB_point_parameters ()

11035 {

11036 GLboolean r = GL_FALSE;

11037

11038 r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;

11039 r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;

11040

11041 return r;

11042 }

11043

11044 #endif /* GL_ARB_point_parameters */

11045

11046 #ifdef GL_ARB_polygon_offset_clamp

11047

11048 static GLboolean _glewInit_GL_ARB_polygon_offset_clamp ()

11049 {

11050 GLboolean r = GL_FALSE;

11051

11052 r = ((glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetClamp")) == NULL) || r;

11053

11054 return r;

11055 }

11056

11057 #endif /* GL_ARB_polygon_offset_clamp */

11058

11059 #ifdef GL_ARB_program_interface_query

11060

11061 static GLboolean _glewInit_GL_ARB_program_interface_query ()

11062 {

11063 GLboolean r = GL_FALSE;

11064

11065 r = ((glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInterfaceiv")) == NULL) || r;

11066 r = ((glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceIndex")) == NULL) || r;

11067 r = ((glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocation")) == NULL) || r;

11068 r = ((glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocationIndex")) == NULL) || r;

11069 r = ((glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceName")) == NULL) || r;

11070 r = ((glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceiv")) == NULL) || r;

11071

11072 return r;

11073 }

11074

11075 #endif /* GL_ARB_program_interface_query */

11076

11077 #ifdef GL_ARB_provoking_vertex

11078

11079 static GLboolean _glewInit_GL_ARB_provoking_vertex ()

11080 {

11081 GLboolean r = GL_FALSE;

11082

11083 r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r;

11084

11085 return r;

11086 }

11087

11088 #endif /* GL_ARB_provoking_vertex */

11089

11090 #ifdef GL_ARB_robustness

11091

11092 static GLboolean _glewInit_GL_ARB_robustness ()

11093 {

11094 GLboolean r = GL_FALSE;

11095

11096 r = ((glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusARB")) == NULL) || r;

11097 r = ((glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnColorTableARB")) == NULL) || r;

11098 r = ((glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImageARB")) == NULL) || r;

11099 r = ((glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnConvolutionFilterARB")) == NULL) || r;

11100 r = ((glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glGetnHistogramARB")) == NULL) || r;

11101 r = ((glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapdvARB")) == NULL) || r;

11102 r = ((glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapfvARB")) == NULL) || r;

11103 r = ((glGetnMapivARB = (PFNGLGETNMAPIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapivARB")) == NULL) || r;

11104 r = ((glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMinmaxARB")) == NULL) || r;

11105 r = ((glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapfvARB")) == NULL) || r;

11106 r = ((glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapuivARB")) == NULL) || r;

11107 r = ((glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapusvARB")) == NULL) || r;

11108 r = ((glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPolygonStippleARB")) == NULL) || r;

11109 r = ((glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnSeparableFilterARB")) == NULL) || r;

11110 r = ((glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImageARB")) == NULL) || r;

11111 r = ((glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdvARB")) == NULL) || r;

11112 r = ((glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvARB")) == NULL) || r;

11113 r = ((glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivARB")) == NULL) || r;

11114 r = ((glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuivARB")) == NULL) || r;

11115 r = ((glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsARB")) == NULL) || r;

11116

11117 return r;

11118 }

11119

11120 #endif /* GL_ARB_robustness */

11121

11122 #ifdef GL_ARB_sample_locations

11123

11124 static GLboolean _glewInit_GL_ARB_sample_locations ()

11125 {

11126 GLboolean r = GL_FALSE;

11127

11128 r = ((glFramebufferSampleLocationsfvARB = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvARB")) == NULL) || r;

11129 r = ((glNamedFramebufferSampleLocationsfvARB = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvARB")) == NULL) || r;

11130

11131 return r;

11132 }

11133

11134 #endif /* GL_ARB_sample_locations */

11135

11136 #ifdef GL_ARB_sample_shading

11137

11138 static GLboolean _glewInit_GL_ARB_sample_shading ()

11139 {

11140 GLboolean r = GL_FALSE;

11141

11142 r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r;

11143

11144 return r;

11145 }

11146

11147 #endif /* GL_ARB_sample_shading */

11148

11149 #ifdef GL_ARB_sampler_objects

11150

11151 static GLboolean _glewInit_GL_ARB_sampler_objects ()

11152 {

11153 GLboolean r = GL_FALSE;

11154

11155 r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r;

11156 r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r;

11157 r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r;

11158 r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r;

11159 r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r;

11160 r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r;

11161 r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r;

11162 r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r;

11163 r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r;

11164 r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r;

11165 r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r;

11166 r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r;

11167 r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r;

11168 r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r;

11169

11170 return r;

11171 }

11172

11173 #endif /* GL_ARB_sampler_objects */

11174

11175 #ifdef GL_ARB_separate_shader_objects

11176

11177 static GLboolean _glewInit_GL_ARB_separate_shader_objects ()

11178 {

11179 GLboolean r = GL_FALSE;

11180

11181 r = ((glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glActiveShaderProgram")) == NULL) || r;

11182 r = ((glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glBindProgramPipeline")) == NULL) || r;

11183 r = ((glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramv")) == NULL) || r;

11184 r = ((glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramPipelines")) == NULL) || r;

11185 r = ((glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glGenProgramPipelines")) == NULL) || r;

11186 r = ((glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineInfoLog")) == NULL) || r;

11187 r = ((glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineiv")) == NULL) || r;

11188 r = ((glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glIsProgramPipeline")) == NULL) || r;

11189 r = ((glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1d")) == NULL) || r;

11190 r = ((glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dv")) == NULL) || r;

11191 r = ((glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1f")) == NULL) || r;

11192 r = ((glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fv")) == NULL) || r;

11193 r = ((glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i")) == NULL) || r;

11194 r = ((glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iv")) == NULL) || r;

11195 r = ((glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui")) == NULL) || r;

11196 r = ((glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiv")) == NULL) || r;

11197 r = ((glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2d")) == NULL) || r;

11198 r = ((glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dv")) == NULL) || r;

11199 r = ((glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2f")) == NULL) || r;

11200 r = ((glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fv")) == NULL) || r;

11201 r = ((glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i")) == NULL) || r;

11202 r = ((glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iv")) == NULL) || r;

11203 r = ((glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui")) == NULL) || r;

11204 r = ((glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiv")) == NULL) || r;

11205 r = ((glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3d")) == NULL) || r;

11206 r = ((glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dv")) == NULL) || r;

11207 r = ((glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3f")) == NULL) || r;

11208 r = ((glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fv")) == NULL) || r;

11209 r = ((glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i")) == NULL) || r;

11210 r = ((glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iv")) == NULL) || r;

11211 r = ((glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui")) == NULL) || r;

11212 r = ((glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiv")) == NULL) || r;

11213 r = ((glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4d")) == NULL) || r;

11214 r = ((glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dv")) == NULL) || r;

11215 r = ((glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4f")) == NULL) || r;

11216 r = ((glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fv")) == NULL) || r;

11217 r = ((glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i")) == NULL) || r;

11218 r = ((glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iv")) == NULL) || r;

11219 r = ((glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui")) == NULL) || r;

11220 r = ((glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiv")) == NULL) || r;

11221 r = ((glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dv")) == NULL) || r;

11222 r = ((glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fv")) == NULL) || r;

11223 r = ((glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dv")) == NULL) || r;

11224 r = ((glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fv")) == NULL) || r;

11225 r = ((glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dv")) == NULL) || r;

11226 r = ((glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fv")) == NULL) || r;

11227 r = ((glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dv")) == NULL) || r;

11228 r = ((glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fv")) == NULL) || r;

11229 r = ((glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dv")) == NULL) || r;

11230 r = ((glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fv")) == NULL) || r;

11231 r = ((glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dv")) == NULL) || r;

11232 r = ((glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fv")) == NULL) || r;

11233 r = ((glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dv")) == NULL) || r;

11234 r = ((glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fv")) == NULL) || r;

11235 r = ((glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dv")) == NULL) || r;

11236 r = ((glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fv")) == NULL) || r;

11237 r = ((glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dv")) == NULL) || r;

11238 r = ((glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fv")) == NULL) || r;

11239 r = ((glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glewGetProcAddress((const GLubyte*)"glUseProgramStages")) == NULL) || r;

11240 r = ((glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramPipeline")) == NULL) || r;

11241

11242 return r;

11243 }

11244

11245 #endif /* GL_ARB_separate_shader_objects */

11246

11247 #ifdef GL_ARB_shader_atomic_counters

11248

11249 static GLboolean _glewInit_GL_ARB_shader_atomic_counters ()

11250 {

11251 GLboolean r = GL_FALSE;

11252

11253 r = ((glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAtomicCounterBufferiv")) == NULL) || r;

11254

11255 return r;

11256 }

11257

11258 #endif /* GL_ARB_shader_atomic_counters */

11259

11260 #ifdef GL_ARB_shader_image_load_store

11261

11262 static GLboolean _glewInit_GL_ARB_shader_image_load_store ()

11263 {

11264 GLboolean r = GL_FALSE;

11265

11266 r = ((glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glBindImageTexture")) == NULL) || r;

11267 r = ((glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrier")) == NULL) || r;

11268

11269 return r;

11270 }

11271

11272 #endif /* GL_ARB_shader_image_load_store */

11273

11274 #ifdef GL_ARB_shader_objects

11275

11276 static GLboolean _glewInit_GL_ARB_shader_objects ()

11277 {

11278 GLboolean r = GL_FALSE;

11279

11280 r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;

11281 r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;

11282 r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;

11283 r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;

11284 r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;

11285 r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;

11286 r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;

11287 r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;

11288 r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;

11289 r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;

11290 r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;

11291 r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;

11292 r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;

11293 r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;

11294 r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;

11295 r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;

11296 r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;

11297 r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;

11298 r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;

11299 r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;

11300 r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;

11301 r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;

11302 r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;

11303 r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;

11304 r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;

11305 r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;

11306 r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;

11307 r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;

11308 r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;

11309 r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;

11310 r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;

11311 r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;

11312 r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;

11313 r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;

11314 r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;

11315 r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;

11316 r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;

11317 r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;

11318 r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;

11319

11320 return r;

11321 }

11322

11323 #endif /* GL_ARB_shader_objects */

11324

11325 #ifdef GL_ARB_shader_storage_buffer_object

11326

11327 static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object ()

11328 {

11329 GLboolean r = GL_FALSE;

11330

11331 r = ((glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glShaderStorageBlockBinding")) == NULL) || r;

11332

11333 return r;

11334 }

11335

11336 #endif /* GL_ARB_shader_storage_buffer_object */

11337

11338 #ifdef GL_ARB_shader_subroutine

11339

11340 static GLboolean _glewInit_GL_ARB_shader_subroutine ()

11341 {

11342 GLboolean r = GL_FALSE;

11343

11344 r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r;

11345 r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r;

11346 r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r;

11347 r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r;

11348 r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r;

11349 r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r;

11350 r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r;

11351 r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r;

11352

11353 return r;

11354 }

11355

11356 #endif /* GL_ARB_shader_subroutine */

11357

11358 #ifdef GL_ARB_shading_language_include

11359

11360 static GLboolean _glewInit_GL_ARB_shading_language_include ()

11361 {

11362 GLboolean r = GL_FALSE;

11363

11364 r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r;

11365 r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r;

11366 r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r;

11367 r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r;

11368 r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r;

11369 r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r;

11370

11371 return r;

11372 }

11373

11374 #endif /* GL_ARB_shading_language_include */

11375

11376 #ifdef GL_ARB_sparse_buffer

11377

11378 static GLboolean _glewInit_GL_ARB_sparse_buffer ()

11379 {

11380 GLboolean r = GL_FALSE;

11381

11382 r = ((glBufferPageCommitmentARB = (PFNGLBUFFERPAGECOMMITMENTARBPROC)glewGetProcAddress((const GLubyte*)"glBufferPageCommitmentARB")) == NULL) || r;

11383

11384 return r;

11385 }

11386

11387 #endif /* GL_ARB_sparse_buffer */

11388

11389 #ifdef GL_ARB_sparse_texture

11390

11391 static GLboolean _glewInit_GL_ARB_sparse_texture ()

11392 {

11393 GLboolean r = GL_FALSE;

11394

11395 r = ((glTexPageCommitmentARB = (PFNGLTEXPAGECOMMITMENTARBPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentARB")) == NULL) || r;

11396

11397 return r;

11398 }

11399

11400 #endif /* GL_ARB_sparse_texture */

11401

11402 #ifdef GL_ARB_sync

11403

11404 static GLboolean _glewInit_GL_ARB_sync ()

11405 {

11406 GLboolean r = GL_FALSE;

11407

11408 r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r;

11409 r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r;

11410 r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r;

11411 r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r;

11412 r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r;

11413 r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r;

11414 r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r;

11415

11416 return r;

11417 }

11418

11419 #endif /* GL_ARB_sync */

11420

11421 #ifdef GL_ARB_tessellation_shader

11422

11423 static GLboolean _glewInit_GL_ARB_tessellation_shader ()

11424 {

11425 GLboolean r = GL_FALSE;

11426

11427 r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r;

11428 r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r;

11429

11430 return r;

11431 }

11432

11433 #endif /* GL_ARB_tessellation_shader */

11434

11435 #ifdef GL_ARB_texture_barrier

11436

11437 static GLboolean _glewInit_GL_ARB_texture_barrier ()

11438 {

11439 GLboolean r = GL_FALSE;

11440

11441 r = ((glTextureBarrier = (PFNGLTEXTUREBARRIERPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrier")) == NULL) || r;

11442

11443 return r;

11444 }

11445

11446 #endif /* GL_ARB_texture_barrier */

11447

11448 #ifdef GL_ARB_texture_buffer_object

11449

11450 static GLboolean _glewInit_GL_ARB_texture_buffer_object ()

11451 {

11452 GLboolean r = GL_FALSE;

11453

11454 r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;

11455

11456 return r;

11457 }

11458

11459 #endif /* GL_ARB_texture_buffer_object */

11460

11461 #ifdef GL_ARB_texture_buffer_range

11462

11463 static GLboolean _glewInit_GL_ARB_texture_buffer_range ()

11464 {

11465 GLboolean r = GL_FALSE;

11466

11467 r = ((glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTexBufferRange")) == NULL) || r;

11468 r = ((glTextureBufferRangeEXT = (PFNGLTEXTUREBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferRangeEXT")) == NULL) || r;

11469

11470 return r;

11471 }

11472

11473 #endif /* GL_ARB_texture_buffer_range */

11474

11475 #ifdef GL_ARB_texture_compression

11476

11477 static GLboolean _glewInit_GL_ARB_texture_compression ()

11478 {

11479 GLboolean r = GL_FALSE;

11480

11481 r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;

11482 r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;

11483 r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;

11484 r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;

11485 r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;

11486 r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;

11487 r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;

11488

11489 return r;

11490 }

11491

11492 #endif /* GL_ARB_texture_compression */

11493

11494 #ifdef GL_ARB_texture_multisample

11495

11496 static GLboolean _glewInit_GL_ARB_texture_multisample ()

11497 {

11498 GLboolean r = GL_FALSE;

11499

11500 r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r;

11501 r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r;

11502 r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r;

11503 r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r;

11504

11505 return r;

11506 }

11507

11508 #endif /* GL_ARB_texture_multisample */

11509

11510 #ifdef GL_ARB_texture_storage

11511

11512 static GLboolean _glewInit_GL_ARB_texture_storage ()

11513 {

11514 GLboolean r = GL_FALSE;

11515

11516 r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r;

11517 r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r;

11518 r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r;

11519

11520 return r;

11521 }

11522

11523 #endif /* GL_ARB_texture_storage */

11524

11525 #ifdef GL_ARB_texture_storage_multisample

11526

11527 static GLboolean _glewInit_GL_ARB_texture_storage_multisample ()

11528 {

11529 GLboolean r = GL_FALSE;

11530

11531 r = ((glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2DMultisample")) == NULL) || r;

11532 r = ((glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DMultisample")) == NULL) || r;

11533 r = ((glTextureStorage2DMultisampleEXT = (PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DMultisampleEXT")) == NULL) || r;

11534 r = ((glTextureStorage3DMultisampleEXT = (PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DMultisampleEXT")) == NULL) || r;

11535

11536 return r;

11537 }

11538

11539 #endif /* GL_ARB_texture_storage_multisample */

11540

11541 #ifdef GL_ARB_texture_view

11542

11543 static GLboolean _glewInit_GL_ARB_texture_view ()

11544 {

11545 GLboolean r = GL_FALSE;

11546

11547 r = ((glTextureView = (PFNGLTEXTUREVIEWPROC)glewGetProcAddress((const GLubyte*)"glTextureView")) == NULL) || r;

11548

11549 return r;

11550 }

11551

11552 #endif /* GL_ARB_texture_view */

11553

11554 #ifdef GL_ARB_timer_query

11555

11556 static GLboolean _glewInit_GL_ARB_timer_query ()

11557 {

11558 GLboolean r = GL_FALSE;

11559

11560 r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r;

11561 r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r;

11562 r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r;

11563

11564 return r;

11565 }

11566

11567 #endif /* GL_ARB_timer_query */

11568

11569 #ifdef GL_ARB_transform_feedback2

11570

11571 static GLboolean _glewInit_GL_ARB_transform_feedback2 ()

11572 {

11573 GLboolean r = GL_FALSE;

11574

11575 r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r;

11576 r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r;

11577 r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r;

11578 r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r;

11579 r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r;

11580 r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r;

11581 r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r;

11582

11583 return r;

11584 }

11585

11586 #endif /* GL_ARB_transform_feedback2 */

11587

11588 #ifdef GL_ARB_transform_feedback3

11589

11590 static GLboolean _glewInit_GL_ARB_transform_feedback3 ()

11591 {

11592 GLboolean r = GL_FALSE;

11593

11594 r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r;

11595 r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r;

11596 r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r;

11597 r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r;

11598

11599 return r;

11600 }

11601

11602 #endif /* GL_ARB_transform_feedback3 */

11603

11604 #ifdef GL_ARB_transform_feedback_instanced

11605

11606 static GLboolean _glewInit_GL_ARB_transform_feedback_instanced ()

11607 {

11608 GLboolean r = GL_FALSE;

11609

11610 r = ((glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstanced")) == NULL) || r;

11611 r = ((glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStreamInstanced")) == NULL) || r;

11612

11613 return r;

11614 }

11615

11616 #endif /* GL_ARB_transform_feedback_instanced */

11617

11618 #ifdef GL_ARB_transpose_matrix

11619

11620 static GLboolean _glewInit_GL_ARB_transpose_matrix ()

11621 {

11622 GLboolean r = GL_FALSE;

11623

11624 r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r;

11625 r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r;

11626 r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r;

11627 r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r;

11628

11629 return r;

11630 }

11631

11632 #endif /* GL_ARB_transpose_matrix */

11633

11634 #ifdef GL_ARB_uniform_buffer_object

11635

11636 static GLboolean _glewInit_GL_ARB_uniform_buffer_object ()

11637 {

11638 GLboolean r = GL_FALSE;

11639

11640 r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;

11641 r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;

11642 r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r;

11643 r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r;

11644 r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r;

11645 r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r;

11646 r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;

11647 r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r;

11648 r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r;

11649 r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r;

11650

11651 return r;

11652 }

11653

11654 #endif /* GL_ARB_uniform_buffer_object */

11655

11656 #ifdef GL_ARB_vertex_array_object

11657

11658 static GLboolean _glewInit_GL_ARB_vertex_array_object ()

11659 {

11660 GLboolean r = GL_FALSE;

11661

11662 r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r;

11663 r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r;

11664 r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r;

11665 r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r;

11666

11667 return r;

11668 }

11669

11670 #endif /* GL_ARB_vertex_array_object */

11671

11672 #ifdef GL_ARB_vertex_attrib_64bit

11673

11674 static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit ()

11675 {

11676 GLboolean r = GL_FALSE;

11677

11678 r = ((glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdv")) == NULL) || r;

11679 r = ((glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1d")) == NULL) || r;

11680 r = ((glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dv")) == NULL) || r;

11681 r = ((glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2d")) == NULL) || r;

11682 r = ((glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dv")) == NULL) || r;

11683 r = ((glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3d")) == NULL) || r;

11684 r = ((glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dv")) == NULL) || r;

11685 r = ((glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4d")) == NULL) || r;

11686 r = ((glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dv")) == NULL) || r;

11687 r = ((glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointer")) == NULL) || r;

11688

11689 return r;

11690 }

11691

11692 #endif /* GL_ARB_vertex_attrib_64bit */

11693

11694 #ifdef GL_ARB_vertex_attrib_binding

11695

11696 static GLboolean _glewInit_GL_ARB_vertex_attrib_binding ()

11697 {

11698 GLboolean r = GL_FALSE;

11699

11700 r = ((glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffer")) == NULL) || r;

11701 r = ((glVertexArrayBindVertexBufferEXT = (PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayBindVertexBufferEXT")) == NULL) || r;

11702 r = ((glVertexArrayVertexAttribBindingEXT = (PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribBindingEXT")) == NULL) || r;

11703 r = ((glVertexArrayVertexAttribFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribFormatEXT")) == NULL) || r;

11704 r = ((glVertexArrayVertexAttribIFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIFormatEXT")) == NULL) || r;

11705 r = ((glVertexArrayVertexAttribLFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLFormatEXT")) == NULL) || r;

11706 r = ((glVertexArrayVertexBindingDivisorEXT = (PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexBindingDivisorEXT")) == NULL) || r;

11707 r = ((glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribBinding")) == NULL) || r;

11708 r = ((glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormat")) == NULL) || r;

11709 r = ((glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormat")) == NULL) || r;

11710 r = ((glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormat")) == NULL) || r;

11711 r = ((glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexBindingDivisor")) == NULL) || r;

11712

11713 return r;

11714 }

11715

11716 #endif /* GL_ARB_vertex_attrib_binding */

11717

11718 #ifdef GL_ARB_vertex_blend

11719

11720 static GLboolean _glewInit_GL_ARB_vertex_blend ()

11721 {

11722 GLboolean r = GL_FALSE;

11723

11724 r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r;

11725 r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r;

11726 r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r;

11727 r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r;

11728 r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r;

11729 r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r;

11730 r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r;

11731 r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r;

11732 r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r;

11733 r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r;

11734

11735 return r;

11736 }

11737

11738 #endif /* GL_ARB_vertex_blend */

11739

11740 #ifdef GL_ARB_vertex_buffer_object

11741

11742 static GLboolean _glewInit_GL_ARB_vertex_buffer_object ()

11743 {

11744 GLboolean r = GL_FALSE;

11745

11746 r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;

11747 r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;

11748 r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;

11749 r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;

11750 r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;

11751 r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;

11752 r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;

11753 r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;

11754 r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;

11755 r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;

11756 r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;

11757

11758 return r;

11759 }

11760

11761 #endif /* GL_ARB_vertex_buffer_object */

11762

11763 #ifdef GL_ARB_vertex_program

11764

11765 static GLboolean _glewInit_GL_ARB_vertex_program ()

11766 {

11767 GLboolean r = GL_FALSE;

11768

11769 r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;

11770 r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;

11771 r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;

11772 r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;

11773 r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;

11774 r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;

11775 r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;

11776 r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;

11777 r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;

11778 r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;

11779 r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;

11780 r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;

11781 r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;

11782 r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;

11783 r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;

11784 r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;

11785 r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;

11786 r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;

11787 r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;

11788 r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;

11789 r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;

11790 r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;

11791 r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;

11792 r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;

11793 r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;

11794 r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;

11795 r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;

11796 r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;

11797 r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;

11798 r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;

11799 r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;

11800 r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;

11801 r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;

11802 r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;

11803 r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;

11804 r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;

11805 r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;

11806 r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;

11807 r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;

11808 r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;

11809 r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;

11810 r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;

11811 r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;

11812 r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;

11813 r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;

11814 r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;

11815 r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;

11816 r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;

11817 r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;

11818 r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;

11819 r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;

11820 r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;

11821 r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;

11822 r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;

11823 r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;

11824 r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;

11825 r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;

11826 r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;

11827 r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;

11828 r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;

11829 r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;

11830 r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;

11831

11832 return r;

11833 }

11834

11835 #endif /* GL_ARB_vertex_program */

11836

11837 #ifdef GL_ARB_vertex_shader

11838

11839 static GLboolean _glewInit_GL_ARB_vertex_shader ()

11840 {

11841 GLboolean r = GL_FALSE;

11842

11843 r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;

11844 r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;

11845 r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;

11846

11847 return r;

11848 }

11849

11850 #endif /* GL_ARB_vertex_shader */

11851

11852 #ifdef GL_ARB_vertex_type_2_10_10_10_rev

11853

11854 static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev ()

11855 {

11856 GLboolean r = GL_FALSE;

11857

11858 r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r;

11859 r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r;

11860 r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r;

11861 r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r;

11862 r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r;

11863 r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r;

11864 r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r;

11865 r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r;

11866 r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r;

11867 r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r;

11868 r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r;

11869 r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r;

11870 r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r;

11871 r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r;

11872 r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r;

11873 r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r;

11874 r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r;

11875 r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r;

11876 r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r;

11877 r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r;

11878 r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r;

11879 r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r;

11880 r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r;

11881 r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r;

11882 r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r;

11883 r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r;

11884 r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r;

11885 r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r;

11886 r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r;

11887 r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r;

11888 r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r;

11889 r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r;

11890 r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r;

11891 r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r;

11892 r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r;

11893 r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r;

11894 r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r;

11895 r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r;

11896

11897 return r;

11898 }

11899

11900 #endif /* GL_ARB_vertex_type_2_10_10_10_rev */

11901

11902 #ifdef GL_ARB_viewport_array

11903

11904 static GLboolean _glewInit_GL_ARB_viewport_array ()

11905 {

11906 GLboolean r = GL_FALSE;

11907

11908 r = ((glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayv")) == NULL) || r;

11909 r = ((glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexed")) == NULL) || r;

11910 r = ((glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_v")) == NULL) || r;

11911 r = ((glGetFloati_v = (PFNGLGETFLOATI_VPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_v")) == NULL) || r;

11912 r = ((glScissorArrayv = (PFNGLSCISSORARRAYVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayv")) == NULL) || r;

11913 r = ((glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexed")) == NULL) || r;

11914 r = ((glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedv")) == NULL) || r;

11915 r = ((glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayv")) == NULL) || r;

11916 r = ((glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedf")) == NULL) || r;

11917 r = ((glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfv")) == NULL) || r;

11918

11919 return r;

11920 }

11921

11922 #endif /* GL_ARB_viewport_array */

11923

11924 #ifdef GL_ARB_window_pos

11925

11926 static GLboolean _glewInit_GL_ARB_window_pos ()

11927 {

11928 GLboolean r = GL_FALSE;

11929

11930 r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r;

11931 r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r;

11932 r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r;

11933 r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r;

11934 r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r;

11935 r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r;

11936 r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r;

11937 r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r;

11938 r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r;

11939 r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r;

11940 r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r;

11941 r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r;

11942 r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r;

11943 r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r;

11944 r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r;

11945 r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r;

11946

11947 return r;

11948 }

11949

11950 #endif /* GL_ARB_window_pos */

11951

11952 #ifdef GL_ATI_draw_buffers

11953

11954 static GLboolean _glewInit_GL_ATI_draw_buffers ()

11955 {

11956 GLboolean r = GL_FALSE;

11957

11958 r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;

11959

11960 return r;

11961 }

11962

11963 #endif /* GL_ATI_draw_buffers */

11964

11965 #ifdef GL_ATI_element_array

11966

11967 static GLboolean _glewInit_GL_ATI_element_array ()

11968 {

11969 GLboolean r = GL_FALSE;

11970

11971 r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r;

11972 r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r;

11973 r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r;

11974

11975 return r;

11976 }

11977

11978 #endif /* GL_ATI_element_array */

11979

11980 #ifdef GL_ATI_envmap_bumpmap

11981

11982 static GLboolean _glewInit_GL_ATI_envmap_bumpmap ()

11983 {

11984 GLboolean r = GL_FALSE;

11985

11986 r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r;

11987 r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r;

11988 r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r;

11989 r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r;

11990

11991 return r;

11992 }

11993

11994 #endif /* GL_ATI_envmap_bumpmap */

11995

11996 #ifdef GL_ATI_fragment_shader

11997

11998 static GLboolean _glewInit_GL_ATI_fragment_shader ()

11999 {

12000 GLboolean r = GL_FALSE;

12001

12002 r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;

12003 r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;

12004 r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;

12005 r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;

12006 r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;

12007 r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;

12008 r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;

12009 r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;

12010 r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;

12011 r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;

12012 r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;

12013 r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;

12014 r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;

12015 r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;

12016

12017 return r;

12018 }

12019

12020 #endif /* GL_ATI_fragment_shader */

12021

12022 #ifdef GL_ATI_map_object_buffer

12023

12024 static GLboolean _glewInit_GL_ATI_map_object_buffer ()

12025 {

12026 GLboolean r = GL_FALSE;

12027

12028 r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r;

12029 r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r;

12030

12031 return r;

12032 }

12033

12034 #endif /* GL_ATI_map_object_buffer */

12035

12036 #ifdef GL_ATI_pn_triangles

12037

12038 static GLboolean _glewInit_GL_ATI_pn_triangles ()

12039 {

12040 GLboolean r = GL_FALSE;

12041

12042 r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r;

12043 r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r;

12044

12045 return r;

12046 }

12047

12048 #endif /* GL_ATI_pn_triangles */

12049

12050 #ifdef GL_ATI_separate_stencil

12051

12052 static GLboolean _glewInit_GL_ATI_separate_stencil ()

12053 {

12054 GLboolean r = GL_FALSE;

12055

12056 r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r;

12057 r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r;

12058

12059 return r;

12060 }

12061

12062 #endif /* GL_ATI_separate_stencil */

12063

12064 #ifdef GL_ATI_vertex_array_object

12065

12066 static GLboolean _glewInit_GL_ATI_vertex_array_object ()

12067 {

12068 GLboolean r = GL_FALSE;

12069

12070 r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r;

12071 r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r;

12072 r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r;

12073 r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r;

12074 r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r;

12075 r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r;

12076 r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r;

12077 r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r;

12078 r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r;

12079 r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r;

12080 r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r;

12081 r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r;

12082

12083 return r;

12084 }

12085

12086 #endif /* GL_ATI_vertex_array_object */

12087

12088 #ifdef GL_ATI_vertex_attrib_array_object

12089

12090 static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object ()

12091 {

12092 GLboolean r = GL_FALSE;

12093

12094 r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r;

12095 r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r;

12096 r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r;

12097

12098 return r;

12099 }

12100

12101 #endif /* GL_ATI_vertex_attrib_array_object */

12102

12103 #ifdef GL_ATI_vertex_streams

12104

12105 static GLboolean _glewInit_GL_ATI_vertex_streams ()

12106 {

12107 GLboolean r = GL_FALSE;

12108

12109 r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r;

12110 r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r;

12111 r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r;

12112 r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r;

12113 r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r;

12114 r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r;

12115 r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r;

12116 r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r;

12117 r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r;

12118 r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r;

12119 r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r;

12120 r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r;

12121 r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r;

12122 r = ((glVertexStream1dATI = (PFNGLVERTEXSTREAM1DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dATI")) == NULL) || r;

12123 r = ((glVertexStream1dvATI = (PFNGLVERTEXSTREAM1DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dvATI")) == NULL) || r;

12124 r = ((glVertexStream1fATI = (PFNGLVERTEXSTREAM1FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fATI")) == NULL) || r;

12125 r = ((glVertexStream1fvATI = (PFNGLVERTEXSTREAM1FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fvATI")) == NULL) || r;

12126 r = ((glVertexStream1iATI = (PFNGLVERTEXSTREAM1IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1iATI")) == NULL) || r;

12127 r = ((glVertexStream1ivATI = (PFNGLVERTEXSTREAM1IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1ivATI")) == NULL) || r;

12128 r = ((glVertexStream1sATI = (PFNGLVERTEXSTREAM1SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1sATI")) == NULL) || r;

12129 r = ((glVertexStream1svATI = (PFNGLVERTEXSTREAM1SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1svATI")) == NULL) || r;

12130 r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r;

12131 r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r;

12132 r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r;

12133 r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r;

12134 r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r;

12135 r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r;

12136 r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r;

12137 r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r;

12138 r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r;

12139 r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r;

12140 r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r;

12141 r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r;

12142 r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r;

12143 r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r;

12144 r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r;

12145 r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r;

12146 r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r;

12147 r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r;

12148 r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r;

12149 r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r;

12150 r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r;

12151 r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r;

12152 r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r;

12153 r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r;

12154

12155 return r;

12156 }

12157

12158 #endif /* GL_ATI_vertex_streams */

12159

12160 #ifdef GL_EXT_base_instance

12161

12162 static GLboolean _glewInit_GL_EXT_base_instance ()

12163 {

12164 GLboolean r = GL_FALSE;

12165

12166 r = ((glDrawArraysInstancedBaseInstanceEXT = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstanceEXT")) == NULL) || r;

12167 r = ((glDrawElementsInstancedBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstanceEXT")) == NULL) || r;

12168 r = ((glDrawElementsInstancedBaseVertexBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstanceEXT")) == NULL) || r;

12169

12170 return r;

12171 }

12172

12173 #endif /* GL_EXT_base_instance */

12174

12175 #ifdef GL_EXT_bindable_uniform

12176

12177 static GLboolean _glewInit_GL_EXT_bindable_uniform ()

12178 {

12179 GLboolean r = GL_FALSE;

12180

12181 r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r;

12182 r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r;

12183 r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r;

12184

12185 return r;

12186 }

12187

12188 #endif /* GL_EXT_bindable_uniform */

12189

12190 #ifdef GL_EXT_blend_color

12191

12192 static GLboolean _glewInit_GL_EXT_blend_color ()

12193 {

12194 GLboolean r = GL_FALSE;

12195

12196 r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r;

12197

12198 return r;

12199 }

12200

12201 #endif /* GL_EXT_blend_color */

12202

12203 #ifdef GL_EXT_blend_equation_separate

12204

12205 static GLboolean _glewInit_GL_EXT_blend_equation_separate ()

12206 {

12207 GLboolean r = GL_FALSE;

12208

12209 r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r;

12210

12211 return r;

12212 }

12213

12214 #endif /* GL_EXT_blend_equation_separate */

12215

12216 #ifdef GL_EXT_blend_func_extended

12217

12218 static GLboolean _glewInit_GL_EXT_blend_func_extended ()

12219 {

12220 GLboolean r = GL_FALSE;

12221

12222 r = ((glBindFragDataLocationIndexedEXT = (PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexedEXT")) == NULL) || r;

12223 r = ((glGetFragDataIndexEXT = (PFNGLGETFRAGDATAINDEXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndexEXT")) == NULL) || r;

12224 r = ((glGetProgramResourceLocationIndexEXT = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocationIndexEXT")) == NULL) || r;

12225

12226 return r;

12227 }

12228

12229 #endif /* GL_EXT_blend_func_extended */

12230

12231 #ifdef GL_EXT_blend_func_separate

12232

12233 static GLboolean _glewInit_GL_EXT_blend_func_separate ()

12234 {

12235 GLboolean r = GL_FALSE;

12236

12237 r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r;

12238

12239 return r;

12240 }

12241

12242 #endif /* GL_EXT_blend_func_separate */

12243

12244 #ifdef GL_EXT_blend_minmax

12245

12246 static GLboolean _glewInit_GL_EXT_blend_minmax ()

12247 {

12248 GLboolean r = GL_FALSE;

12249

12250 r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r;

12251

12252 return r;

12253 }

12254

12255 #endif /* GL_EXT_blend_minmax */

12256

12257 #ifdef GL_EXT_buffer_storage

12258

12259 static GLboolean _glewInit_GL_EXT_buffer_storage ()

12260 {

12261 GLboolean r = GL_FALSE;

12262

12263 r = ((glBufferStorageEXT = (PFNGLBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageEXT")) == NULL) || r;

12264 r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r;

12265

12266 return r;

12267 }

12268

12269 #endif /* GL_EXT_buffer_storage */

12270

12271 #ifdef GL_EXT_clear_texture

12272

12273 static GLboolean _glewInit_GL_EXT_clear_texture ()

12274 {

12275 GLboolean r = GL_FALSE;

12276

12277 r = ((glClearTexImageEXT = (PFNGLCLEARTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glClearTexImageEXT")) == NULL) || r;

12278 r = ((glClearTexSubImageEXT = (PFNGLCLEARTEXSUBIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glClearTexSubImageEXT")) == NULL) || r;

12279

12280 return r;

12281 }

12282

12283 #endif /* GL_EXT_clear_texture */

12284

12285 #ifdef GL_EXT_color_subtable

12286

12287 static GLboolean _glewInit_GL_EXT_color_subtable ()

12288 {

12289 GLboolean r = GL_FALSE;

12290

12291 r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r;

12292 r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r;

12293

12294 return r;

12295 }

12296

12297 #endif /* GL_EXT_color_subtable */

12298

12299 #ifdef GL_EXT_compiled_vertex_array

12300

12301 static GLboolean _glewInit_GL_EXT_compiled_vertex_array ()

12302 {

12303 GLboolean r = GL_FALSE;

12304

12305 r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r;

12306 r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r;

12307

12308 return r;

12309 }

12310

12311 #endif /* GL_EXT_compiled_vertex_array */

12312

12313 #ifdef GL_EXT_convolution

12314

12315 static GLboolean _glewInit_GL_EXT_convolution ()

12316 {

12317 GLboolean r = GL_FALSE;

12318

12319 r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r;

12320 r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r;

12321 r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r;

12322 r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r;

12323 r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r;

12324 r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r;

12325 r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r;

12326 r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r;

12327 r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r;

12328 r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r;

12329 r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r;

12330 r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r;

12331 r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r;

12332

12333 return r;

12334 }

12335

12336 #endif /* GL_EXT_convolution */

12337

12338 #ifdef GL_EXT_coordinate_frame

12339

12340 static GLboolean _glewInit_GL_EXT_coordinate_frame ()

12341 {

12342 GLboolean r = GL_FALSE;

12343

12344 r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r;

12345 r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r;

12346

12347 return r;

12348 }

12349

12350 #endif /* GL_EXT_coordinate_frame */

12351

12352 #ifdef GL_EXT_copy_image

12353

12354 static GLboolean _glewInit_GL_EXT_copy_image ()

12355 {

12356 GLboolean r = GL_FALSE;

12357

12358 r = ((glCopyImageSubDataEXT = (PFNGLCOPYIMAGESUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataEXT")) == NULL) || r;

12359

12360 return r;

12361 }

12362

12363 #endif /* GL_EXT_copy_image */

12364

12365 #ifdef GL_EXT_copy_texture

12366

12367 static GLboolean _glewInit_GL_EXT_copy_texture ()

12368 {

12369 GLboolean r = GL_FALSE;

12370

12371 r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r;

12372 r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r;

12373 r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r;

12374 r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r;

12375 r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r;

12376

12377 return r;

12378 }

12379

12380 #endif /* GL_EXT_copy_texture */

12381

12382 #ifdef GL_EXT_cull_vertex

12383

12384 static GLboolean _glewInit_GL_EXT_cull_vertex ()

12385 {

12386 GLboolean r = GL_FALSE;

12387

12388 r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r;

12389 r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r;

12390

12391 return r;

12392 }

12393

12394 #endif /* GL_EXT_cull_vertex */

12395

12396 #ifdef GL_EXT_debug_label

12397

12398 static GLboolean _glewInit_GL_EXT_debug_label ()

12399 {

12400 GLboolean r = GL_FALSE;

12401

12402 r = ((glGetObjectLabelEXT = (PFNGLGETOBJECTLABELEXTPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabelEXT")) == NULL) || r;

12403 r = ((glLabelObjectEXT = (PFNGLLABELOBJECTEXTPROC)glewGetProcAddress((const GLubyte*)"glLabelObjectEXT")) == NULL) || r;

12404

12405 return r;

12406 }

12407

12408 #endif /* GL_EXT_debug_label */

12409

12410 #ifdef GL_EXT_debug_marker

12411

12412 static GLboolean _glewInit_GL_EXT_debug_marker ()

12413 {

12414 GLboolean r = GL_FALSE;

12415

12416 r = ((glInsertEventMarkerEXT = (PFNGLINSERTEVENTMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glInsertEventMarkerEXT")) == NULL) || r;

12417 r = ((glPopGroupMarkerEXT = (PFNGLPOPGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPopGroupMarkerEXT")) == NULL) || r;

12418 r = ((glPushGroupMarkerEXT = (PFNGLPUSHGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPushGroupMarkerEXT")) == NULL) || r;

12419

12420 return r;

12421 }

12422

12423 #endif /* GL_EXT_debug_marker */

12424

12425 #ifdef GL_EXT_depth_bounds_test

12426

12427 static GLboolean _glewInit_GL_EXT_depth_bounds_test ()

12428 {

12429 GLboolean r = GL_FALSE;

12430

12431 r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r;

12432

12433 return r;

12434 }

12435

12436 #endif /* GL_EXT_depth_bounds_test */

12437

12438 #ifdef GL_EXT_direct_state_access

12439

12440 static GLboolean _glewInit_GL_EXT_direct_state_access ()

12441 {

12442 GLboolean r = GL_FALSE;

12443

12444 r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r;

12445 r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r;

12446 r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r;

12447 r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r;

12448 r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r;

12449 r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r;

12450 r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r;

12451 r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r;

12452 r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r;

12453 r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r;

12454 r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r;

12455 r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r;

12456 r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r;

12457 r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r;

12458 r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r;

12459 r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r;

12460 r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r;

12461 r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r;

12462 r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r;

12463 r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r;

12464 r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r;

12465 r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r;

12466 r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r;

12467 r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r;

12468 r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r;

12469 r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r;

12470 r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r;

12471 r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r;

12472 r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r;

12473 r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r;

12474 r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r;

12475 r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r;

12476 r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r;

12477 r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r;

12478 r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r;

12479 r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r;

12480 r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r;

12481 r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r;

12482 r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r;

12483 r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r;

12484 r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r;

12485 r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r;

12486 r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r;

12487 r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r;

12488 r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r;

12489 r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r;

12490 r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r;

12491 r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r;

12492 r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r;

12493 r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r;

12494 r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r;

12495 r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r;

12496 r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r;

12497 r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r;

12498 r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r;

12499 r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r;

12500 r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r;

12501 r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r;

12502 r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r;

12503 r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r;

12504 r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r;

12505 r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r;

12506 r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r;

12507 r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r;

12508 r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r;

12509 r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r;

12510 r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r;

12511 r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r;

12512 r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r;

12513 r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r;

12514 r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r;

12515 r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r;

12516 r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r;

12517 r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r;

12518 r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r;

12519 r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r;

12520 r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r;

12521 r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r;

12522 r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r;

12523 r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r;

12524 r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r;

12525 r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r;

12526 r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r;

12527 r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r;

12528 r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r;

12529 r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r;

12530 r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r;

12531 r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r;

12532 r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r;

12533 r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r;

12534 r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r;

12535 r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r;

12536 r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r;

12537 r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r;

12538 r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r;

12539 r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r;

12540 r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r;

12541 r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r;

12542 r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r;

12543 r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r;

12544 r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r;

12545 r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r;

12546 r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r;

12547 r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r;

12548 r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r;

12549 r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r;

12550 r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r;

12551 r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r;

12552 r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r;

12553 r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r;

12554 r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r;

12555 r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r;

12556 r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r;

12557 r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r;

12558 r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r;

12559 r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r;

12560 r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r;

12561 r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r;

12562 r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r;

12563 r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r;

12564 r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r;

12565 r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r;

12566 r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r;

12567 r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r;

12568 r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r;

12569 r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r;

12570 r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r;

12571 r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;

12572 r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;

12573 r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;

12574 r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r;

12575 r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;

12576 r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r;

12577 r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r;

12578 r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r;

12579 r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r;

12580 r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r;

12581 r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r;

12582 r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r;

12583 r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r;

12584 r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r;

12585 r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r;

12586 r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r;

12587 r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r;

12588 r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r;

12589 r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r;

12590 r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r;

12591 r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r;

12592 r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r;

12593 r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r;

12594 r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r;

12595 r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r;

12596 r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r;

12597 r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r;

12598 r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r;

12599 r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r;

12600 r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r;

12601 r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r;

12602 r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r;

12603 r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r;

12604 r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r;

12605 r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r;

12606 r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r;

12607 r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r;

12608 r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r;

12609 r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r;

12610 r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r;

12611 r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r;

12612 r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r;

12613 r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r;

12614 r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r;

12615 r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r;

12616 r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r;

12617 r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r;

12618 r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r;

12619 r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r;

12620 r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r;

12621 r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r;

12622 r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r;

12623 r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r;

12624 r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r;

12625 r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r;

12626 r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r;

12627 r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r;

12628 r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r;

12629 r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r;

12630 r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r;

12631 r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r;

12632 r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r;

12633 r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r;

12634 r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r;

12635 r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r;

12636 r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r;

12637 r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r;

12638 r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r;

12639 r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r;

12640 r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r;

12641 r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r;

12642 r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r;

12643 r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r;

12644 r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r;

12645 r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r;

12646 r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r;

12647 r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r;

12648 r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r;

12649 r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r;

12650 r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r;

12651 r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r;

12652 r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r;

12653 r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r;

12654 r = ((glVertexArrayVertexAttribDivisorEXT = (PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribDivisorEXT")) == NULL) || r;

12655 r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r;

12656 r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r;

12657 r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r;

12658

12659 return r;

12660 }

12661

12662 #endif /* GL_EXT_direct_state_access */

12663

12664 #ifdef GL_EXT_discard_framebuffer

12665

12666 static GLboolean _glewInit_GL_EXT_discard_framebuffer ()

12667 {

12668 GLboolean r = GL_FALSE;

12669

12670 r = ((glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glDiscardFramebufferEXT")) == NULL) || r;

12671

12672 return r;

12673 }

12674

12675 #endif /* GL_EXT_discard_framebuffer */

12676

12677 #ifdef GL_EXT_draw_buffers

12678

12679 static GLboolean _glewInit_GL_EXT_draw_buffers ()

12680 {

12681 GLboolean r = GL_FALSE;

12682

12683 r = ((glDrawBuffersEXT = (PFNGLDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersEXT")) == NULL) || r;

12684

12685 return r;

12686 }

12687

12688 #endif /* GL_EXT_draw_buffers */

12689

12690 #ifdef GL_EXT_draw_buffers2

12691

12692 static GLboolean _glewInit_GL_EXT_draw_buffers2 ()

12693 {

12694 GLboolean r = GL_FALSE;

12695

12696 r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r;

12697 r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r;

12698 r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r;

12699 r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r;

12700 r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r;

12701 r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r;

12702

12703 return r;

12704 }

12705

12706 #endif /* GL_EXT_draw_buffers2 */

12707

12708 #ifdef GL_EXT_draw_buffers_indexed

12709

12710 static GLboolean _glewInit_GL_EXT_draw_buffers_indexed ()

12711 {

12712 GLboolean r = GL_FALSE;

12713

12714 r = ((glBlendEquationSeparateiEXT = (PFNGLBLENDEQUATIONSEPARATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiEXT")) == NULL) || r;

12715 r = ((glBlendEquationiEXT = (PFNGLBLENDEQUATIONIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiEXT")) == NULL) || r;

12716 r = ((glBlendFuncSeparateiEXT = (PFNGLBLENDFUNCSEPARATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiEXT")) == NULL) || r;

12717 r = ((glBlendFunciEXT = (PFNGLBLENDFUNCIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciEXT")) == NULL) || r;

12718 r = ((glColorMaskiEXT = (PFNGLCOLORMASKIEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskiEXT")) == NULL) || r;

12719 r = ((glDisableiEXT = (PFNGLDISABLEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableiEXT")) == NULL) || r;

12720 r = ((glEnableiEXT = (PFNGLENABLEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableiEXT")) == NULL) || r;

12721 r = ((glIsEnablediEXT = (PFNGLISENABLEDIEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnablediEXT")) == NULL) || r;

12722

12723 return r;

12724 }

12725

12726 #endif /* GL_EXT_draw_buffers_indexed */

12727

12728 #ifdef GL_EXT_draw_elements_base_vertex

12729

12730 static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex ()

12731 {

12732 GLboolean r = GL_FALSE;

12733

12734 r = ((glDrawElementsBaseVertexEXT = (PFNGLDRAWELEMENTSBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertexEXT")) == NULL) || r;

12735 r = ((glDrawElementsInstancedBaseVertexEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexEXT")) == NULL) || r;

12736 r = ((glDrawRangeElementsBaseVertexEXT = (PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertexEXT")) == NULL) || r;

12737 r = ((glMultiDrawElementsBaseVertexEXT = (PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertexEXT")) == NULL) || r;

12738

12739 return r;

12740 }

12741

12742 #endif /* GL_EXT_draw_elements_base_vertex */

12743

12744 #ifdef GL_EXT_draw_instanced

12745

12746 static GLboolean _glewInit_GL_EXT_draw_instanced ()

12747 {

12748 GLboolean r = GL_FALSE;

12749

12750 r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r;

12751 r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r;

12752

12753 return r;

12754 }

12755

12756 #endif /* GL_EXT_draw_instanced */

12757

12758 #ifdef GL_EXT_draw_range_elements

12759

12760 static GLboolean _glewInit_GL_EXT_draw_range_elements ()

12761 {

12762 GLboolean r = GL_FALSE;

12763

12764 r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r;

12765

12766 return r;

12767 }

12768

12769 #endif /* GL_EXT_draw_range_elements */

12770

12771 #ifdef GL_EXT_external_buffer

12772

12773 static GLboolean _glewInit_GL_EXT_external_buffer ()

12774 {

12775 GLboolean r = GL_FALSE;

12776

12777 r = ((glBufferStorageExternalEXT = (PFNGLBUFFERSTORAGEEXTERNALEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageExternalEXT")) == NULL) || r;

12778 r = ((glNamedBufferStorageExternalEXT = (PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageExternalEXT")) == NULL) || r;

12779

12780 return r;

12781 }

12782

12783 #endif /* GL_EXT_external_buffer */

12784

12785 #ifdef GL_EXT_fog_coord

12786

12787 static GLboolean _glewInit_GL_EXT_fog_coord ()

12788 {

12789 GLboolean r = GL_FALSE;

12790

12791 r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r;

12792 r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r;

12793 r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r;

12794 r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r;

12795 r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r;

12796

12797 return r;

12798 }

12799

12800 #endif /* GL_EXT_fog_coord */

12801

12802 #ifdef GL_EXT_fragment_lighting

12803

12804 static GLboolean _glewInit_GL_EXT_fragment_lighting ()

12805 {

12806 GLboolean r = GL_FALSE;

12807

12808 r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r;

12809 r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r;

12810 r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r;

12811 r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r;

12812 r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r;

12813 r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r;

12814 r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r;

12815 r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r;

12816 r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r;

12817 r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r;

12818 r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r;

12819 r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r;

12820 r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r;

12821 r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r;

12822 r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r;

12823 r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r;

12824 r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r;

12825 r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r;

12826

12827 return r;

12828 }

12829

12830 #endif /* GL_EXT_fragment_lighting */

12831

12832 #ifdef GL_EXT_framebuffer_blit

12833

12834 static GLboolean _glewInit_GL_EXT_framebuffer_blit ()

12835 {

12836 GLboolean r = GL_FALSE;

12837

12838 r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r;

12839

12840 return r;

12841 }

12842

12843 #endif /* GL_EXT_framebuffer_blit */

12844

12845 #ifdef GL_EXT_framebuffer_multisample

12846

12847 static GLboolean _glewInit_GL_EXT_framebuffer_multisample ()

12848 {

12849 GLboolean r = GL_FALSE;

12850

12851 r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r;

12852

12853 return r;

12854 }

12855

12856 #endif /* GL_EXT_framebuffer_multisample */

12857

12858 #ifdef GL_EXT_framebuffer_object

12859

12860 static GLboolean _glewInit_GL_EXT_framebuffer_object ()

12861 {

12862 GLboolean r = GL_FALSE;

12863

12864 r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;

12865 r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;

12866 r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;

12867 r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;

12868 r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;

12869 r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;

12870 r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;

12871 r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;

12872 r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;

12873 r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;

12874 r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;

12875 r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;

12876 r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;

12877 r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;

12878 r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;

12879 r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;

12880 r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;

12881

12882 return r;

12883 }

12884

12885 #endif /* GL_EXT_framebuffer_object */

12886

12887 #ifdef GL_EXT_geometry_shader4

12888

12889 static GLboolean _glewInit_GL_EXT_geometry_shader4 ()

12890 {

12891 GLboolean r = GL_FALSE;

12892

12893 r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r;

12894 r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r;

12895 r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r;

12896

12897 return r;

12898 }

12899

12900 #endif /* GL_EXT_geometry_shader4 */

12901

12902 #ifdef GL_EXT_gpu_program_parameters

12903

12904 static GLboolean _glewInit_GL_EXT_gpu_program_parameters ()

12905 {

12906 GLboolean r = GL_FALSE;

12907

12908 r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r;

12909 r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r;

12910

12911 return r;

12912 }

12913

12914 #endif /* GL_EXT_gpu_program_parameters */

12915

12916 #ifdef GL_EXT_gpu_shader4

12917

12918 static GLboolean _glewInit_GL_EXT_gpu_shader4 ()

12919 {

12920 GLboolean r = GL_FALSE;

12921

12922 r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r;

12923 r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r;

12924 r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r;

12925 r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r;

12926 r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r;

12927 r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r;

12928 r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r;

12929 r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r;

12930 r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r;

12931 r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r;

12932 r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r;

12933 r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r;

12934 r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r;

12935 r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r;

12936 r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r;

12937 r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r;

12938 r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r;

12939 r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r;

12940 r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r;

12941 r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r;

12942 r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r;

12943 r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r;

12944 r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r;

12945 r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r;

12946 r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r;

12947 r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r;

12948 r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r;

12949 r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r;

12950 r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r;

12951 r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r;

12952 r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r;

12953 r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r;

12954 r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r;

12955 r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r;

12956

12957 return r;

12958 }

12959

12960 #endif /* GL_EXT_gpu_shader4 */

12961

12962 #ifdef GL_EXT_histogram

12963

12964 static GLboolean _glewInit_GL_EXT_histogram ()

12965 {

12966 GLboolean r = GL_FALSE;

12967

12968 r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r;

12969 r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r;

12970 r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r;

12971 r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r;

12972 r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r;

12973 r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r;

12974 r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r;

12975 r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r;

12976 r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r;

12977 r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r;

12978

12979 return r;

12980 }

12981

12982 #endif /* GL_EXT_histogram */

12983

12984 #ifdef GL_EXT_index_func

12985

12986 static GLboolean _glewInit_GL_EXT_index_func ()

12987 {

12988 GLboolean r = GL_FALSE;

12989

12990 r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r;

12991

12992 return r;

12993 }

12994

12995 #endif /* GL_EXT_index_func */

12996

12997 #ifdef GL_EXT_index_material

12998

12999 static GLboolean _glewInit_GL_EXT_index_material ()

13000 {

13001 GLboolean r = GL_FALSE;

13002

13003 r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r;

13004

13005 return r;

13006 }

13007

13008 #endif /* GL_EXT_index_material */

13009

13010 #ifdef GL_EXT_instanced_arrays

13011

13012 static GLboolean _glewInit_GL_EXT_instanced_arrays ()

13013 {

13014 GLboolean r = GL_FALSE;

13015

13016 r = ((glVertexAttribDivisorEXT = (PFNGLVERTEXATTRIBDIVISOREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorEXT")) == NULL) || r;

13017

13018 return r;

13019 }

13020

13021 #endif /* GL_EXT_instanced_arrays */

13022

13023 #ifdef GL_EXT_light_texture

13024

13025 static GLboolean _glewInit_GL_EXT_light_texture ()

13026 {

13027 GLboolean r = GL_FALSE;

13028

13029 r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r;

13030 r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r;

13031 r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r;

13032

13033 return r;

13034 }

13035

13036 #endif /* GL_EXT_light_texture */

13037

13038 #ifdef GL_EXT_map_buffer_range

13039

13040 static GLboolean _glewInit_GL_EXT_map_buffer_range ()

13041 {

13042 GLboolean r = GL_FALSE;

13043

13044 r = ((glFlushMappedBufferRangeEXT = (PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeEXT")) == NULL) || r;

13045 r = ((glMapBufferRangeEXT = (PFNGLMAPBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRangeEXT")) == NULL) || r;

13046

13047 return r;

13048 }

13049

13050 #endif /* GL_EXT_map_buffer_range */

13051

13052 #ifdef GL_EXT_memory_object

13053

13054 static GLboolean _glewInit_GL_EXT_memory_object ()

13055 {

13056 GLboolean r = GL_FALSE;

13057

13058 r = ((glBufferStorageMemEXT = (PFNGLBUFFERSTORAGEMEMEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageMemEXT")) == NULL) || r;

13059 r = ((glCreateMemoryObjectsEXT = (PFNGLCREATEMEMORYOBJECTSEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateMemoryObjectsEXT")) == NULL) || r;

13060 r = ((glDeleteMemoryObjectsEXT = (PFNGLDELETEMEMORYOBJECTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteMemoryObjectsEXT")) == NULL) || r;

13061 r = ((glGetMemoryObjectParameterivEXT = (PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMemoryObjectParameterivEXT")) == NULL) || r;

13062 r = ((glGetUnsignedBytei_vEXT = (PFNGLGETUNSIGNEDBYTEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUnsignedBytei_vEXT")) == NULL) || r;

13063 r = ((glGetUnsignedBytevEXT = (PFNGLGETUNSIGNEDBYTEVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUnsignedBytevEXT")) == NULL) || r;

13064 r = ((glIsMemoryObjectEXT = (PFNGLISMEMORYOBJECTEXTPROC)glewGetProcAddress((const GLubyte*)"glIsMemoryObjectEXT")) == NULL) || r;

13065 r = ((glMemoryObjectParameterivEXT = (PFNGLMEMORYOBJECTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryObjectParameterivEXT")) == NULL) || r;

13066 r = ((glNamedBufferStorageMemEXT = (PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageMemEXT")) == NULL) || r;

13067 r = ((glTexStorageMem1DEXT = (PFNGLTEXSTORAGEMEM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem1DEXT")) == NULL) || r;

13068 r = ((glTexStorageMem2DEXT = (PFNGLTEXSTORAGEMEM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem2DEXT")) == NULL) || r;

13069 r = ((glTexStorageMem2DMultisampleEXT = (PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem2DMultisampleEXT")) == NULL) || r;

13070 r = ((glTexStorageMem3DEXT = (PFNGLTEXSTORAGEMEM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem3DEXT")) == NULL) || r;

13071 r = ((glTexStorageMem3DMultisampleEXT = (PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem3DMultisampleEXT")) == NULL) || r;

13072 r = ((glTextureStorageMem1DEXT = (PFNGLTEXTURESTORAGEMEM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem1DEXT")) == NULL) || r;

13073 r = ((glTextureStorageMem2DEXT = (PFNGLTEXTURESTORAGEMEM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem2DEXT")) == NULL) || r;

13074 r = ((glTextureStorageMem2DMultisampleEXT = (PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem2DMultisampleEXT")) == NULL) || r;

13075 r = ((glTextureStorageMem3DEXT = (PFNGLTEXTURESTORAGEMEM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem3DEXT")) == NULL) || r;

13076 r = ((glTextureStorageMem3DMultisampleEXT = (PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem3DMultisampleEXT")) == NULL) || r;

13077

13078 return r;

13079 }

13080

13081 #endif /* GL_EXT_memory_object */

13082

13083 #ifdef GL_EXT_memory_object_fd

13084

13085 static GLboolean _glewInit_GL_EXT_memory_object_fd ()

13086 {

13087 GLboolean r = GL_FALSE;

13088

13089 r = ((glImportMemoryFdEXT = (PFNGLIMPORTMEMORYFDEXTPROC)glewGetProcAddress((const GLubyte*)"glImportMemoryFdEXT")) == NULL) || r;

13090

13091 return r;

13092 }

13093

13094 #endif /* GL_EXT_memory_object_fd */

13095

13096 #ifdef GL_EXT_memory_object_win32

13097

13098 static GLboolean _glewInit_GL_EXT_memory_object_win32 ()

13099 {

13100 GLboolean r = GL_FALSE;

13101

13102 r = ((glImportMemoryWin32HandleEXT = (PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportMemoryWin32HandleEXT")) == NULL) || r;

13103 r = ((glImportMemoryWin32NameEXT = (PFNGLIMPORTMEMORYWIN32NAMEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportMemoryWin32NameEXT")) == NULL) || r;

13104

13105 return r;

13106 }

13107

13108 #endif /* GL_EXT_memory_object_win32 */

13109

13110 #ifdef GL_EXT_multi_draw_arrays

13111

13112 static GLboolean _glewInit_GL_EXT_multi_draw_arrays ()

13113 {

13114 GLboolean r = GL_FALSE;

13115

13116 r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r;

13117 r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r;

13118

13119 return r;

13120 }

13121

13122 #endif /* GL_EXT_multi_draw_arrays */

13123

13124 #ifdef GL_EXT_multi_draw_indirect

13125

13126 static GLboolean _glewInit_GL_EXT_multi_draw_indirect ()

13127 {

13128 GLboolean r = GL_FALSE;

13129

13130 r = ((glMultiDrawArraysIndirectEXT = (PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectEXT")) == NULL) || r;

13131 r = ((glMultiDrawElementsIndirectEXT = (PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectEXT")) == NULL) || r;

13132

13133 return r;

13134 }

13135

13136 #endif /* GL_EXT_multi_draw_indirect */

13137

13138 #ifdef GL_EXT_multisample

13139

13140 static GLboolean _glewInit_GL_EXT_multisample ()

13141 {

13142 GLboolean r = GL_FALSE;

13143

13144 r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r;

13145 r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r;

13146

13147 return r;

13148 }

13149

13150 #endif /* GL_EXT_multisample */

13151

13152 #ifdef GL_EXT_multisampled_render_to_texture

13153

13154 static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture ()

13155 {

13156 GLboolean r = GL_FALSE;

13157

13158 r = ((glFramebufferTexture2DMultisampleEXT = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DMultisampleEXT")) == NULL) || r;

13159

13160 return r;

13161 }

13162

13163 #endif /* GL_EXT_multisampled_render_to_texture */

13164

13165 #ifdef GL_EXT_multiview_draw_buffers

13166

13167 static GLboolean _glewInit_GL_EXT_multiview_draw_buffers ()

13168 {

13169 GLboolean r = GL_FALSE;

13170

13171 r = ((glDrawBuffersIndexedEXT = (PFNGLDRAWBUFFERSINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersIndexedEXT")) == NULL) || r;

13172 r = ((glGetIntegeri_vEXT = (PFNGLGETINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_vEXT")) == NULL) || r;

13173 r = ((glReadBufferIndexedEXT = (PFNGLREADBUFFERINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glReadBufferIndexedEXT")) == NULL) || r;

13174

13175 return r;

13176 }

13177

13178 #endif /* GL_EXT_multiview_draw_buffers */

13179

13180 #ifdef GL_EXT_paletted_texture

13181

13182 static GLboolean _glewInit_GL_EXT_paletted_texture ()

13183 {

13184 GLboolean r = GL_FALSE;

13185

13186 r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r;

13187 r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r;

13188 r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r;

13189 r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r;

13190

13191 return r;

13192 }

13193

13194 #endif /* GL_EXT_paletted_texture */

13195

13196 #ifdef GL_EXT_pixel_transform

13197

13198 static GLboolean _glewInit_GL_EXT_pixel_transform ()

13199 {

13200 GLboolean r = GL_FALSE;

13201

13202 r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r;

13203 r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r;

13204 r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r;

13205 r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r;

13206 r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r;

13207 r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r;

13208

13209 return r;

13210 }

13211

13212 #endif /* GL_EXT_pixel_transform */

13213

13214 #ifdef GL_EXT_point_parameters

13215

13216 static GLboolean _glewInit_GL_EXT_point_parameters ()

13217 {

13218 GLboolean r = GL_FALSE;

13219

13220 r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;

13221 r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;

13222

13223 return r;

13224 }

13225

13226 #endif /* GL_EXT_point_parameters */

13227

13228 #ifdef GL_EXT_polygon_offset

13229

13230 static GLboolean _glewInit_GL_EXT_polygon_offset ()

13231 {

13232 GLboolean r = GL_FALSE;

13233

13234 r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r;

13235

13236 return r;

13237 }

13238

13239 #endif /* GL_EXT_polygon_offset */

13240

13241 #ifdef GL_EXT_polygon_offset_clamp

13242

13243 static GLboolean _glewInit_GL_EXT_polygon_offset_clamp ()

13244 {

13245 GLboolean r = GL_FALSE;

13246

13247 r = ((glPolygonOffsetClampEXT = (PFNGLPOLYGONOFFSETCLAMPEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetClampEXT")) == NULL) || r;

13248

13249 return r;

13250 }

13251

13252 #endif /* GL_EXT_polygon_offset_clamp */

13253

13254 #ifdef GL_EXT_provoking_vertex

13255

13256 static GLboolean _glewInit_GL_EXT_provoking_vertex ()

13257 {

13258 GLboolean r = GL_FALSE;

13259

13260 r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r;

13261

13262 return r;

13263 }

13264

13265 #endif /* GL_EXT_provoking_vertex */

13266

13267 #ifdef GL_EXT_raster_multisample

13268

13269 static GLboolean _glewInit_GL_EXT_raster_multisample ()

13270 {

13271 GLboolean r = GL_FALSE;

13272

13273 r = ((glCoverageModulationNV = (PFNGLCOVERAGEMODULATIONNVPROC)glewGetProcAddress((const GLubyte*)"glCoverageModulationNV")) == NULL) || r;

13274 r = ((glCoverageModulationTableNV = (PFNGLCOVERAGEMODULATIONTABLENVPROC)glewGetProcAddress((const GLubyte*)"glCoverageModulationTableNV")) == NULL) || r;

13275 r = ((glGetCoverageModulationTableNV = (PFNGLGETCOVERAGEMODULATIONTABLENVPROC)glewGetProcAddress((const GLubyte*)"glGetCoverageModulationTableNV")) == NULL) || r;

13276 r = ((glRasterSamplesEXT = (PFNGLRASTERSAMPLESEXTPROC)glewGetProcAddress((const GLubyte*)"glRasterSamplesEXT")) == NULL) || r;

13277

13278 return r;

13279 }

13280

13281 #endif /* GL_EXT_raster_multisample */

13282

13283 #ifdef GL_EXT_scene_marker

13284

13285 static GLboolean _glewInit_GL_EXT_scene_marker ()

13286 {

13287 GLboolean r = GL_FALSE;

13288

13289 r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r;

13290 r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r;

13291

13292 return r;

13293 }

13294

13295 #endif /* GL_EXT_scene_marker */

13296

13297 #ifdef GL_EXT_secondary_color

13298

13299 static GLboolean _glewInit_GL_EXT_secondary_color ()

13300 {

13301 GLboolean r = GL_FALSE;

13302

13303 r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;

13304 r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;

13305 r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;

13306 r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;

13307 r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;

13308 r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;

13309 r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;

13310 r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;

13311 r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;

13312 r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;

13313 r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;

13314 r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;

13315 r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;

13316 r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;

13317 r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;

13318 r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;

13319 r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;

13320

13321 return r;

13322 }

13323

13324 #endif /* GL_EXT_secondary_color */

13325

13326 #ifdef GL_EXT_semaphore

13327

13328 static GLboolean _glewInit_GL_EXT_semaphore ()

13329 {

13330 GLboolean r = GL_FALSE;

13331

13332 r = ((glDeleteSemaphoresEXT = (PFNGLDELETESEMAPHORESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteSemaphoresEXT")) == NULL) || r;

13333 r = ((glGenSemaphoresEXT = (PFNGLGENSEMAPHORESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSemaphoresEXT")) == NULL) || r;

13334 r = ((glGetSemaphoreParameterui64vEXT = (PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetSemaphoreParameterui64vEXT")) == NULL) || r;

13335 r = ((glIsSemaphoreEXT = (PFNGLISSEMAPHOREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsSemaphoreEXT")) == NULL) || r;

13336 r = ((glSemaphoreParameterui64vEXT = (PFNGLSEMAPHOREPARAMETERUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glSemaphoreParameterui64vEXT")) == NULL) || r;

13337 r = ((glSignalSemaphoreEXT = (PFNGLSIGNALSEMAPHOREEXTPROC)glewGetProcAddress((const GLubyte*)"glSignalSemaphoreEXT")) == NULL) || r;

13338 r = ((glWaitSemaphoreEXT = (PFNGLWAITSEMAPHOREEXTPROC)glewGetProcAddress((const GLubyte*)"glWaitSemaphoreEXT")) == NULL) || r;

13339

13340 return r;

13341 }

13342

13343 #endif /* GL_EXT_semaphore */

13344

13345 #ifdef GL_EXT_semaphore_fd

13346

13347 static GLboolean _glewInit_GL_EXT_semaphore_fd ()

13348 {

13349 GLboolean r = GL_FALSE;

13350

13351 r = ((glImportSemaphoreFdEXT = (PFNGLIMPORTSEMAPHOREFDEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSemaphoreFdEXT")) == NULL) || r;

13352

13353 return r;

13354 }

13355

13356 #endif /* GL_EXT_semaphore_fd */

13357

13358 #ifdef GL_EXT_semaphore_win32

13359

13360 static GLboolean _glewInit_GL_EXT_semaphore_win32 ()

13361 {

13362 GLboolean r = GL_FALSE;

13363

13364 r = ((glImportSemaphoreWin32HandleEXT = (PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSemaphoreWin32HandleEXT")) == NULL) || r;

13365 r = ((glImportSemaphoreWin32NameEXT = (PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSemaphoreWin32NameEXT")) == NULL) || r;

13366

13367 return r;

13368 }

13369

13370 #endif /* GL_EXT_semaphore_win32 */

13371

13372 #ifdef GL_EXT_separate_shader_objects

13373

13374 static GLboolean _glewInit_GL_EXT_separate_shader_objects ()

13375 {

13376 GLboolean r = GL_FALSE;

13377

13378 r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r;

13379 r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r;

13380 r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r;

13381

13382 return r;

13383 }

13384

13385 #endif /* GL_EXT_separate_shader_objects */

13386

13387 #ifdef GL_EXT_shader_image_load_store

13388

13389 static GLboolean _glewInit_GL_EXT_shader_image_load_store ()

13390 {

13391 GLboolean r = GL_FALSE;

13392

13393 r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r;

13394 r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r;

13395

13396 return r;

13397 }

13398

13399 #endif /* GL_EXT_shader_image_load_store */

13400

13401 #ifdef GL_EXT_shader_pixel_local_storage2

13402

13403 static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 ()

13404 {

13405 GLboolean r = GL_FALSE;

13406

13407 r = ((glClearPixelLocalStorageuiEXT = (PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearPixelLocalStorageuiEXT")) == NULL) || r;

13408 r = ((glFramebufferPixelLocalStorageSizeEXT = (PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferPixelLocalStorageSizeEXT")) == NULL) || r;

13409 r = ((glGetFramebufferPixelLocalStorageSizeEXT = (PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferPixelLocalStorageSizeEXT")) == NULL) || r;

13410

13411 return r;

13412 }

13413

13414 #endif /* GL_EXT_shader_pixel_local_storage2 */

13415

13416 #ifdef GL_EXT_sparse_texture

13417

13418 static GLboolean _glewInit_GL_EXT_sparse_texture ()

13419 {

13420 GLboolean r = GL_FALSE;

13421

13422 r = ((glTexPageCommitmentEXT = (PFNGLTEXPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentEXT")) == NULL) || r;

13423 r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r;

13424

13425 return r;

13426 }

13427

13428 #endif /* GL_EXT_sparse_texture */

13429

13430 #ifdef GL_EXT_stencil_two_side

13431

13432 static GLboolean _glewInit_GL_EXT_stencil_two_side ()

13433 {

13434 GLboolean r = GL_FALSE;

13435

13436 r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;

13437

13438 return r;

13439 }

13440

13441 #endif /* GL_EXT_stencil_two_side */

13442

13443 #ifdef GL_EXT_subtexture

13444

13445 static GLboolean _glewInit_GL_EXT_subtexture ()

13446 {

13447 GLboolean r = GL_FALSE;

13448

13449 r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r;

13450 r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r;

13451 r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r;

13452

13453 return r;

13454 }

13455

13456 #endif /* GL_EXT_subtexture */

13457

13458 #ifdef GL_EXT_texture3D

13459

13460 static GLboolean _glewInit_GL_EXT_texture3D ()

13461 {

13462 GLboolean r = GL_FALSE;

13463

13464 r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r;

13465

13466 return r;

13467 }

13468

13469 #endif /* GL_EXT_texture3D */

13470

13471 #ifdef GL_EXT_texture_array

13472

13473 static GLboolean _glewInit_GL_EXT_texture_array ()

13474 {

13475 GLboolean r = GL_FALSE;

13476

13477 r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r;

13478

13479 return r;

13480 }

13481

13482 #endif /* GL_EXT_texture_array */

13483

13484 #ifdef GL_EXT_texture_buffer_object

13485

13486 static GLboolean _glewInit_GL_EXT_texture_buffer_object ()

13487 {

13488 GLboolean r = GL_FALSE;

13489

13490 r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r;

13491

13492 return r;

13493 }

13494

13495 #endif /* GL_EXT_texture_buffer_object */

13496

13497 #ifdef GL_EXT_texture_integer

13498

13499 static GLboolean _glewInit_GL_EXT_texture_integer ()

13500 {

13501 GLboolean r = GL_FALSE;

13502

13503 r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r;

13504 r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r;

13505 r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r;

13506 r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r;

13507 r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r;

13508 r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r;

13509

13510 return r;

13511 }

13512

13513 #endif /* GL_EXT_texture_integer */

13514

13515 #ifdef GL_EXT_texture_object

13516

13517 static GLboolean _glewInit_GL_EXT_texture_object ()

13518 {

13519 GLboolean r = GL_FALSE;

13520

13521 r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r;

13522 r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r;

13523 r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r;

13524 r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;

13525 r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;

13526 r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;

13527

13528 return r;

13529 }

13530

13531 #endif /* GL_EXT_texture_object */

13532

13533 #ifdef GL_EXT_texture_perturb_normal

13534

13535 static GLboolean _glewInit_GL_EXT_texture_perturb_normal ()

13536 {

13537 GLboolean r = GL_FALSE;

13538

13539 r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;

13540

13541 return r;

13542 }

13543

13544 #endif /* GL_EXT_texture_perturb_normal */

13545

13546 #ifdef GL_EXT_texture_storage

13547

13548 static GLboolean _glewInit_GL_EXT_texture_storage ()

13549 {

13550 GLboolean r = GL_FALSE;

13551

13552 r = ((glTexStorage1DEXT = (PFNGLTEXSTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1DEXT")) == NULL) || r;

13553 r = ((glTexStorage2DEXT = (PFNGLTEXSTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2DEXT")) == NULL) || r;

13554 r = ((glTexStorage3DEXT = (PFNGLTEXSTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DEXT")) == NULL) || r;

13555 r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r;

13556 r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r;

13557 r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r;

13558

13559 return r;

13560 }

13561

13562 #endif /* GL_EXT_texture_storage */

13563

13564 #ifdef GL_EXT_texture_view

13565

13566 static GLboolean _glewInit_GL_EXT_texture_view ()

13567 {

13568 GLboolean r = GL_FALSE;

13569

13570 r = ((glTextureViewEXT = (PFNGLTEXTUREVIEWEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureViewEXT")) == NULL) || r;

13571

13572 return r;

13573 }

13574

13575 #endif /* GL_EXT_texture_view */

13576

13577 #ifdef GL_EXT_timer_query

13578

13579 static GLboolean _glewInit_GL_EXT_timer_query ()

13580 {

13581 GLboolean r = GL_FALSE;

13582

13583 r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r;

13584 r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r;

13585

13586 return r;

13587 }

13588

13589 #endif /* GL_EXT_timer_query */

13590

13591 #ifdef GL_EXT_transform_feedback

13592

13593 static GLboolean _glewInit_GL_EXT_transform_feedback ()

13594 {

13595 GLboolean r = GL_FALSE;

13596

13597 r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r;

13598 r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r;

13599 r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r;

13600 r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r;

13601 r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r;

13602 r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r;

13603 r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r;

13604

13605 return r;

13606 }

13607

13608 #endif /* GL_EXT_transform_feedback */

13609

13610 #ifdef GL_EXT_vertex_array

13611

13612 static GLboolean _glewInit_GL_EXT_vertex_array ()

13613 {

13614 GLboolean r = GL_FALSE;

13615

13616 r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;

13617 r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;

13618 r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;

13619 r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;

13620 r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;

13621 r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;

13622 r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;

13623 r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;

13624

13625 return r;

13626 }

13627

13628 #endif /* GL_EXT_vertex_array */

13629

13630 #ifdef GL_EXT_vertex_array_setXXX

13631

13632 static GLboolean _glewInit_GL_EXT_vertex_array_setXXX ()

13633 {

13634 GLboolean r = GL_FALSE;

13635

13636 r = ((glBindArraySetEXT = (PFNGLBINDARRAYSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindArraySetEXT")) == NULL) || r;

13637 r = ((glCreateArraySetExt = (PFNGLCREATEARRAYSETEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateArraySetExt")) == NULL) || r;

13638 r = ((glDeleteArraySetsEXT = (PFNGLDELETEARRAYSETSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteArraySetsEXT")) == NULL) || r;

13639

13640 return r;

13641 }

13642

13643 #endif /* GL_EXT_vertex_array_setXXX */

13644

13645 #ifdef GL_EXT_vertex_attrib_64bit

13646

13647 static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit ()

13648 {

13649 GLboolean r = GL_FALSE;

13650

13651 r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r;

13652 r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r;

13653 r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r;

13654 r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r;

13655 r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r;

13656 r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r;

13657 r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r;

13658 r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r;

13659 r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r;

13660 r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r;

13661 r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r;

13662

13663 return r;

13664 }

13665

13666 #endif /* GL_EXT_vertex_attrib_64bit */

13667

13668 #ifdef GL_EXT_vertex_shader

13669

13670 static GLboolean _glewInit_GL_EXT_vertex_shader ()

13671 {

13672 GLboolean r = GL_FALSE;

13673

13674 r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;

13675 r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;

13676 r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;

13677 r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;

13678 r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;

13679 r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;

13680 r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;

13681 r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;

13682 r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;

13683 r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;

13684 r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;

13685 r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;

13686 r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;

13687 r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;

13688 r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;

13689 r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;

13690 r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;

13691 r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;

13692 r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;

13693 r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;

13694 r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;

13695 r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;

13696 r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;

13697 r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;

13698 r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;

13699 r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;

13700 r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;

13701 r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;

13702 r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;

13703 r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;

13704 r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;

13705 r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;

13706 r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;

13707 r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;

13708 r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;

13709 r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;

13710 r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;

13711 r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;

13712 r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;

13713 r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;

13714 r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;

13715 r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;

13716

13717 return r;

13718 }

13719

13720 #endif /* GL_EXT_vertex_shader */

13721

13722 #ifdef GL_EXT_vertex_weighting

13723

13724 static GLboolean _glewInit_GL_EXT_vertex_weighting ()

13725 {

13726 GLboolean r = GL_FALSE;

13727

13728 r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;

13729 r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;

13730 r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;

13731

13732 return r;

13733 }

13734

13735 #endif /* GL_EXT_vertex_weighting */

13736

13737 #ifdef GL_EXT_win32_keyed_mutex

13738

13739 static GLboolean _glewInit_GL_EXT_win32_keyed_mutex ()

13740 {

13741 GLboolean r = GL_FALSE;

13742

13743 r = ((glAcquireKeyedMutexWin32EXT = (PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC)glewGetProcAddress((const GLubyte*)"glAcquireKeyedMutexWin32EXT")) == NULL) || r;

13744 r = ((glReleaseKeyedMutexWin32EXT = (PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC)glewGetProcAddress((const GLubyte*)"glReleaseKeyedMutexWin32EXT")) == NULL) || r;

13745

13746 return r;

13747 }

13748

13749 #endif /* GL_EXT_win32_keyed_mutex */

13750

13751 #ifdef GL_EXT_window_rectangles

13752

13753 static GLboolean _glewInit_GL_EXT_window_rectangles ()

13754 {

13755 GLboolean r = GL_FALSE;

13756

13757 r = ((glWindowRectanglesEXT = (PFNGLWINDOWRECTANGLESEXTPROC)glewGetProcAddress((const GLubyte*)"glWindowRectanglesEXT")) == NULL) || r;

13758

13759 return r;

13760 }

13761

13762 #endif /* GL_EXT_window_rectangles */

13763

13764 #ifdef GL_EXT_x11_sync_object

13765

13766 static GLboolean _glewInit_GL_EXT_x11_sync_object ()

13767 {

13768 GLboolean r = GL_FALSE;

13769

13770 r = ((glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSyncEXT")) == NULL) || r;

13771

13772 return r;

13773 }

13774

13775 #endif /* GL_EXT_x11_sync_object */

13776

13777 #ifdef GL_GREMEDY_frame_terminator

13778

13779 static GLboolean _glewInit_GL_GREMEDY_frame_terminator ()

13780 {

13781 GLboolean r = GL_FALSE;

13782

13783 r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r;

13784

13785 return r;

13786 }

13787

13788 #endif /* GL_GREMEDY_frame_terminator */

13789

13790 #ifdef GL_GREMEDY_string_marker

13791

13792 static GLboolean _glewInit_GL_GREMEDY_string_marker ()

13793 {

13794 GLboolean r = GL_FALSE;

13795

13796 r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r;

13797

13798 return r;

13799 }

13800

13801 #endif /* GL_GREMEDY_string_marker */

13802

13803 #ifdef GL_HP_image_transform

13804

13805 static GLboolean _glewInit_GL_HP_image_transform ()

13806 {

13807 GLboolean r = GL_FALSE;

13808

13809 r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;

13810 r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;

13811 r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;

13812 r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;

13813 r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;

13814 r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;

13815

13816 return r;

13817 }

13818

13819 #endif /* GL_HP_image_transform */

13820

13821 #ifdef GL_IBM_multimode_draw_arrays

13822

13823 static GLboolean _glewInit_GL_IBM_multimode_draw_arrays ()

13824 {

13825 GLboolean r = GL_FALSE;

13826

13827 r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;

13828 r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;

13829

13830 return r;

13831 }

13832

13833 #endif /* GL_IBM_multimode_draw_arrays */

13834

13835 #ifdef GL_IBM_vertex_array_lists

13836

13837 static GLboolean _glewInit_GL_IBM_vertex_array_lists ()

13838 {

13839 GLboolean r = GL_FALSE;

13840

13841 r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;

13842 r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;

13843 r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;

13844 r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;

13845 r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;

13846 r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;

13847 r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;

13848 r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;

13849

13850 return r;

13851 }

13852

13853 #endif /* GL_IBM_vertex_array_lists */

13854

13855 #ifdef GL_INTEL_map_texture

13856

13857 static GLboolean _glewInit_GL_INTEL_map_texture ()

13858 {

13859 GLboolean r = GL_FALSE;

13860

13861 r = ((glMapTexture2DINTEL = (PFNGLMAPTEXTURE2DINTELPROC)glewGetProcAddress((const GLubyte*)"glMapTexture2DINTEL")) == NULL) || r;

13862 r = ((glSyncTextureINTEL = (PFNGLSYNCTEXTUREINTELPROC)glewGetProcAddress((const GLubyte*)"glSyncTextureINTEL")) == NULL) || r;

13863 r = ((glUnmapTexture2DINTEL = (PFNGLUNMAPTEXTURE2DINTELPROC)glewGetProcAddress((const GLubyte*)"glUnmapTexture2DINTEL")) == NULL) || r;

13864

13865 return r;

13866 }

13867

13868 #endif /* GL_INTEL_map_texture */

13869

13870 #ifdef GL_INTEL_parallel_arrays

13871

13872 static GLboolean _glewInit_GL_INTEL_parallel_arrays ()

13873 {

13874 GLboolean r = GL_FALSE;

13875

13876 r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;

13877 r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;

13878 r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;

13879 r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;

13880

13881 return r;

13882 }

13883

13884 #endif /* GL_INTEL_parallel_arrays */

13885

13886 #ifdef GL_INTEL_performance_query

13887

13888 static GLboolean _glewInit_GL_INTEL_performance_query ()

13889 {

13890 GLboolean r = GL_FALSE;

13891

13892 r = ((glBeginPerfQueryINTEL = (PFNGLBEGINPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfQueryINTEL")) == NULL) || r;

13893 r = ((glCreatePerfQueryINTEL = (PFNGLCREATEPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glCreatePerfQueryINTEL")) == NULL) || r;

13894 r = ((glDeletePerfQueryINTEL = (PFNGLDELETEPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfQueryINTEL")) == NULL) || r;

13895 r = ((glEndPerfQueryINTEL = (PFNGLENDPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glEndPerfQueryINTEL")) == NULL) || r;

13896 r = ((glGetFirstPerfQueryIdINTEL = (PFNGLGETFIRSTPERFQUERYIDINTELPROC)glewGetProcAddress((const GLubyte*)"glGetFirstPerfQueryIdINTEL")) == NULL) || r;

13897 r = ((glGetNextPerfQueryIdINTEL = (PFNGLGETNEXTPERFQUERYIDINTELPROC)glewGetProcAddress((const GLubyte*)"glGetNextPerfQueryIdINTEL")) == NULL) || r;

13898 r = ((glGetPerfCounterInfoINTEL = (PFNGLGETPERFCOUNTERINFOINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfCounterInfoINTEL")) == NULL) || r;

13899 r = ((glGetPerfQueryDataINTEL = (PFNGLGETPERFQUERYDATAINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfQueryDataINTEL")) == NULL) || r;

13900 r = ((glGetPerfQueryIdByNameINTEL = (PFNGLGETPERFQUERYIDBYNAMEINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfQueryIdByNameINTEL")) == NULL) || r;

13901 r = ((glGetPerfQueryInfoINTEL = (PFNGLGETPERFQUERYINFOINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfQueryInfoINTEL")) == NULL) || r;

13902

13903 return r;

13904 }

13905

13906 #endif /* GL_INTEL_performance_query */

13907

13908 #ifdef GL_INTEL_texture_scissor

13909

13910 static GLboolean _glewInit_GL_INTEL_texture_scissor ()

13911 {

13912 GLboolean r = GL_FALSE;

13913

13914 r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;

13915 r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;

13916

13917 return r;

13918 }

13919

13920 #endif /* GL_INTEL_texture_scissor */

13921

13922 #ifdef GL_KHR_blend_equation_advanced

13923

13924 static GLboolean _glewInit_GL_KHR_blend_equation_advanced ()

13925 {

13926 GLboolean r = GL_FALSE;

13927

13928 r = ((glBlendBarrierKHR = (PFNGLBLENDBARRIERKHRPROC)glewGetProcAddress((const GLubyte*)"glBlendBarrierKHR")) == NULL) || r;

13929

13930 return r;

13931 }

13932

13933 #endif /* GL_KHR_blend_equation_advanced */

13934

13935 #ifdef GL_KHR_debug

13936

13937 static GLboolean _glewInit_GL_KHR_debug ()

13938 {

13939 GLboolean r = GL_FALSE;

13940

13941 r = ((glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallback")) == NULL) || r;

13942 r = ((glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControl")) == NULL) || r;

13943 r = ((glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsert")) == NULL) || r;

13944 r = ((glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLog")) == NULL) || r;

13945 r = ((glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabel")) == NULL) || r;

13946 r = ((glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectPtrLabel")) == NULL) || r;

13947 r = ((glObjectLabel = (PFNGLOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectLabel")) == NULL) || r;

13948 r = ((glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectPtrLabel")) == NULL) || r;

13949 r = ((glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPopDebugGroup")) == NULL) || r;

13950 r = ((glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPushDebugGroup")) == NULL) || r;

13951

13952 return r;

13953 }

13954

13955 #endif /* GL_KHR_debug */

13956

13957 #ifdef GL_KHR_parallel_shader_compile

13958

13959 static GLboolean _glewInit_GL_KHR_parallel_shader_compile ()

13960 {

13961 GLboolean r = GL_FALSE;

13962

13963 r = ((glMaxShaderCompilerThreadsKHR = (PFNGLMAXSHADERCOMPILERTHREADSKHRPROC)glewGetProcAddress((const GLubyte*)"glMaxShaderCompilerThreadsKHR")) == NULL) || r;

13964

13965 return r;

13966 }

13967

13968 #endif /* GL_KHR_parallel_shader_compile */

13969

13970 #ifdef GL_KHR_robustness

13971

13972 static GLboolean _glewInit_GL_KHR_robustness ()

13973 {

13974 GLboolean r = GL_FALSE;

13975

13976 r = ((glGetnUniformfv = (PFNGLGETNUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfv")) == NULL) || r;

13977 r = ((glGetnUniformiv = (PFNGLGETNUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformiv")) == NULL) || r;

13978 r = ((glGetnUniformuiv = (PFNGLGETNUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuiv")) == NULL) || r;

13979 r = ((glReadnPixels = (PFNGLREADNPIXELSPROC)glewGetProcAddress((const GLubyte*)"glReadnPixels")) == NULL) || r;

13980

13981 return r;

13982 }

13983

13984 #endif /* GL_KHR_robustness */

13985

13986 #ifdef GL_KTX_buffer_region

13987

13988 static GLboolean _glewInit_GL_KTX_buffer_region ()

13989 {

13990 GLboolean r = GL_FALSE;

13991

13992 r = ((glBufferRegionEnabled = (PFNGLBUFFERREGIONENABLEDPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabled")) == NULL) || r;

13993 r = ((glDeleteBufferRegion = (PFNGLDELETEBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegion")) == NULL) || r;

13994 r = ((glDrawBufferRegion = (PFNGLDRAWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegion")) == NULL) || r;

13995 r = ((glNewBufferRegion = (PFNGLNEWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegion")) == NULL) || r;

13996 r = ((glReadBufferRegion = (PFNGLREADBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegion")) == NULL) || r;

13997

13998 return r;

13999 }

14000

14001 #endif /* GL_KTX_buffer_region */

14002

14003 #ifdef GL_MESA_resize_buffers

14004

14005 static GLboolean _glewInit_GL_MESA_resize_buffers ()

14006 {

14007 GLboolean r = GL_FALSE;

14008

14009 r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;

14010

14011 return r;

14012 }

14013

14014 #endif /* GL_MESA_resize_buffers */

14015

14016 #ifdef GL_MESA_window_pos

14017

14018 static GLboolean _glewInit_GL_MESA_window_pos ()

14019 {

14020 GLboolean r = GL_FALSE;

14021

14022 r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;

14023 r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;

14024 r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;

14025 r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;

14026 r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;

14027 r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;

14028 r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;

14029 r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;

14030 r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;

14031 r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;

14032 r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;

14033 r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;

14034 r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;

14035 r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;

14036 r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;

14037 r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;

14038 r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;

14039 r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;

14040 r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;

14041 r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;

14042 r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;

14043 r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;

14044 r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;

14045 r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;

14046

14047 return r;

14048 }

14049

14050 #endif /* GL_MESA_window_pos */

14051

14052 #ifdef GL_NVX_conditional_render

14053

14054 static GLboolean _glewInit_GL_NVX_conditional_render ()

14055 {

14056 GLboolean r = GL_FALSE;

14057

14058 r = ((glBeginConditionalRenderNVX = (PFNGLBEGINCONDITIONALRENDERNVXPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNVX")) == NULL) || r;

14059 r = ((glEndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNVX")) == NULL) || r;

14060

14061 return r;

14062 }

14063

14064 #endif /* GL_NVX_conditional_render */

14065

14066 #ifdef GL_NVX_linked_gpu_multicast

14067

14068 static GLboolean _glewInit_GL_NVX_linked_gpu_multicast ()

14069 {

14070 GLboolean r = GL_FALSE;

14071

14072 r = ((glLGPUCopyImageSubDataNVX = (PFNGLLGPUCOPYIMAGESUBDATANVXPROC)glewGetProcAddress((const GLubyte*)"glLGPUCopyImageSubDataNVX")) == NULL) || r;

14073 r = ((glLGPUInterlockNVX = (PFNGLLGPUINTERLOCKNVXPROC)glewGetProcAddress((const GLubyte*)"glLGPUInterlockNVX")) == NULL) || r;

14074 r = ((glLGPUNamedBufferSubDataNVX = (PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC)glewGetProcAddress((const GLubyte*)"glLGPUNamedBufferSubDataNVX")) == NULL) || r;

14075

14076 return r;

14077 }

14078

14079 #endif /* GL_NVX_linked_gpu_multicast */

14080

14081 #ifdef GL_NV_3dvision_settings

14082

14083 static GLboolean _glewInit_GL_NV_3dvision_settings ()

14084 {

14085 GLboolean r = GL_FALSE;

14086

14087 r = ((glStereoParameterfNV = (PFNGLSTEREOPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glStereoParameterfNV")) == NULL) || r;

14088 r = ((glStereoParameteriNV = (PFNGLSTEREOPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glStereoParameteriNV")) == NULL) || r;

14089

14090 return r;

14091 }

14092

14093 #endif /* GL_NV_3dvision_settings */

14094

14095 #ifdef GL_NV_bindless_multi_draw_indirect

14096

14097 static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect ()

14098 {

14099 GLboolean r = GL_FALSE;

14100

14101 r = ((glMultiDrawArraysIndirectBindlessNV = (PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectBindlessNV")) == NULL) || r;

14102 r = ((glMultiDrawElementsIndirectBindlessNV = (PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectBindlessNV")) == NULL) || r;

14103

14104 return r;

14105 }

14106

14107 #endif /* GL_NV_bindless_multi_draw_indirect */

14108

14109 #ifdef GL_NV_bindless_multi_draw_indirect_count

14110

14111 static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count ()

14112 {

14113 GLboolean r = GL_FALSE;

14114

14115 r = ((glMultiDrawArraysIndirectBindlessCountNV = (PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectBindlessCountNV")) == NULL) || r;

14116 r = ((glMultiDrawElementsIndirectBindlessCountNV = (PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectBindlessCountNV")) == NULL) || r;

14117

14118 return r;

14119 }

14120

14121 #endif /* GL_NV_bindless_multi_draw_indirect_count */

14122

14123 #ifdef GL_NV_bindless_texture

14124

14125 static GLboolean _glewInit_GL_NV_bindless_texture ()

14126 {

14127 GLboolean r = GL_FALSE;

14128

14129 r = ((glGetImageHandleNV = (PFNGLGETIMAGEHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleNV")) == NULL) || r;

14130 r = ((glGetTextureHandleNV = (PFNGLGETTEXTUREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleNV")) == NULL) || r;

14131 r = ((glGetTextureSamplerHandleNV = (PFNGLGETTEXTURESAMPLERHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleNV")) == NULL) || r;

14132 r = ((glIsImageHandleResidentNV = (PFNGLISIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentNV")) == NULL) || r;

14133 r = ((glIsTextureHandleResidentNV = (PFNGLISTEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentNV")) == NULL) || r;

14134 r = ((glMakeImageHandleNonResidentNV = (PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentNV")) == NULL) || r;

14135 r = ((glMakeImageHandleResidentNV = (PFNGLMAKEIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentNV")) == NULL) || r;

14136 r = ((glMakeTextureHandleNonResidentNV = (PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentNV")) == NULL) || r;

14137 r = ((glMakeTextureHandleResidentNV = (PFNGLMAKETEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentNV")) == NULL) || r;

14138 r = ((glProgramUniformHandleui64NV = (PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64NV")) == NULL) || r;

14139 r = ((glProgramUniformHandleui64vNV = (PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vNV")) == NULL) || r;

14140 r = ((glUniformHandleui64NV = (PFNGLUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64NV")) == NULL) || r;

14141 r = ((glUniformHandleui64vNV = (PFNGLUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vNV")) == NULL) || r;

14142

14143 return r;

14144 }

14145

14146 #endif /* GL_NV_bindless_texture */

14147

14148 #ifdef GL_NV_blend_equation_advanced

14149

14150 static GLboolean _glewInit_GL_NV_blend_equation_advanced ()

14151 {

14152 GLboolean r = GL_FALSE;

14153

14154 r = ((glBlendBarrierNV = (PFNGLBLENDBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glBlendBarrierNV")) == NULL) || r;

14155 r = ((glBlendParameteriNV = (PFNGLBLENDPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glBlendParameteriNV")) == NULL) || r;

14156

14157 return r;

14158 }

14159

14160 #endif /* GL_NV_blend_equation_advanced */

14161

14162 #ifdef GL_NV_clip_space_w_scaling

14163

14164 static GLboolean _glewInit_GL_NV_clip_space_w_scaling ()

14165 {

14166 GLboolean r = GL_FALSE;

14167

14168 r = ((glViewportPositionWScaleNV = (PFNGLVIEWPORTPOSITIONWSCALENVPROC)glewGetProcAddress((const GLubyte*)"glViewportPositionWScaleNV")) == NULL) || r;

14169

14170 return r;

14171 }

14172

14173 #endif /* GL_NV_clip_space_w_scaling */

14174

14175 #ifdef GL_NV_command_list

14176

14177 static GLboolean _glewInit_GL_NV_command_list ()

14178 {

14179 GLboolean r = GL_FALSE;

14180

14181 r = ((glCallCommandListNV = (PFNGLCALLCOMMANDLISTNVPROC)glewGetProcAddress((const GLubyte*)"glCallCommandListNV")) == NULL) || r;

14182 r = ((glCommandListSegmentsNV = (PFNGLCOMMANDLISTSEGMENTSNVPROC)glewGetProcAddress((const GLubyte*)"glCommandListSegmentsNV")) == NULL) || r;

14183 r = ((glCompileCommandListNV = (PFNGLCOMPILECOMMANDLISTNVPROC)glewGetProcAddress((const GLubyte*)"glCompileCommandListNV")) == NULL) || r;

14184 r = ((glCreateCommandListsNV = (PFNGLCREATECOMMANDLISTSNVPROC)glewGetProcAddress((const GLubyte*)"glCreateCommandListsNV")) == NULL) || r;

14185 r = ((glCreateStatesNV = (PFNGLCREATESTATESNVPROC)glewGetProcAddress((const GLubyte*)"glCreateStatesNV")) == NULL) || r;

14186 r = ((glDeleteCommandListsNV = (PFNGLDELETECOMMANDLISTSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteCommandListsNV")) == NULL) || r;

14187 r = ((glDeleteStatesNV = (PFNGLDELETESTATESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteStatesNV")) == NULL) || r;

14188 r = ((glDrawCommandsAddressNV = (PFNGLDRAWCOMMANDSADDRESSNVPROC)glewGetProcAddress((const GLubyte*)"glDrawCommandsAddressNV")) == NULL) || r;

14189 r = ((glDrawCommandsNV = (PFNGLDRAWCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glDrawCommandsNV")) == NULL) || r;

14190 r = ((glDrawCommandsStatesAddressNV = (PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC)glewGetProcAddress((const GLubyte*)"glDrawCommandsStatesAddressNV")) == NULL) || r;

14191 r = ((glDrawCommandsStatesNV = (PFNGLDRAWCOMMANDSSTATESNVPROC)glewGetProcAddress((const GLubyte*)"glDrawCommandsStatesNV")) == NULL) || r;

14192 r = ((glGetCommandHeaderNV = (PFNGLGETCOMMANDHEADERNVPROC)glewGetProcAddress((const GLubyte*)"glGetCommandHeaderNV")) == NULL) || r;

14193 r = ((glGetStageIndexNV = (PFNGLGETSTAGEINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glGetStageIndexNV")) == NULL) || r;

14194 r = ((glIsCommandListNV = (PFNGLISCOMMANDLISTNVPROC)glewGetProcAddress((const GLubyte*)"glIsCommandListNV")) == NULL) || r;

14195 r = ((glIsStateNV = (PFNGLISSTATENVPROC)glewGetProcAddress((const GLubyte*)"glIsStateNV")) == NULL) || r;

14196 r = ((glListDrawCommandsStatesClientNV = (PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC)glewGetProcAddress((const GLubyte*)"glListDrawCommandsStatesClientNV")) == NULL) || r;

14197 r = ((glStateCaptureNV = (PFNGLSTATECAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glStateCaptureNV")) == NULL) || r;

14198

14199 return r;

14200 }

14201

14202 #endif /* GL_NV_command_list */

14203

14204 #ifdef GL_NV_conditional_render

14205

14206 static GLboolean _glewInit_GL_NV_conditional_render ()

14207 {

14208 GLboolean r = GL_FALSE;

14209

14210 r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r;

14211 r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r;

14212

14213 return r;

14214 }

14215

14216 #endif /* GL_NV_conditional_render */

14217

14218 #ifdef GL_NV_conservative_raster

14219

14220 static GLboolean _glewInit_GL_NV_conservative_raster ()

14221 {

14222 GLboolean r = GL_FALSE;

14223

14224 r = ((glSubpixelPrecisionBiasNV = (PFNGLSUBPIXELPRECISIONBIASNVPROC)glewGetProcAddress((const GLubyte*)"glSubpixelPrecisionBiasNV")) == NULL) || r;

14225

14226 return r;

14227 }

14228

14229 #endif /* GL_NV_conservative_raster */

14230

14231 #ifdef GL_NV_conservative_raster_dilate

14232

14233 static GLboolean _glewInit_GL_NV_conservative_raster_dilate ()

14234 {

14235 GLboolean r = GL_FALSE;

14236

14237 r = ((glConservativeRasterParameterfNV = (PFNGLCONSERVATIVERASTERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glConservativeRasterParameterfNV")) == NULL) || r;

14238

14239 return r;

14240 }

14241

14242 #endif /* GL_NV_conservative_raster_dilate */

14243

14244 #ifdef GL_NV_conservative_raster_pre_snap_triangles

14245

14246 static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles ()

14247 {

14248 GLboolean r = GL_FALSE;

14249

14250 r = ((glConservativeRasterParameteriNV = (PFNGLCONSERVATIVERASTERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glConservativeRasterParameteriNV")) == NULL) || r;

14251

14252 return r;

14253 }

14254

14255 #endif /* GL_NV_conservative_raster_pre_snap_triangles */

14256

14257 #ifdef GL_NV_copy_buffer

14258

14259 static GLboolean _glewInit_GL_NV_copy_buffer ()

14260 {

14261 GLboolean r = GL_FALSE;

14262

14263 r = ((glCopyBufferSubDataNV = (PFNGLCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubDataNV")) == NULL) || r;

14264

14265 return r;

14266 }

14267

14268 #endif /* GL_NV_copy_buffer */

14269

14270 #ifdef GL_NV_copy_image

14271

14272 static GLboolean _glewInit_GL_NV_copy_image ()

14273 {

14274 GLboolean r = GL_FALSE;

14275

14276 r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r;

14277

14278 return r;

14279 }

14280

14281 #endif /* GL_NV_copy_image */

14282

14283 #ifdef GL_NV_depth_buffer_float

14284

14285 static GLboolean _glewInit_GL_NV_depth_buffer_float ()

14286 {

14287 GLboolean r = GL_FALSE;

14288

14289 r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r;

14290 r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r;

14291 r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r;

14292

14293 return r;

14294 }

14295

14296 #endif /* GL_NV_depth_buffer_float */

14297

14298 #ifdef GL_NV_draw_buffers

14299

14300 static GLboolean _glewInit_GL_NV_draw_buffers ()

14301 {

14302 GLboolean r = GL_FALSE;

14303

14304 r = ((glDrawBuffersNV = (PFNGLDRAWBUFFERSNVPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersNV")) == NULL) || r;

14305

14306 return r;

14307 }

14308

14309 #endif /* GL_NV_draw_buffers */

14310

14311 #ifdef GL_NV_draw_instanced

14312

14313 static GLboolean _glewInit_GL_NV_draw_instanced ()

14314 {

14315 GLboolean r = GL_FALSE;

14316

14317 r = ((glDrawArraysInstancedNV = (PFNGLDRAWARRAYSINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedNV")) == NULL) || r;

14318 r = ((glDrawElementsInstancedNV = (PFNGLDRAWELEMENTSINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedNV")) == NULL) || r;

14319

14320 return r;

14321 }

14322

14323 #endif /* GL_NV_draw_instanced */

14324

14325 #ifdef GL_NV_draw_texture

14326

14327 static GLboolean _glewInit_GL_NV_draw_texture ()

14328 {

14329 GLboolean r = GL_FALSE;

14330

14331 r = ((glDrawTextureNV = (PFNGLDRAWTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glDrawTextureNV")) == NULL) || r;

14332

14333 return r;

14334 }

14335

14336 #endif /* GL_NV_draw_texture */

14337

14338 #ifdef GL_NV_draw_vulkan_image

14339

14340 static GLboolean _glewInit_GL_NV_draw_vulkan_image ()

14341 {

14342 GLboolean r = GL_FALSE;

14343

14344 r = ((glDrawVkImageNV = (PFNGLDRAWVKIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glDrawVkImageNV")) == NULL) || r;

14345 r = ((glGetVkProcAddrNV = (PFNGLGETVKPROCADDRNVPROC)glewGetProcAddress((const GLubyte*)"glGetVkProcAddrNV")) == NULL) || r;

14346 r = ((glSignalVkFenceNV = (PFNGLSIGNALVKFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSignalVkFenceNV")) == NULL) || r;

14347 r = ((glSignalVkSemaphoreNV = (PFNGLSIGNALVKSEMAPHORENVPROC)glewGetProcAddress((const GLubyte*)"glSignalVkSemaphoreNV")) == NULL) || r;

14348 r = ((glWaitVkSemaphoreNV = (PFNGLWAITVKSEMAPHORENVPROC)glewGetProcAddress((const GLubyte*)"glWaitVkSemaphoreNV")) == NULL) || r;

14349

14350 return r;

14351 }

14352

14353 #endif /* GL_NV_draw_vulkan_image */

14354

14355 #ifdef GL_NV_evaluators

14356

14357 static GLboolean _glewInit_GL_NV_evaluators ()

14358 {

14359 GLboolean r = GL_FALSE;

14360

14361 r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;

14362 r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;

14363 r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;

14364 r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;

14365 r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;

14366 r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;

14367 r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;

14368 r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;

14369 r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;

14370

14371 return r;

14372 }

14373

14374 #endif /* GL_NV_evaluators */

14375

14376 #ifdef GL_NV_explicit_multisample

14377

14378 static GLboolean _glewInit_GL_NV_explicit_multisample ()

14379 {

14380 GLboolean r = GL_FALSE;

14381

14382 r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r;

14383 r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r;

14384 r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r;

14385

14386 return r;

14387 }

14388

14389 #endif /* GL_NV_explicit_multisample */

14390

14391 #ifdef GL_NV_fence

14392

14393 static GLboolean _glewInit_GL_NV_fence ()

14394 {

14395 GLboolean r = GL_FALSE;

14396

14397 r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;

14398 r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;

14399 r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;

14400 r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;

14401 r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;

14402 r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;

14403 r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;

14404

14405 return r;

14406 }

14407

14408 #endif /* GL_NV_fence */

14409

14410 #ifdef GL_NV_fragment_coverage_to_color

14411

14412 static GLboolean _glewInit_GL_NV_fragment_coverage_to_color ()

14413 {

14414 GLboolean r = GL_FALSE;

14415

14416 r = ((glFragmentCoverageColorNV = (PFNGLFRAGMENTCOVERAGECOLORNVPROC)glewGetProcAddress((const GLubyte*)"glFragmentCoverageColorNV")) == NULL) || r;

14417

14418 return r;

14419 }

14420

14421 #endif /* GL_NV_fragment_coverage_to_color */

14422

14423 #ifdef GL_NV_fragment_program

14424

14425 static GLboolean _glewInit_GL_NV_fragment_program ()

14426 {

14427 GLboolean r = GL_FALSE;

14428

14429 r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;

14430 r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;

14431 r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;

14432 r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;

14433 r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;

14434 r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;

14435

14436 return r;

14437 }

14438

14439 #endif /* GL_NV_fragment_program */

14440

14441 #ifdef GL_NV_framebuffer_blit

14442

14443 static GLboolean _glewInit_GL_NV_framebuffer_blit ()

14444 {

14445 GLboolean r = GL_FALSE;

14446

14447 r = ((glBlitFramebufferNV = (PFNGLBLITFRAMEBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferNV")) == NULL) || r;

14448

14449 return r;

14450 }

14451

14452 #endif /* GL_NV_framebuffer_blit */

14453

14454 #ifdef GL_NV_framebuffer_multisample

14455

14456 static GLboolean _glewInit_GL_NV_framebuffer_multisample ()

14457 {

14458 GLboolean r = GL_FALSE;

14459

14460 r = ((glRenderbufferStorageMultisampleNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleNV")) == NULL) || r;

14461

14462 return r;

14463 }

14464

14465 #endif /* GL_NV_framebuffer_multisample */

14466

14467 #ifdef GL_NV_framebuffer_multisample_coverage

14468

14469 static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage ()

14470 {

14471 GLboolean r = GL_FALSE;

14472

14473 r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r;

14474

14475 return r;

14476 }

14477

14478 #endif /* GL_NV_framebuffer_multisample_coverage */

14479

14480 #ifdef GL_NV_geometry_program4

14481

14482 static GLboolean _glewInit_GL_NV_geometry_program4 ()

14483 {

14484 GLboolean r = GL_FALSE;

14485

14486 r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r;

14487

14488 return r;

14489 }

14490

14491 #endif /* GL_NV_geometry_program4 */

14492

14493 #ifdef GL_NV_gpu_multicast

14494

14495 static GLboolean _glewInit_GL_NV_gpu_multicast ()

14496 {

14497 GLboolean r = GL_FALSE;

14498

14499 r = ((glMulticastBarrierNV = (PFNGLMULTICASTBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastBarrierNV")) == NULL) || r;

14500 r = ((glMulticastBlitFramebufferNV = (PFNGLMULTICASTBLITFRAMEBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastBlitFramebufferNV")) == NULL) || r;

14501 r = ((glMulticastBufferSubDataNV = (PFNGLMULTICASTBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glMulticastBufferSubDataNV")) == NULL) || r;

14502 r = ((glMulticastCopyBufferSubDataNV = (PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glMulticastCopyBufferSubDataNV")) == NULL) || r;

14503 r = ((glMulticastCopyImageSubDataNV = (PFNGLMULTICASTCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glMulticastCopyImageSubDataNV")) == NULL) || r;

14504 r = ((glMulticastFramebufferSampleLocationsfvNV = (PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastFramebufferSampleLocationsfvNV")) == NULL) || r;

14505 r = ((glMulticastGetQueryObjecti64vNV = (PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastGetQueryObjecti64vNV")) == NULL) || r;

14506 r = ((glMulticastGetQueryObjectivNV = (PFNGLMULTICASTGETQUERYOBJECTIVNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastGetQueryObjectivNV")) == NULL) || r;

14507 r = ((glMulticastGetQueryObjectui64vNV = (PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastGetQueryObjectui64vNV")) == NULL) || r;

14508 r = ((glMulticastGetQueryObjectuivNV = (PFNGLMULTICASTGETQUERYOBJECTUIVNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastGetQueryObjectuivNV")) == NULL) || r;

14509 r = ((glMulticastWaitSyncNV = (PFNGLMULTICASTWAITSYNCNVPROC)glewGetProcAddress((const GLubyte*)"glMulticastWaitSyncNV")) == NULL) || r;

14510 r = ((glRenderGpuMaskNV = (PFNGLRENDERGPUMASKNVPROC)glewGetProcAddress((const GLubyte*)"glRenderGpuMaskNV")) == NULL) || r;

14511

14512 return r;

14513 }

14514

14515 #endif /* GL_NV_gpu_multicast */

14516

14517 #ifdef GL_NV_gpu_program4

14518

14519 static GLboolean _glewInit_GL_NV_gpu_program4 ()

14520 {

14521 GLboolean r = GL_FALSE;

14522

14523 r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r;

14524 r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r;

14525 r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r;

14526 r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r;

14527 r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r;

14528 r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r;

14529 r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r;

14530 r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r;

14531 r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r;

14532 r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r;

14533 r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r;

14534 r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r;

14535

14536 return r;

14537 }

14538

14539 #endif /* GL_NV_gpu_program4 */

14540

14541 #ifdef GL_NV_gpu_shader5

14542

14543 static GLboolean _glewInit_GL_NV_gpu_shader5 ()

14544 {

14545 GLboolean r = GL_FALSE;

14546

14547 r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r;

14548 r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r;

14549 r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r;

14550 r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r;

14551 r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r;

14552 r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r;

14553 r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r;

14554 r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r;

14555 r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r;

14556 r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r;

14557 r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r;

14558 r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r;

14559 r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r;

14560 r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r;

14561 r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r;

14562 r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r;

14563 r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r;

14564 r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r;

14565 r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r;

14566 r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r;

14567 r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r;

14568 r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r;

14569 r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r;

14570 r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r;

14571 r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r;

14572 r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r;

14573 r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r;

14574 r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r;

14575 r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r;

14576 r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r;

14577 r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r;

14578 r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r;

14579 r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r;

14580 r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r;

14581

14582 return r;

14583 }

14584

14585 #endif /* GL_NV_gpu_shader5 */

14586

14587 #ifdef GL_NV_half_float

14588

14589 static GLboolean _glewInit_GL_NV_half_float ()

14590 {

14591 GLboolean r = GL_FALSE;

14592

14593 r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;

14594 r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;

14595 r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;

14596 r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;

14597 r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;

14598 r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;

14599 r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;

14600 r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;

14601 r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;

14602 r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;

14603 r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;

14604 r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;

14605 r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;

14606 r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;

14607 r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;

14608 r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;

14609 r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;

14610 r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;

14611 r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;

14612 r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;

14613 r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;

14614 r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;

14615 r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;

14616 r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;

14617 r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;

14618 r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;

14619 r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;

14620 r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;

14621 r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;

14622 r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;

14623 r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;

14624 r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;

14625 r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;

14626 r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;

14627 r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;

14628 r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;

14629 r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;

14630 r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;

14631 r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;

14632 r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;

14633 r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;

14634 r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;

14635 r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;

14636 r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;

14637 r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;

14638 r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;

14639

14640 return r;

14641 }

14642

14643 #endif /* GL_NV_half_float */

14644

14645 #ifdef GL_NV_instanced_arrays

14646

14647 static GLboolean _glewInit_GL_NV_instanced_arrays ()

14648 {

14649 GLboolean r = GL_FALSE;

14650

14651 r = ((glVertexAttribDivisorNV = (PFNGLVERTEXATTRIBDIVISORNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorNV")) == NULL) || r;

14652

14653 return r;

14654 }

14655

14656 #endif /* GL_NV_instanced_arrays */

14657

14658 #ifdef GL_NV_internalformat_sample_query

14659

14660 static GLboolean _glewInit_GL_NV_internalformat_sample_query ()

14661 {

14662 GLboolean r = GL_FALSE;

14663

14664 r = ((glGetInternalformatSampleivNV = (PFNGLGETINTERNALFORMATSAMPLEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformatSampleivNV")) == NULL) || r;

14665

14666 return r;

14667 }

14668

14669 #endif /* GL_NV_internalformat_sample_query */

14670

14671 #ifdef GL_NV_non_square_matrices

14672

14673 static GLboolean _glewInit_GL_NV_non_square_matrices ()

14674 {

14675 GLboolean r = GL_FALSE;

14676

14677 r = ((glUniformMatrix2x3fvNV = (PFNGLUNIFORMMATRIX2X3FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fvNV")) == NULL) || r;

14678 r = ((glUniformMatrix2x4fvNV = (PFNGLUNIFORMMATRIX2X4FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fvNV")) == NULL) || r;

14679 r = ((glUniformMatrix3x2fvNV = (PFNGLUNIFORMMATRIX3X2FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fvNV")) == NULL) || r;

14680 r = ((glUniformMatrix3x4fvNV = (PFNGLUNIFORMMATRIX3X4FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fvNV")) == NULL) || r;

14681 r = ((glUniformMatrix4x2fvNV = (PFNGLUNIFORMMATRIX4X2FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fvNV")) == NULL) || r;

14682 r = ((glUniformMatrix4x3fvNV = (PFNGLUNIFORMMATRIX4X3FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fvNV")) == NULL) || r;

14683

14684 return r;

14685 }

14686

14687 #endif /* GL_NV_non_square_matrices */

14688

14689 #ifdef GL_NV_occlusion_query

14690

14691 static GLboolean _glewInit_GL_NV_occlusion_query ()

14692 {

14693 GLboolean r = GL_FALSE;

14694

14695 r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;

14696 r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;

14697 r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;

14698 r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;

14699 r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;

14700 r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;

14701 r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;

14702

14703 return r;

14704 }

14705

14706 #endif /* GL_NV_occlusion_query */

14707

14708 #ifdef GL_NV_parameter_buffer_object

14709

14710 static GLboolean _glewInit_GL_NV_parameter_buffer_object ()

14711 {

14712 GLboolean r = GL_FALSE;

14713

14714 r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r;

14715 r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r;

14716 r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r;

14717

14718 return r;

14719 }

14720

14721 #endif /* GL_NV_parameter_buffer_object */

14722

14723 #ifdef GL_NV_path_rendering

14724

14725 static GLboolean _glewInit_GL_NV_path_rendering ()

14726 {

14727 GLboolean r = GL_FALSE;

14728

14729 r = ((glCopyPathNV = (PFNGLCOPYPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCopyPathNV")) == NULL) || r;

14730 r = ((glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathInstancedNV")) == NULL) || r;

14731 r = ((glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathNV")) == NULL) || r;

14732 r = ((glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathInstancedNV")) == NULL) || r;

14733 r = ((glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathNV")) == NULL) || r;

14734 r = ((glDeletePathsNV = (PFNGLDELETEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glDeletePathsNV")) == NULL) || r;

14735 r = ((glGenPathsNV = (PFNGLGENPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glGenPathsNV")) == NULL) || r;

14736 r = ((glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenfvNV")) == NULL) || r;

14737 r = ((glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenivNV")) == NULL) || r;

14738 r = ((glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCommandsNV")) == NULL) || r;

14739 r = ((glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCoordsNV")) == NULL) || r;

14740 r = ((glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathDashArrayNV")) == NULL) || r;

14741 r = ((glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathLengthNV")) == NULL) || r;

14742 r = ((glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricRangeNV")) == NULL) || r;

14743 r = ((glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricsNV")) == NULL) || r;

14744 r = ((glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterfvNV")) == NULL) || r;

14745 r = ((glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterivNV")) == NULL) || r;

14746 r = ((glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathSpacingNV")) == NULL) || r;

14747 r = ((glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenfvNV")) == NULL) || r;

14748 r = ((glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenivNV")) == NULL) || r;

14749 r = ((glGetProgramResourcefvNV = (PFNGLGETPROGRAMRESOURCEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourcefvNV")) == NULL) || r;

14750 r = ((glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glInterpolatePathsNV")) == NULL) || r;

14751 r = ((glIsPathNV = (PFNGLISPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPathNV")) == NULL) || r;

14752 r = ((glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInFillPathNV")) == NULL) || r;

14753 r = ((glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInStrokePathNV")) == NULL) || r;

14754 r = ((glMatrixLoad3x2fNV = (PFNGLMATRIXLOAD3X2FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoad3x2fNV")) == NULL) || r;

14755 r = ((glMatrixLoad3x3fNV = (PFNGLMATRIXLOAD3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoad3x3fNV")) == NULL) || r;

14756 r = ((glMatrixLoadTranspose3x3fNV = (PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTranspose3x3fNV")) == NULL) || r;

14757 r = ((glMatrixMult3x2fNV = (PFNGLMATRIXMULT3X2FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixMult3x2fNV")) == NULL) || r;

14758 r = ((glMatrixMult3x3fNV = (PFNGLMATRIXMULT3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixMult3x3fNV")) == NULL) || r;

14759 r = ((glMatrixMultTranspose3x3fNV = (PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTranspose3x3fNV")) == NULL) || r;

14760 r = ((glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathColorGenNV")) == NULL) || r;

14761 r = ((glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCommandsNV")) == NULL) || r;

14762 r = ((glPathCoordsNV = (PFNGLPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoordsNV")) == NULL) || r;

14763 r = ((glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoverDepthFuncNV")) == NULL) || r;

14764 r = ((glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathDashArrayNV")) == NULL) || r;

14765 r = ((glPathFogGenNV = (PFNGLPATHFOGGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathFogGenNV")) == NULL) || r;

14766 r = ((glPathGlyphIndexArrayNV = (PFNGLPATHGLYPHINDEXARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphIndexArrayNV")) == NULL) || r;

14767 r = ((glPathGlyphIndexRangeNV = (PFNGLPATHGLYPHINDEXRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphIndexRangeNV")) == NULL) || r;

14768 r = ((glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphRangeNV")) == NULL) || r;

14769 r = ((glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphsNV")) == NULL) || r;

14770 r = ((glPathMemoryGlyphIndexArrayNV = (PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathMemoryGlyphIndexArrayNV")) == NULL) || r;

14771 r = ((glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfNV")) == NULL) || r;

14772 r = ((glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfvNV")) == NULL) || r;

14773 r = ((glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPathParameteriNV")) == NULL) || r;

14774 r = ((glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterivNV")) == NULL) || r;

14775 r = ((glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilDepthOffsetNV")) == NULL) || r;

14776 r = ((glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilFuncNV")) == NULL) || r;

14777 r = ((glPathStringNV = (PFNGLPATHSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glPathStringNV")) == NULL) || r;

14778 r = ((glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCommandsNV")) == NULL) || r;

14779 r = ((glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCoordsNV")) == NULL) || r;

14780 r = ((glPathTexGenNV = (PFNGLPATHTEXGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathTexGenNV")) == NULL) || r;

14781 r = ((glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC)glewGetProcAddress((const GLubyte*)"glPointAlongPathNV")) == NULL) || r;

14782 r = ((glProgramPathFragmentInputGenNV = (PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC)glewGetProcAddress((const GLubyte*)"glProgramPathFragmentInputGenNV")) == NULL) || r;

14783 r = ((glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathInstancedNV")) == NULL) || r;

14784 r = ((glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathNV")) == NULL) || r;

14785 r = ((glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathInstancedNV")) == NULL) || r;

14786 r = ((glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathNV")) == NULL) || r;

14787 r = ((glStencilThenCoverFillPathInstancedNV = (PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverFillPathInstancedNV")) == NULL) || r;

14788 r = ((glStencilThenCoverFillPathNV = (PFNGLSTENCILTHENCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverFillPathNV")) == NULL) || r;

14789 r = ((glStencilThenCoverStrokePathInstancedNV = (PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverStrokePathInstancedNV")) == NULL) || r;

14790 r = ((glStencilThenCoverStrokePathNV = (PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverStrokePathNV")) == NULL) || r;

14791 r = ((glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC)glewGetProcAddress((const GLubyte*)"glTransformPathNV")) == NULL) || r;

14792 r = ((glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glWeightPathsNV")) == NULL) || r;

14793

14794 return r;

14795 }

14796

14797 #endif /* GL_NV_path_rendering */

14798

14799 #ifdef GL_NV_pixel_data_range

14800

14801 static GLboolean _glewInit_GL_NV_pixel_data_range ()

14802 {

14803 GLboolean r = GL_FALSE;

14804

14805 r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;

14806 r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;

14807

14808 return r;

14809 }

14810

14811 #endif /* GL_NV_pixel_data_range */

14812

14813 #ifdef GL_NV_point_sprite

14814

14815 static GLboolean _glewInit_GL_NV_point_sprite ()

14816 {

14817 GLboolean r = GL_FALSE;

14818

14819 r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;

14820 r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;

14821

14822 return r;

14823 }

14824

14825 #endif /* GL_NV_point_sprite */

14826

14827 #ifdef GL_NV_polygon_mode

14828

14829 static GLboolean _glewInit_GL_NV_polygon_mode ()

14830 {

14831 GLboolean r = GL_FALSE;

14832

14833 r = ((glPolygonModeNV = (PFNGLPOLYGONMODENVPROC)glewGetProcAddress((const GLubyte*)"glPolygonModeNV")) == NULL) || r;

14834

14835 return r;

14836 }

14837

14838 #endif /* GL_NV_polygon_mode */

14839

14840 #ifdef GL_NV_present_video

14841

14842 static GLboolean _glewInit_GL_NV_present_video ()

14843 {

14844 GLboolean r = GL_FALSE;

14845

14846 r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r;

14847 r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r;

14848 r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r;

14849 r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r;

14850 r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r;

14851 r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r;

14852

14853 return r;

14854 }

14855

14856 #endif /* GL_NV_present_video */

14857

14858 #ifdef GL_NV_primitive_restart

14859

14860 static GLboolean _glewInit_GL_NV_primitive_restart ()

14861 {

14862 GLboolean r = GL_FALSE;

14863

14864 r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;

14865 r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;

14866

14867 return r;

14868 }

14869

14870 #endif /* GL_NV_primitive_restart */

14871

14872 #ifdef GL_NV_register_combiners

14873

14874 static GLboolean _glewInit_GL_NV_register_combiners ()

14875 {

14876 GLboolean r = GL_FALSE;

14877

14878 r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;

14879 r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;

14880 r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;

14881 r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;

14882 r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;

14883 r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;

14884 r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;

14885 r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;

14886 r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;

14887 r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;

14888 r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;

14889 r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;

14890 r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;

14891

14892 return r;

14893 }

14894

14895 #endif /* GL_NV_register_combiners */

14896

14897 #ifdef GL_NV_register_combiners2

14898

14899 static GLboolean _glewInit_GL_NV_register_combiners2 ()

14900 {

14901 GLboolean r = GL_FALSE;

14902

14903 r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;

14904 r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;

14905

14906 return r;

14907 }

14908

14909 #endif /* GL_NV_register_combiners2 */

14910

14911 #ifdef GL_NV_sample_locations

14912

14913 static GLboolean _glewInit_GL_NV_sample_locations ()

14914 {

14915 GLboolean r = GL_FALSE;

14916

14917 r = ((glFramebufferSampleLocationsfvNV = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvNV")) == NULL) || r;

14918 r = ((glNamedFramebufferSampleLocationsfvNV = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvNV")) == NULL) || r;

14919

14920 return r;

14921 }

14922

14923 #endif /* GL_NV_sample_locations */

14924

14925 #ifdef GL_NV_shader_buffer_load

14926

14927 static GLboolean _glewInit_GL_NV_shader_buffer_load ()

14928 {

14929 GLboolean r = GL_FALSE;

14930

14931 r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r;

14932 r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r;

14933 r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r;

14934 r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r;

14935 r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r;

14936 r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r;

14937 r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r;

14938 r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r;

14939 r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r;

14940 r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r;

14941 r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r;

14942 r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r;

14943 r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r;

14944

14945 return r;

14946 }

14947

14948 #endif /* GL_NV_shader_buffer_load */

14949

14950 #ifdef GL_NV_texture_array

14951

14952 static GLboolean _glewInit_GL_NV_texture_array ()

14953 {

14954 GLboolean r = GL_FALSE;

14955

14956 r = ((glCompressedTexImage3DNV = (PFNGLCOMPRESSEDTEXIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DNV")) == NULL) || r;

14957 r = ((glCompressedTexSubImage3DNV = (PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DNV")) == NULL) || r;

14958 r = ((glCopyTexSubImage3DNV = (PFNGLCOPYTEXSUBIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DNV")) == NULL) || r;

14959 r = ((glFramebufferTextureLayerNV = (PFNGLFRAMEBUFFERTEXTURELAYERNVPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerNV")) == NULL) || r;

14960 r = ((glTexImage3DNV = (PFNGLTEXIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DNV")) == NULL) || r;

14961 r = ((glTexSubImage3DNV = (PFNGLTEXSUBIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DNV")) == NULL) || r;

14962

14963 return r;

14964 }

14965

14966 #endif /* GL_NV_texture_array */

14967

14968 #ifdef GL_NV_texture_barrier

14969

14970 static GLboolean _glewInit_GL_NV_texture_barrier ()

14971 {

14972 GLboolean r = GL_FALSE;

14973

14974 r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r;

14975

14976 return r;

14977 }

14978

14979 #endif /* GL_NV_texture_barrier */

14980

14981 #ifdef GL_NV_texture_multisample

14982

14983 static GLboolean _glewInit_GL_NV_texture_multisample ()

14984 {

14985 GLboolean r = GL_FALSE;

14986

14987 r = ((glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisampleCoverageNV")) == NULL) || r;

14988 r = ((glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisampleCoverageNV")) == NULL) || r;

14989 r = ((glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleCoverageNV")) == NULL) || r;

14990 r = ((glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleNV")) == NULL) || r;

14991 r = ((glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleCoverageNV")) == NULL) || r;

14992 r = ((glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleNV")) == NULL) || r;

14993

14994 return r;

14995 }

14996

14997 #endif /* GL_NV_texture_multisample */

14998

14999 #ifdef GL_NV_transform_feedback

15000

15001 static GLboolean _glewInit_GL_NV_transform_feedback ()

15002 {

15003 GLboolean r = GL_FALSE;

15004

15005 r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r;

15006 r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r;

15007 r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r;

15008 r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r;

15009 r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r;

15010 r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r;

15011 r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r;

15012 r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r;

15013 r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r;

15014 r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r;

15015 r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r;

15016

15017 return r;

15018 }

15019

15020 #endif /* GL_NV_transform_feedback */

15021

15022 #ifdef GL_NV_transform_feedback2

15023

15024 static GLboolean _glewInit_GL_NV_transform_feedback2 ()

15025 {

15026 GLboolean r = GL_FALSE;

15027

15028 r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r;

15029 r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r;

15030 r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r;

15031 r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r;

15032 r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r;

15033 r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r;

15034 r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r;

15035

15036 return r;

15037 }

15038

15039 #endif /* GL_NV_transform_feedback2 */

15040

15041 #ifdef GL_NV_vdpau_interop

15042

15043 static GLboolean _glewInit_GL_NV_vdpau_interop ()

15044 {

15045 GLboolean r = GL_FALSE;

15046

15047 r = ((glVDPAUFiniNV = (PFNGLVDPAUFININVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUFiniNV")) == NULL) || r;

15048 r = ((glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUGetSurfaceivNV")) == NULL) || r;

15049 r = ((glVDPAUInitNV = (PFNGLVDPAUINITNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUInitNV")) == NULL) || r;

15050 r = ((glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUIsSurfaceNV")) == NULL) || r;

15051 r = ((glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUMapSurfacesNV")) == NULL) || r;

15052 r = ((glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterOutputSurfaceNV")) == NULL) || r;

15053 r = ((glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterVideoSurfaceNV")) == NULL) || r;

15054 r = ((glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUSurfaceAccessNV")) == NULL) || r;

15055 r = ((glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnmapSurfacesNV")) == NULL) || r;

15056 r = ((glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnregisterSurfaceNV")) == NULL) || r;

15057

15058 return r;

15059 }

15060

15061 #endif /* GL_NV_vdpau_interop */

15062

15063 #ifdef GL_NV_vertex_array_range

15064

15065 static GLboolean _glewInit_GL_NV_vertex_array_range ()

15066 {

15067 GLboolean r = GL_FALSE;

15068

15069 r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;

15070 r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;

15071

15072 return r;

15073 }

15074

15075 #endif /* GL_NV_vertex_array_range */

15076

15077 #ifdef GL_NV_vertex_attrib_integer_64bit

15078

15079 static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit ()

15080 {

15081 GLboolean r = GL_FALSE;

15082

15083 r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r;

15084 r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r;

15085 r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r;

15086 r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r;

15087 r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r;

15088 r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r;

15089 r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r;

15090 r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r;

15091 r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r;

15092 r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r;

15093 r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r;

15094 r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r;

15095 r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r;

15096 r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r;

15097 r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r;

15098 r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r;

15099 r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r;

15100 r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r;

15101 r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r;

15102

15103 return r;

15104 }

15105

15106 #endif /* GL_NV_vertex_attrib_integer_64bit */

15107

15108 #ifdef GL_NV_vertex_buffer_unified_memory

15109

15110 static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory ()

15111 {

15112 GLboolean r = GL_FALSE;

15113

15114 r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r;

15115 r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r;

15116 r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r;

15117 r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r;

15118 r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r;

15119 r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r;

15120 r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r;

15121 r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r;

15122 r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r;

15123 r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r;

15124 r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r;

15125 r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r;

15126

15127 return r;

15128 }

15129

15130 #endif /* GL_NV_vertex_buffer_unified_memory */

15131

15132 #ifdef GL_NV_vertex_program

15133

15134 static GLboolean _glewInit_GL_NV_vertex_program ()

15135 {

15136 GLboolean r = GL_FALSE;

15137

15138 r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;

15139 r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;

15140 r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;

15141 r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;

15142 r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;

15143 r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;

15144 r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;

15145 r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;

15146 r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;

15147 r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;

15148 r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;

15149 r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;

15150 r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;

15151 r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;

15152 r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;

15153 r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;

15154 r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;

15155 r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;

15156 r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;

15157 r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;

15158 r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;

15159 r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;

15160 r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;

15161 r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;

15162 r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;

15163 r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;

15164 r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;

15165 r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;

15166 r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;

15167 r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;

15168 r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;

15169 r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;

15170 r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;

15171 r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;

15172 r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;

15173 r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;

15174 r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;

15175 r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;

15176 r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;

15177 r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;

15178 r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;

15179 r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;

15180 r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;

15181 r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;

15182 r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;

15183 r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;

15184 r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;

15185 r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;

15186 r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;

15187 r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;

15188 r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;

15189 r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;

15190 r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;

15191 r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;

15192 r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;

15193 r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;

15194 r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;

15195 r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;

15196 r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;

15197 r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;

15198 r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;

15199 r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;

15200 r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;

15201 r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;

15202

15203 return r;

15204 }

15205

15206 #endif /* GL_NV_vertex_program */

15207

15208 #ifdef GL_NV_video_capture

15209

15210 static GLboolean _glewInit_GL_NV_video_capture ()

15211 {

15212 GLboolean r = GL_FALSE;

15213

15214 r = ((glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glBeginVideoCaptureNV")) == NULL) || r;

15215 r = ((glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamBufferNV")) == NULL) || r;

15216 r = ((glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamTextureNV")) == NULL) || r;

15217 r = ((glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glEndVideoCaptureNV")) == NULL) || r;

15218 r = ((glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamdvNV")) == NULL) || r;

15219 r = ((glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamfvNV")) == NULL) || r;

15220 r = ((glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamivNV")) == NULL) || r;

15221 r = ((glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureivNV")) == NULL) || r;

15222 r = ((glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureNV")) == NULL) || r;

15223 r = ((glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterdvNV")) == NULL) || r;

15224 r = ((glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterfvNV")) == NULL) || r;

15225 r = ((glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterivNV")) == NULL) || r;

15226

15227 return r;

15228 }

15229

15230 #endif /* GL_NV_video_capture */

15231

15232 #ifdef GL_NV_viewport_array

15233

15234 static GLboolean _glewInit_GL_NV_viewport_array ()

15235 {

15236 GLboolean r = GL_FALSE;

15237

15238 r = ((glDepthRangeArrayfvNV = (PFNGLDEPTHRANGEARRAYFVNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayfvNV")) == NULL) || r;

15239 r = ((glDepthRangeIndexedfNV = (PFNGLDEPTHRANGEINDEXEDFNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexedfNV")) == NULL) || r;

15240 r = ((glDisableiNV = (PFNGLDISABLEINVPROC)glewGetProcAddress((const GLubyte*)"glDisableiNV")) == NULL) || r;

15241 r = ((glEnableiNV = (PFNGLENABLEINVPROC)glewGetProcAddress((const GLubyte*)"glEnableiNV")) == NULL) || r;

15242 r = ((glGetFloati_vNV = (PFNGLGETFLOATI_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vNV")) == NULL) || r;

15243 r = ((glIsEnablediNV = (PFNGLISENABLEDINVPROC)glewGetProcAddress((const GLubyte*)"glIsEnablediNV")) == NULL) || r;

15244 r = ((glScissorArrayvNV = (PFNGLSCISSORARRAYVNVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayvNV")) == NULL) || r;

15245 r = ((glScissorIndexedNV = (PFNGLSCISSORINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedNV")) == NULL) || r;

15246 r = ((glScissorIndexedvNV = (PFNGLSCISSORINDEXEDVNVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedvNV")) == NULL) || r;

15247 r = ((glViewportArrayvNV = (PFNGLVIEWPORTARRAYVNVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayvNV")) == NULL) || r;

15248 r = ((glViewportIndexedfNV = (PFNGLVIEWPORTINDEXEDFNVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfNV")) == NULL) || r;

15249 r = ((glViewportIndexedfvNV = (PFNGLVIEWPORTINDEXEDFVNVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfvNV")) == NULL) || r;

15250

15251 return r;

15252 }

15253

15254 #endif /* GL_NV_viewport_array */

15255

15256 #ifdef GL_NV_viewport_swizzle

15257

15258 static GLboolean _glewInit_GL_NV_viewport_swizzle ()

15259 {

15260 GLboolean r = GL_FALSE;

15261

15262 r = ((glViewportSwizzleNV = (PFNGLVIEWPORTSWIZZLENVPROC)glewGetProcAddress((const GLubyte*)"glViewportSwizzleNV")) == NULL) || r;

15263

15264 return r;

15265 }

15266

15267 #endif /* GL_NV_viewport_swizzle */

15268

15269 #ifdef GL_OVR_multiview

15270

15271 static GLboolean _glewInit_GL_OVR_multiview ()

15272 {

15273 GLboolean r = GL_FALSE;

15274

15275 r = ((glFramebufferTextureMultiviewOVR = (PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureMultiviewOVR")) == NULL) || r;

15276

15277 return r;

15278 }

15279

15280 #endif /* GL_OVR_multiview */

15281

15282 #ifdef GL_OVR_multiview_multisampled_render_to_texture

15283

15284 static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture ()

15285 {

15286 GLboolean r = GL_FALSE;

15287

15288 r = ((glFramebufferTextureMultisampleMultiviewOVR = (PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureMultisampleMultiviewOVR")) == NULL) || r;

15289

15290 return r;

15291 }

15292

15293 #endif /* GL_OVR_multiview_multisampled_render_to_texture */

15294

15295 #ifdef GL_QCOM_alpha_test

15296

15297 static GLboolean _glewInit_GL_QCOM_alpha_test ()

15298 {

15299 GLboolean r = GL_FALSE;

15300

15301 r = ((glAlphaFuncQCOM = (PFNGLALPHAFUNCQCOMPROC)glewGetProcAddress((const GLubyte*)"glAlphaFuncQCOM")) == NULL) || r;

15302

15303 return r;

15304 }

15305

15306 #endif /* GL_QCOM_alpha_test */

15307

15308 #ifdef GL_QCOM_driver_control

15309

15310 static GLboolean _glewInit_GL_QCOM_driver_control ()

15311 {

15312 GLboolean r = GL_FALSE;

15313

15314 r = ((glDisableDriverControlQCOM = (PFNGLDISABLEDRIVERCONTROLQCOMPROC)glewGetProcAddress((const GLubyte*)"glDisableDriverControlQCOM")) == NULL) || r;

15315 r = ((glEnableDriverControlQCOM = (PFNGLENABLEDRIVERCONTROLQCOMPROC)glewGetProcAddress((const GLubyte*)"glEnableDriverControlQCOM")) == NULL) || r;

15316 r = ((glGetDriverControlStringQCOM = (PFNGLGETDRIVERCONTROLSTRINGQCOMPROC)glewGetProcAddress((const GLubyte*)"glGetDriverControlStringQCOM")) == NULL) || r;

15317 r = ((glGetDriverControlsQCOM = (PFNGLGETDRIVERCONTROLSQCOMPROC)glewGetProcAddress((const GLubyte*)"glGetDriverControlsQCOM")) == NULL) || r;

15318

15319 return r;

15320 }

15321

15322 #endif /* GL_QCOM_driver_control */

15323

15324 #ifdef GL_QCOM_extended_get

15325

15326 static GLboolean _glewInit_GL_QCOM_extended_get ()

15327 {

15328 GLboolean r = GL_FALSE;

15329

15330 r = ((glExtGetBufferPointervQCOM = (PFNGLEXTGETBUFFERPOINTERVQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetBufferPointervQCOM")) == NULL) || r;

15331 r = ((glExtGetBuffersQCOM = (PFNGLEXTGETBUFFERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetBuffersQCOM")) == NULL) || r;

15332 r = ((glExtGetFramebuffersQCOM = (PFNGLEXTGETFRAMEBUFFERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetFramebuffersQCOM")) == NULL) || r;

15333 r = ((glExtGetRenderbuffersQCOM = (PFNGLEXTGETRENDERBUFFERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetRenderbuffersQCOM")) == NULL) || r;

15334 r = ((glExtGetTexLevelParameterivQCOM = (PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetTexLevelParameterivQCOM")) == NULL) || r;

15335 r = ((glExtGetTexSubImageQCOM = (PFNGLEXTGETTEXSUBIMAGEQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetTexSubImageQCOM")) == NULL) || r;

15336 r = ((glExtGetTexturesQCOM = (PFNGLEXTGETTEXTURESQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetTexturesQCOM")) == NULL) || r;

15337 r = ((glExtTexObjectStateOverrideiQCOM = (PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtTexObjectStateOverrideiQCOM")) == NULL) || r;

15338

15339 return r;

15340 }

15341

15342 #endif /* GL_QCOM_extended_get */

15343

15344 #ifdef GL_QCOM_extended_get2

15345

15346 static GLboolean _glewInit_GL_QCOM_extended_get2 ()

15347 {

15348 GLboolean r = GL_FALSE;

15349

15350 r = ((glExtGetProgramBinarySourceQCOM = (PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetProgramBinarySourceQCOM")) == NULL) || r;

15351 r = ((glExtGetProgramsQCOM = (PFNGLEXTGETPROGRAMSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetProgramsQCOM")) == NULL) || r;

15352 r = ((glExtGetShadersQCOM = (PFNGLEXTGETSHADERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetShadersQCOM")) == NULL) || r;

15353 r = ((glExtIsProgramBinaryQCOM = (PFNGLEXTISPROGRAMBINARYQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtIsProgramBinaryQCOM")) == NULL) || r;

15354

15355 return r;

15356 }

15357

15358 #endif /* GL_QCOM_extended_get2 */

15359

15360 #ifdef GL_QCOM_framebuffer_foveated

15361

15362 static GLboolean _glewInit_GL_QCOM_framebuffer_foveated ()

15363 {

15364 GLboolean r = GL_FALSE;

15365

15366 r = ((glFramebufferFoveationConfigQCOM = (PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFoveationConfigQCOM")) == NULL) || r;

15367 r = ((glFramebufferFoveationParametersQCOM = (PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFoveationParametersQCOM")) == NULL) || r;

15368

15369 return r;

15370 }

15371

15372 #endif /* GL_QCOM_framebuffer_foveated */

15373

15374 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent

15375

15376 static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent ()

15377 {

15378 GLboolean r = GL_FALSE;

15379

15380 r = ((glFramebufferFetchBarrierQCOM = (PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFetchBarrierQCOM")) == NULL) || r;

15381

15382 return r;

15383 }

15384

15385 #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */

15386

15387 #ifdef GL_QCOM_tiled_rendering

15388

15389 static GLboolean _glewInit_GL_QCOM_tiled_rendering ()

15390 {

15391 GLboolean r = GL_FALSE;

15392

15393 r = ((glEndTilingQCOM = (PFNGLENDTILINGQCOMPROC)glewGetProcAddress((const GLubyte*)"glEndTilingQCOM")) == NULL) || r;

15394 r = ((glStartTilingQCOM = (PFNGLSTARTTILINGQCOMPROC)glewGetProcAddress((const GLubyte*)"glStartTilingQCOM")) == NULL) || r;

15395

15396 return r;

15397 }

15398

15399 #endif /* GL_QCOM_tiled_rendering */

15400

15401 #ifdef GL_REGAL_ES1_0_compatibility

15402

15403 static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility ()

15404 {

15405 GLboolean r = GL_FALSE;

15406

15407 r = ((glAlphaFuncx = (PFNGLALPHAFUNCXPROC)glewGetProcAddress((const GLubyte*)"glAlphaFuncx")) == NULL) || r;

15408 r = ((glClearColorx = (PFNGLCLEARCOLORXPROC)glewGetProcAddress((const GLubyte*)"glClearColorx")) == NULL) || r;

15409 r = ((glClearDepthx = (PFNGLCLEARDEPTHXPROC)glewGetProcAddress((const GLubyte*)"glClearDepthx")) == NULL) || r;

15410 r = ((glColor4x = (PFNGLCOLOR4XPROC)glewGetProcAddress((const GLubyte*)"glColor4x")) == NULL) || r;

15411 r = ((glDepthRangex = (PFNGLDEPTHRANGEXPROC)glewGetProcAddress((const GLubyte*)"glDepthRangex")) == NULL) || r;

15412 r = ((glFogx = (PFNGLFOGXPROC)glewGetProcAddress((const GLubyte*)"glFogx")) == NULL) || r;

15413 r = ((glFogxv = (PFNGLFOGXVPROC)glewGetProcAddress((const GLubyte*)"glFogxv")) == NULL) || r;

15414 r = ((glFrustumf = (PFNGLFRUSTUMFPROC)glewGetProcAddress((const GLubyte*)"glFrustumf")) == NULL) || r;

15415 r = ((glFrustumx = (PFNGLFRUSTUMXPROC)glewGetProcAddress((const GLubyte*)"glFrustumx")) == NULL) || r;

15416 r = ((glLightModelx = (PFNGLLIGHTMODELXPROC)glewGetProcAddress((const GLubyte*)"glLightModelx")) == NULL) || r;

15417 r = ((glLightModelxv = (PFNGLLIGHTMODELXVPROC)glewGetProcAddress((const GLubyte*)"glLightModelxv")) == NULL) || r;

15418 r = ((glLightx = (PFNGLLIGHTXPROC)glewGetProcAddress((const GLubyte*)"glLightx")) == NULL) || r;

15419 r = ((glLightxv = (PFNGLLIGHTXVPROC)glewGetProcAddress((const GLubyte*)"glLightxv")) == NULL) || r;

15420 r = ((glLineWidthx = (PFNGLLINEWIDTHXPROC)glewGetProcAddress((const GLubyte*)"glLineWidthx")) == NULL) || r;

15421 r = ((glLoadMatrixx = (PFNGLLOADMATRIXXPROC)glewGetProcAddress((const GLubyte*)"glLoadMatrixx")) == NULL) || r;

15422 r = ((glMaterialx = (PFNGLMATERIALXPROC)glewGetProcAddress((const GLubyte*)"glMaterialx")) == NULL) || r;

15423 r = ((glMaterialxv = (PFNGLMATERIALXVPROC)glewGetProcAddress((const GLubyte*)"glMaterialxv")) == NULL) || r;

15424 r = ((glMultMatrixx = (PFNGLMULTMATRIXXPROC)glewGetProcAddress((const GLubyte*)"glMultMatrixx")) == NULL) || r;

15425 r = ((glMultiTexCoord4x = (PFNGLMULTITEXCOORD4XPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4x")) == NULL) || r;

15426 r = ((glNormal3x = (PFNGLNORMAL3XPROC)glewGetProcAddress((const GLubyte*)"glNormal3x")) == NULL) || r;

15427 r = ((glOrthof = (PFNGLORTHOFPROC)glewGetProcAddress((const GLubyte*)"glOrthof")) == NULL) || r;

15428 r = ((glOrthox = (PFNGLORTHOXPROC)glewGetProcAddress((const GLubyte*)"glOrthox")) == NULL) || r;

15429 r = ((glPointSizex = (PFNGLPOINTSIZEXPROC)glewGetProcAddress((const GLubyte*)"glPointSizex")) == NULL) || r;

15430 r = ((glPolygonOffsetx = (PFNGLPOLYGONOFFSETXPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetx")) == NULL) || r;

15431 r = ((glRotatex = (PFNGLROTATEXPROC)glewGetProcAddress((const GLubyte*)"glRotatex")) == NULL) || r;

15432 r = ((glSampleCoveragex = (PFNGLSAMPLECOVERAGEXPROC)glewGetProcAddress((const GLubyte*)"glSampleCoveragex")) == NULL) || r;

15433 r = ((glScalex = (PFNGLSCALEXPROC)glewGetProcAddress((const GLubyte*)"glScalex")) == NULL) || r;

15434 r = ((glTexEnvx = (PFNGLTEXENVXPROC)glewGetProcAddress((const GLubyte*)"glTexEnvx")) == NULL) || r;

15435 r = ((glTexEnvxv = (PFNGLTEXENVXVPROC)glewGetProcAddress((const GLubyte*)"glTexEnvxv")) == NULL) || r;

15436 r = ((glTexParameterx = (PFNGLTEXPARAMETERXPROC)glewGetProcAddress((const GLubyte*)"glTexParameterx")) == NULL) || r;

15437 r = ((glTranslatex = (PFNGLTRANSLATEXPROC)glewGetProcAddress((const GLubyte*)"glTranslatex")) == NULL) || r;

15438

15439 return r;

15440 }

15441

15442 #endif /* GL_REGAL_ES1_0_compatibility */

15443

15444 #ifdef GL_REGAL_ES1_1_compatibility

15445

15446 static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility ()

15447 {

15448 GLboolean r = GL_FALSE;

15449

15450 r = ((glClipPlanef = (PFNGLCLIPPLANEFPROC)glewGetProcAddress((const GLubyte*)"glClipPlanef")) == NULL) || r;

15451 r = ((glClipPlanex = (PFNGLCLIPPLANEXPROC)glewGetProcAddress((const GLubyte*)"glClipPlanex")) == NULL) || r;

15452 r = ((glGetClipPlanef = (PFNGLGETCLIPPLANEFPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanef")) == NULL) || r;

15453 r = ((glGetClipPlanex = (PFNGLGETCLIPPLANEXPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanex")) == NULL) || r;

15454 r = ((glGetFixedv = (PFNGLGETFIXEDVPROC)glewGetProcAddress((const GLubyte*)"glGetFixedv")) == NULL) || r;

15455 r = ((glGetLightxv = (PFNGLGETLIGHTXVPROC)glewGetProcAddress((const GLubyte*)"glGetLightxv")) == NULL) || r;

15456 r = ((glGetMaterialxv = (PFNGLGETMATERIALXVPROC)glewGetProcAddress((const GLubyte*)"glGetMaterialxv")) == NULL) || r;

15457 r = ((glGetTexEnvxv = (PFNGLGETTEXENVXVPROC)glewGetProcAddress((const GLubyte*)"glGetTexEnvxv")) == NULL) || r;

15458 r = ((glGetTexParameterxv = (PFNGLGETTEXPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterxv")) == NULL) || r;

15459 r = ((glPointParameterx = (PFNGLPOINTPARAMETERXPROC)glewGetProcAddress((const GLubyte*)"glPointParameterx")) == NULL) || r;

15460 r = ((glPointParameterxv = (PFNGLPOINTPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterxv")) == NULL) || r;

15461 r = ((glPointSizePointerOES = (PFNGLPOINTSIZEPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glPointSizePointerOES")) == NULL) || r;

15462 r = ((glTexParameterxv = (PFNGLTEXPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterxv")) == NULL) || r;

15463

15464 return r;

15465 }

15466

15467 #endif /* GL_REGAL_ES1_1_compatibility */

15468

15469 #ifdef GL_REGAL_error_string

15470

15471 static GLboolean _glewInit_GL_REGAL_error_string ()

15472 {

15473 GLboolean r = GL_FALSE;

15474

15475 r = ((glErrorStringREGAL = (PFNGLERRORSTRINGREGALPROC)glewGetProcAddress((const GLubyte*)"glErrorStringREGAL")) == NULL) || r;

15476

15477 return r;

15478 }

15479

15480 #endif /* GL_REGAL_error_string */

15481

15482 #ifdef GL_REGAL_extension_query

15483

15484 static GLboolean _glewInit_GL_REGAL_extension_query ()

15485 {

15486 GLboolean r = GL_FALSE;

15487

15488 r = ((glGetExtensionREGAL = (PFNGLGETEXTENSIONREGALPROC)glewGetProcAddress((const GLubyte*)"glGetExtensionREGAL")) == NULL) || r;

15489 r = ((glIsSupportedREGAL = (PFNGLISSUPPORTEDREGALPROC)glewGetProcAddress((const GLubyte*)"glIsSupportedREGAL")) == NULL) || r;

15490

15491 return r;

15492 }

15493

15494 #endif /* GL_REGAL_extension_query */

15495

15496 #ifdef GL_REGAL_log

15497

15498 static GLboolean _glewInit_GL_REGAL_log ()

15499 {

15500 GLboolean r = GL_FALSE;

15501

15502 r = ((glLogMessageCallbackREGAL = (PFNGLLOGMESSAGECALLBACKREGALPROC)glewGetProcAddress((const GLubyte*)"glLogMessageCallbackREGAL")) == NULL) || r;

15503

15504 return r;

15505 }

15506

15507 #endif /* GL_REGAL_log */

15508

15509 #ifdef GL_REGAL_proc_address

15510

15511 static GLboolean _glewInit_GL_REGAL_proc_address ()

15512 {

15513 GLboolean r = GL_FALSE;

15514

15515 r = ((glGetProcAddressREGAL = (PFNGLGETPROCADDRESSREGALPROC)glewGetProcAddress((const GLubyte*)"glGetProcAddressREGAL")) == NULL) || r;

15516

15517 return r;

15518 }

15519

15520 #endif /* GL_REGAL_proc_address */

15521

15522 #ifdef GL_SGIS_detail_texture

15523

15524 static GLboolean _glewInit_GL_SGIS_detail_texture ()

15525 {

15526 GLboolean r = GL_FALSE;

15527

15528 r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;

15529 r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;

15530

15531 return r;

15532 }

15533

15534 #endif /* GL_SGIS_detail_texture */

15535

15536 #ifdef GL_SGIS_fog_function

15537

15538 static GLboolean _glewInit_GL_SGIS_fog_function ()

15539 {

15540 GLboolean r = GL_FALSE;

15541

15542 r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;

15543 r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;

15544

15545 return r;

15546 }

15547

15548 #endif /* GL_SGIS_fog_function */

15549

15550 #ifdef GL_SGIS_multisample

15551

15552 static GLboolean _glewInit_GL_SGIS_multisample ()

15553 {

15554 GLboolean r = GL_FALSE;

15555

15556 r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;

15557 r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;

15558

15559 return r;

15560 }

15561

15562 #endif /* GL_SGIS_multisample */

15563

15564 #ifdef GL_SGIS_multitexture

15565

15566 static GLboolean _glewInit_GL_SGIS_multitexture ()

15567 {

15568 GLboolean r = GL_FALSE;

15569

15570 r = ((glInterleavedTextureCoordSetsSGIS = (PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC)glewGetProcAddress((const GLubyte*)"glInterleavedTextureCoordSetsSGIS")) == NULL) || r;

15571 r = ((glSelectTextureCoordSetSGIS = (PFNGLSELECTTEXTURECOORDSETSGISPROC)glewGetProcAddress((const GLubyte*)"glSelectTextureCoordSetSGIS")) == NULL) || r;

15572 r = ((glSelectTextureSGIS = (PFNGLSELECTTEXTURESGISPROC)glewGetProcAddress((const GLubyte*)"glSelectTextureSGIS")) == NULL) || r;

15573 r = ((glSelectTextureTransformSGIS = (PFNGLSELECTTEXTURETRANSFORMSGISPROC)glewGetProcAddress((const GLubyte*)"glSelectTextureTransformSGIS")) == NULL) || r;

15574

15575 return r;

15576 }

15577

15578 #endif /* GL_SGIS_multitexture */

15579

15580 #ifdef GL_SGIS_shared_multisample

15581

15582 static GLboolean _glewInit_GL_SGIS_shared_multisample ()

15583 {

15584 GLboolean r = GL_FALSE;

15585

15586 r = ((glMultisampleSubRectPosSGIS = (PFNGLMULTISAMPLESUBRECTPOSSGISPROC)glewGetProcAddress((const GLubyte*)"glMultisampleSubRectPosSGIS")) == NULL) || r;

15587

15588 return r;

15589 }

15590

15591 #endif /* GL_SGIS_shared_multisample */

15592

15593 #ifdef GL_SGIS_sharpen_texture

15594

15595 static GLboolean _glewInit_GL_SGIS_sharpen_texture ()

15596 {

15597 GLboolean r = GL_FALSE;

15598

15599 r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;

15600 r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;

15601

15602 return r;

15603 }

15604

15605 #endif /* GL_SGIS_sharpen_texture */

15606

15607 #ifdef GL_SGIS_texture4D

15608

15609 static GLboolean _glewInit_GL_SGIS_texture4D ()

15610 {

15611 GLboolean r = GL_FALSE;

15612

15613 r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;

15614 r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;

15615

15616 return r;

15617 }

15618

15619 #endif /* GL_SGIS_texture4D */

15620

15621 #ifdef GL_SGIS_texture_filter4

15622

15623 static GLboolean _glewInit_GL_SGIS_texture_filter4 ()

15624 {

15625 GLboolean r = GL_FALSE;

15626

15627 r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;

15628 r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;

15629

15630 return r;

15631 }

15632

15633 #endif /* GL_SGIS_texture_filter4 */

15634

15635 #ifdef GL_SGIX_async

15636

15637 static GLboolean _glewInit_GL_SGIX_async ()

15638 {

15639 GLboolean r = GL_FALSE;

15640

15641 r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;

15642 r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;

15643 r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;

15644 r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;

15645 r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;

15646 r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;

15647

15648 return r;

15649 }

15650

15651 #endif /* GL_SGIX_async */

15652

15653 #ifdef GL_SGIX_datapipe

15654

15655 static GLboolean _glewInit_GL_SGIX_datapipe ()

15656 {

15657 GLboolean r = GL_FALSE;

15658

15659 r = ((glAddressSpace = (PFNGLADDRESSSPACEPROC)glewGetProcAddress((const GLubyte*)"glAddressSpace")) == NULL) || r;

15660 r = ((glDataPipe = (PFNGLDATAPIPEPROC)glewGetProcAddress((const GLubyte*)"glDataPipe")) == NULL) || r;

15661

15662 return r;

15663 }

15664

15665 #endif /* GL_SGIX_datapipe */

15666

15667 #ifdef GL_SGIX_flush_raster

15668

15669 static GLboolean _glewInit_GL_SGIX_flush_raster ()

15670 {

15671 GLboolean r = GL_FALSE;

15672

15673 r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;

15674

15675 return r;

15676 }

15677

15678 #endif /* GL_SGIX_flush_raster */

15679

15680 #ifdef GL_SGIX_fog_layers

15681

15682 static GLboolean _glewInit_GL_SGIX_fog_layers ()

15683 {

15684 GLboolean r = GL_FALSE;

15685

15686 r = ((glFogLayersSGIX = (PFNGLFOGLAYERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glFogLayersSGIX")) == NULL) || r;

15687 r = ((glGetFogLayersSGIX = (PFNGLGETFOGLAYERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFogLayersSGIX")) == NULL) || r;

15688

15689 return r;

15690 }

15691

15692 #endif /* GL_SGIX_fog_layers */

15693

15694 #ifdef GL_SGIX_fog_texture

15695

15696 static GLboolean _glewInit_GL_SGIX_fog_texture ()

15697 {

15698 GLboolean r = GL_FALSE;

15699

15700 r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;

15701

15702 return r;

15703 }

15704

15705 #endif /* GL_SGIX_fog_texture */

15706

15707 #ifdef GL_SGIX_fragment_specular_lighting

15708

15709 static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting ()

15710 {

15711 GLboolean r = GL_FALSE;

15712

15713 r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;

15714 r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;

15715 r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;

15716 r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;

15717 r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;

15718 r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;

15719 r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;

15720 r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;

15721 r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;

15722 r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;

15723 r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;

15724 r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;

15725 r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;

15726 r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;

15727 r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;

15728 r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;

15729 r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;

15730

15731 return r;

15732 }

15733

15734 #endif /* GL_SGIX_fragment_specular_lighting */

15735

15736 #ifdef GL_SGIX_framezoom

15737

15738 static GLboolean _glewInit_GL_SGIX_framezoom ()

15739 {

15740 GLboolean r = GL_FALSE;

15741

15742 r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;

15743

15744 return r;

15745 }

15746

15747 #endif /* GL_SGIX_framezoom */

15748

15749 #ifdef GL_SGIX_igloo_interface

15750

15751 static GLboolean _glewInit_GL_SGIX_igloo_interface ()

15752 {

15753 GLboolean r = GL_FALSE;

15754

15755 r = ((glIglooInterfaceSGIX = (PFNGLIGLOOINTERFACESGIXPROC)glewGetProcAddress((const GLubyte*)"glIglooInterfaceSGIX")) == NULL) || r;

15756

15757 return r;

15758 }

15759

15760 #endif /* GL_SGIX_igloo_interface */

15761

15762 #ifdef GL_SGIX_mpeg1

15763

15764 static GLboolean _glewInit_GL_SGIX_mpeg1 ()

15765 {

15766 GLboolean r = GL_FALSE;

15767

15768 r = ((glAllocMPEGPredictorsSGIX = (PFNGLALLOCMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glAllocMPEGPredictorsSGIX")) == NULL) || r;

15769 r = ((glDeleteMPEGPredictorsSGIX = (PFNGLDELETEMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteMPEGPredictorsSGIX")) == NULL) || r;

15770 r = ((glGenMPEGPredictorsSGIX = (PFNGLGENMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenMPEGPredictorsSGIX")) == NULL) || r;

15771 r = ((glGetMPEGParameterfvSGIX = (PFNGLGETMPEGPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGParameterfvSGIX")) == NULL) || r;

15772 r = ((glGetMPEGParameterivSGIX = (PFNGLGETMPEGPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGParameterivSGIX")) == NULL) || r;

15773 r = ((glGetMPEGPredictorSGIX = (PFNGLGETMPEGPREDICTORSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGPredictorSGIX")) == NULL) || r;

15774 r = ((glGetMPEGQuantTableubv = (PFNGLGETMPEGQUANTTABLEUBVPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGQuantTableubv")) == NULL) || r;

15775 r = ((glIsMPEGPredictorSGIX = (PFNGLISMPEGPREDICTORSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsMPEGPredictorSGIX")) == NULL) || r;

15776 r = ((glMPEGPredictorSGIX = (PFNGLMPEGPREDICTORSGIXPROC)glewGetProcAddress((const GLubyte*)"glMPEGPredictorSGIX")) == NULL) || r;

15777 r = ((glMPEGQuantTableubv = (PFNGLMPEGQUANTTABLEUBVPROC)glewGetProcAddress((const GLubyte*)"glMPEGQuantTableubv")) == NULL) || r;

15778 r = ((glSwapMPEGPredictorsSGIX = (PFNGLSWAPMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glSwapMPEGPredictorsSGIX")) == NULL) || r;

15779

15780 return r;

15781 }

15782

15783 #endif /* GL_SGIX_mpeg1 */

15784

15785 #ifdef GL_SGIX_nonlinear_lighting_pervertex

15786

15787 static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex ()

15788 {

15789 GLboolean r = GL_FALSE;

15790

15791 r = ((glGetNonlinLightfvSGIX = (PFNGLGETNONLINLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetNonlinLightfvSGIX")) == NULL) || r;

15792 r = ((glGetNonlinMaterialfvSGIX = (PFNGLGETNONLINMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetNonlinMaterialfvSGIX")) == NULL) || r;

15793 r = ((glNonlinLightfvSGIX = (PFNGLNONLINLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glNonlinLightfvSGIX")) == NULL) || r;

15794 r = ((glNonlinMaterialfvSGIX = (PFNGLNONLINMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glNonlinMaterialfvSGIX")) == NULL) || r;

15795

15796 return r;

15797 }

15798

15799 #endif /* GL_SGIX_nonlinear_lighting_pervertex */

15800

15801 #ifdef GL_SGIX_pixel_texture

15802

15803 static GLboolean _glewInit_GL_SGIX_pixel_texture ()

15804 {

15805 GLboolean r = GL_FALSE;

15806

15807 r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;

15808

15809 return r;

15810 }

15811

15812 #endif /* GL_SGIX_pixel_texture */

15813

15814 #ifdef GL_SGIX_polynomial_ffd

15815

15816 static GLboolean _glewInit_GL_SGIX_polynomial_ffd ()

15817 {

15818 GLboolean r = GL_FALSE;

15819

15820 r = ((glDeformSGIX = (PFNGLDEFORMSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeformSGIX")) == NULL) || r;

15821 r = ((glLoadIdentityDeformationMapSGIX = (PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC)glewGetProcAddress((const GLubyte*)"glLoadIdentityDeformationMapSGIX")) == NULL) || r;

15822

15823 return r;

15824 }

15825

15826 #endif /* GL_SGIX_polynomial_ffd */

15827

15828 #ifdef GL_SGIX_quad_mesh

15829

15830 static GLboolean _glewInit_GL_SGIX_quad_mesh ()

15831 {

15832 GLboolean r = GL_FALSE;

15833

15834 r = ((glMeshBreadthSGIX = (PFNGLMESHBREADTHSGIXPROC)glewGetProcAddress((const GLubyte*)"glMeshBreadthSGIX")) == NULL) || r;

15835 r = ((glMeshStrideSGIX = (PFNGLMESHSTRIDESGIXPROC)glewGetProcAddress((const GLubyte*)"glMeshStrideSGIX")) == NULL) || r;

15836

15837 return r;

15838 }

15839

15840 #endif /* GL_SGIX_quad_mesh */

15841

15842 #ifdef GL_SGIX_reference_plane

15843

15844 static GLboolean _glewInit_GL_SGIX_reference_plane ()

15845 {

15846 GLboolean r = GL_FALSE;

15847

15848 r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;

15849

15850 return r;

15851 }

15852

15853 #endif /* GL_SGIX_reference_plane */

15854

15855 #ifdef GL_SGIX_sprite

15856

15857 static GLboolean _glewInit_GL_SGIX_sprite ()

15858 {

15859 GLboolean r = GL_FALSE;

15860

15861 r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;

15862 r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;

15863 r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;

15864 r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;

15865

15866 return r;

15867 }

15868

15869 #endif /* GL_SGIX_sprite */

15870

15871 #ifdef GL_SGIX_tag_sample_buffer

15872

15873 static GLboolean _glewInit_GL_SGIX_tag_sample_buffer ()

15874 {

15875 GLboolean r = GL_FALSE;

15876

15877 r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;

15878

15879 return r;

15880 }

15881

15882 #endif /* GL_SGIX_tag_sample_buffer */

15883

15884 #ifdef GL_SGIX_vector_ops

15885

15886 static GLboolean _glewInit_GL_SGIX_vector_ops ()

15887 {

15888 GLboolean r = GL_FALSE;

15889

15890 r = ((glGetVectorOperationSGIX = (PFNGLGETVECTOROPERATIONSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetVectorOperationSGIX")) == NULL) || r;

15891 r = ((glVectorOperationSGIX = (PFNGLVECTOROPERATIONSGIXPROC)glewGetProcAddress((const GLubyte*)"glVectorOperationSGIX")) == NULL) || r;

15892

15893 return r;

15894 }

15895

15896 #endif /* GL_SGIX_vector_ops */

15897

15898 #ifdef GL_SGIX_vertex_array_object

15899

15900 static GLboolean _glewInit_GL_SGIX_vertex_array_object ()

15901 {

15902 GLboolean r = GL_FALSE;

15903

15904 r = ((glAreVertexArraysResidentSGIX = (PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glAreVertexArraysResidentSGIX")) == NULL) || r;

15905 r = ((glBindVertexArraySGIX = (PFNGLBINDVERTEXARRAYSGIXPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArraySGIX")) == NULL) || r;

15906 r = ((glDeleteVertexArraysSGIX = (PFNGLDELETEVERTEXARRAYSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysSGIX")) == NULL) || r;

15907 r = ((glGenVertexArraysSGIX = (PFNGLGENVERTEXARRAYSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysSGIX")) == NULL) || r;

15908 r = ((glIsVertexArraySGIX = (PFNGLISVERTEXARRAYSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArraySGIX")) == NULL) || r;

15909 r = ((glPrioritizeVertexArraysSGIX = (PFNGLPRIORITIZEVERTEXARRAYSSGIXPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeVertexArraysSGIX")) == NULL) || r;

15910

15911 return r;

15912 }

15913

15914 #endif /* GL_SGIX_vertex_array_object */

15915

15916 #ifdef GL_SGI_color_table

15917

15918 static GLboolean _glewInit_GL_SGI_color_table ()

15919 {

15920 GLboolean r = GL_FALSE;

15921

15922 r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;

15923 r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;

15924 r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;

15925 r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;

15926 r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;

15927 r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;

15928 r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;

15929

15930 return r;

15931 }

15932

15933 #endif /* GL_SGI_color_table */

15934

15935 #ifdef GL_SGI_fft

15936

15937 static GLboolean _glewInit_GL_SGI_fft ()

15938 {

15939 GLboolean r = GL_FALSE;

15940

15941 r = ((glGetPixelTransformParameterfvSGI = (PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvSGI")) == NULL) || r;

15942 r = ((glGetPixelTransformParameterivSGI = (PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivSGI")) == NULL) || r;

15943 r = ((glPixelTransformParameterfSGI = (PFNGLPIXELTRANSFORMPARAMETERFSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfSGI")) == NULL) || r;

15944 r = ((glPixelTransformParameterfvSGI = (PFNGLPIXELTRANSFORMPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvSGI")) == NULL) || r;

15945 r = ((glPixelTransformParameteriSGI = (PFNGLPIXELTRANSFORMPARAMETERISGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriSGI")) == NULL) || r;

15946 r = ((glPixelTransformParameterivSGI = (PFNGLPIXELTRANSFORMPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivSGI")) == NULL) || r;

15947 r = ((glPixelTransformSGI = (PFNGLPIXELTRANSFORMSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformSGI")) == NULL) || r;

15948

15949 return r;

15950 }

15951

15952 #endif /* GL_SGI_fft */

15953

15954 #ifdef GL_SUNX_constant_data

15955

15956 static GLboolean _glewInit_GL_SUNX_constant_data ()

15957 {

15958 GLboolean r = GL_FALSE;

15959

15960 r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;

15961

15962 return r;

15963 }

15964

15965 #endif /* GL_SUNX_constant_data */

15966

15967 #ifdef GL_SUN_global_alpha

15968

15969 static GLboolean _glewInit_GL_SUN_global_alpha ()

15970 {

15971 GLboolean r = GL_FALSE;

15972

15973 r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;

15974 r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;

15975 r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;

15976 r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;

15977 r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;

15978 r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;

15979 r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;

15980 r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;

15981

15982 return r;

15983 }

15984

15985 #endif /* GL_SUN_global_alpha */

15986

15987 #ifdef GL_SUN_read_video_pixels

15988

15989 static GLboolean _glewInit_GL_SUN_read_video_pixels ()

15990 {

15991 GLboolean r = GL_FALSE;

15992

15993 r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;

15994

15995 return r;

15996 }

15997

15998 #endif /* GL_SUN_read_video_pixels */

15999

16000 #ifdef GL_SUN_triangle_list

16001

16002 static GLboolean _glewInit_GL_SUN_triangle_list ()

16003 {

16004 GLboolean r = GL_FALSE;

16005

16006 r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;

16007 r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;

16008 r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;

16009 r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;

16010 r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;

16011 r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;

16012 r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;

16013

16014 return r;

16015 }

16016

16017 #endif /* GL_SUN_triangle_list */

16018

16019 #ifdef GL_SUN_vertex

16020

16021 static GLboolean _glewInit_GL_SUN_vertex ()

16022 {

16023 GLboolean r = GL_FALSE;

16024

16025 r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;

16026 r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;

16027 r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;

16028 r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;

16029 r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;

16030 r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;

16031 r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;

16032 r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;

16033 r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;

16034 r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;

16035 r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;

16036 r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;

16037 r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;

16038 r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;

16039 r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;

16040 r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;

16041 r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;

16042 r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;

16043 r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

16044 r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

16045 r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

16046 r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

16047 r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;

16048 r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;

16049 r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;

16050 r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;

16051 r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;

16052 r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;

16053 r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

16054 r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

16055 r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;

16056 r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;

16057 r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

16058 r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

16059 r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;

16060 r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;

16061 r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;

16062 r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;

16063 r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;

16064 r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;

16065

16066 return r;

16067 }

16068

16069 #endif /* GL_SUN_vertex */

16070

16071 #ifdef GL_WIN_swap_hint

16072

16073 static GLboolean _glewInit_GL_WIN_swap_hint ()

16074 {

16075 GLboolean r = GL_FALSE;

16076

16077 r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;

16078

16079 return r;

16080 }

16081

16082 #endif /* GL_WIN_swap_hint */

16083

16084 /* ------------------------------------------------------------------------- */

16085

16086 static int _glewExtensionCompare(const char *s1, const char *s2)

16087 {

16088 /* http://www.chanduthedev.com/2012/07/strcmp-implementation-in-c.html */

16089 while (*s1 || *s2)

16090 {

16091 if (*s1 > *s2)

16092 return 1;

16093 if (*s1 < *s2)

16094 return -1;

16095 s1++;

16096 s2++;

16097 }

16098 return 0;

16099 }

16100

16101 static ptrdiff_t _glewBsearchExtension(const char* name)

16102 {

16103 ptrdiff_t lo = 0, hi = sizeof(_glewExtensionLookup) / sizeof(char*) - 2;

16104

16105 while (lo <= hi)

16106 {

16107 ptrdiff_t mid = (lo + hi) / 2;

16108 const int cmp = _glewExtensionCompare(name, _glewExtensionLookup[mid]);

16109 if (cmp < 0) hi = mid - 1;

16110 else if (cmp > 0) lo = mid + 1;

16111 else return mid;

16112 }

16113 return -1;

16114 }

16115

16116 static GLboolean *_glewGetExtensionString(const char *name)

16117 {

16118 ptrdiff_t n = _glewBsearchExtension(name);

16119 if (n >= 0) return &_glewExtensionString[n];

16120 return NULL;

16121 }

16122

16123 static GLboolean *_glewGetExtensionEnable(const char *name)

16124 {

16125 ptrdiff_t n = _glewBsearchExtension(name);

16126 if (n >= 0) return _glewExtensionEnabled[n];

16127 return NULL;

16128 }

16129

16130 static const char *_glewNextSpace(const char *i)

16131 {

16132 const char *j = i;

16133 if (j)

16134 while (*j!=' ' && *j) ++j;

16135 return j;

16136 }

16137

16138 static const char *_glewNextNonSpace(const char *i)

16139 {

16140 const char *j = i;

16141 if (j)

16142 while (*j==' ') ++j;

16143 return j;

16144 }

16145

16146 GLboolean GLEWAPIENTRY glewGetExtension (const char* name)

16147 {

16148 GLboolean *enable = _glewGetExtensionString(name);

16149 if (enable)

16150 return *enable;

16151 return GL_FALSE;

16152 }

16153

16154 /* ------------------------------------------------------------------------- */

16155

16156 typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGPROC) (GLenum name);

16157 typedef void (GLAPIENTRY * PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params);

16158

16159 static GLenum GLEWAPIENTRY glewContextInit ()

16160 {

16161 PFNGLGETSTRINGPROC getString;

16162 const GLubyte* s;

16163 GLuint dot;

16164 GLint major, minor;

16165 size_t n;

16166

16167 #ifdef _WIN32

16168 getString = glGetString;

16169 #else

16170 getString = (PFNGLGETSTRINGPROC) glewGetProcAddress((const GLubyte*)"glGetString");

16171 if (!getString)

16172 return GLEW_ERROR_NO_GL_VERSION;

16173 #endif

16174

16175 /* query opengl version */

16176 s = getString(GL_VERSION);

16177 dot = _glewStrCLen(s, '.');

16178 if (dot == 0)

16179 return GLEW_ERROR_NO_GL_VERSION;

16180

16181 major = s[dot-1]-'0';

16182 minor = s[dot+1]-'0';

16183

16184 if (minor < 0 || minor > 9)

16185 minor = 0;

16186 if (major<0 || major>9)

16187 return GLEW_ERROR_NO_GL_VERSION;

16188

16189 if (major == 1 && minor == 0)

16190 {

16191 return GLEW_ERROR_GL_VERSION_10_ONLY;

16192 }

16193 else

16194 {

16195 GLEW_VERSION_4_6 = ( major > 4 ) || ( major == 4 && minor >= 6 ) ? GL_TRUE : GL_FALSE;

16196 GLEW_VERSION_4_5 = GLEW_VERSION_4_4 == GL_TRUE || ( major == 4 && minor >= 5 ) ? GL_TRUE : GL_FALSE;

16197 GLEW_VERSION_4_4 = GLEW_VERSION_4_5 == GL_TRUE || ( major == 4 && minor >= 4 ) ? GL_TRUE : GL_FALSE;

16198 GLEW_VERSION_4_3 = GLEW_VERSION_4_4 == GL_TRUE || ( major == 4 && minor >= 3 ) ? GL_TRUE : GL_FALSE;

16199 GLEW_VERSION_4_2 = GLEW_VERSION_4_3 == GL_TRUE || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE;

16200 GLEW_VERSION_4_1 = GLEW_VERSION_4_2 == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE;

16201 GLEW_VERSION_4_0 = GLEW_VERSION_4_1 == GL_TRUE || ( major == 4 ) ? GL_TRUE : GL_FALSE;

16202 GLEW_VERSION_3_3 = GLEW_VERSION_4_0 == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE;

16203 GLEW_VERSION_3_2 = GLEW_VERSION_3_3 == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE;

16204 GLEW_VERSION_3_1 = GLEW_VERSION_3_2 == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE;

16205 GLEW_VERSION_3_0 = GLEW_VERSION_3_1 == GL_TRUE || ( major == 3 ) ? GL_TRUE : GL_FALSE;

16206 GLEW_VERSION_2_1 = GLEW_VERSION_3_0 == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE;

16207 GLEW_VERSION_2_0 = GLEW_VERSION_2_1 == GL_TRUE || ( major == 2 ) ? GL_TRUE : GL_FALSE;

16208 GLEW_VERSION_1_5 = GLEW_VERSION_2_0 == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE;

16209 GLEW_VERSION_1_4 = GLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE;

16210 GLEW_VERSION_1_3 = GLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE;

16211 GLEW_VERSION_1_2_1 = GLEW_VERSION_1_3 == GL_TRUE ? GL_TRUE : GL_FALSE;

16212 GLEW_VERSION_1_2 = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE;

16213 GLEW_VERSION_1_1 = GLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE;

16214 }

16215

16216 for (n = 0; n < sizeof(_glewExtensionString) / sizeof(_glewExtensionString[0]); ++n)

16217 _glewExtensionString[n] = GL_FALSE;

16218

16219 if (GLEW_VERSION_3_0)

16220 {

16221 GLint n = 0;

16222 GLint i;

16223 PFNGLGETINTEGERVPROC getIntegerv;

16224 PFNGLGETSTRINGIPROC getStringi;

16225 const char *ext;

16226 GLboolean *enable;

16227

16228 #ifdef _WIN32

16229 getIntegerv = glGetIntegerv;

16230 #else

16231 getIntegerv = (PFNGLGETINTEGERVPROC) glewGetProcAddress((const GLubyte*)"glGetIntegerv");

16232 #endif

16233

16234 if (getIntegerv)

16235 getIntegerv(GL_NUM_EXTENSIONS, &n);

16236

16237 /* glGetStringi is OpenGL 3.0 */

16238 getStringi = (PFNGLGETSTRINGIPROC) glewGetProcAddress((const GLubyte*)"glGetStringi");

16239 if (getStringi)

16240 for (i = 0; i<n; ++i)

16241 {

16242 ext = (const char *) getStringi(GL_EXTENSIONS, i);

16243

16244 /* Based on extension string(s), glewGetExtension purposes */

16245 enable = _glewGetExtensionString(ext);

16246 if (enable)

16247 *enable = GL_TRUE;

16248

16249 /* Based on extension string(s), experimental mode, glewIsSupported purposes */

16250 enable = _glewGetExtensionEnable(ext);

16251 if (enable)

16252 *enable = GL_TRUE;

16253 }

16254 }

16255 else

16256 {

16257 const char *extensions;

16258 const char *end;

16259 const char *i;

16260 const char *j;

16261 char ext[128];

16262 GLboolean *enable;

16263

16264 extensions = (const char *) getString(GL_EXTENSIONS);

16265

16266 if (extensions)

16267 {

16268 end = extensions + _glewStrLen((const GLubyte *) extensions);

16269 for (i=extensions; i<end; i = j + 1)

16270 {

16271 i = _glewNextNonSpace(i);

16272 j = _glewNextSpace(i);

16273

16274 /* Copy extension into NUL terminated string */

16275 if (j-i >= (ptrdiff_t) sizeof(ext))

16276 continue;

16277 _glewStrCopy(ext, i, ' ');

16278

16279 /* Based on extension string(s), glewGetExtension purposes */

16280 enable = _glewGetExtensionString(ext);

16281 if (enable)

16282 *enable = GL_TRUE;

16283

16284 /* Based on extension string(s), experimental mode, glewIsSupported purposes */

16285 enable = _glewGetExtensionEnable(ext);

16286 if (enable)

16287 *enable = GL_TRUE;

16288 }

16289 }

16290 }

16291 #ifdef GL_VERSION_1_2

16292 if (glewExperimental || GLEW_VERSION_1_2) GLEW_VERSION_1_2 = !_glewInit_GL_VERSION_1_2();

16293 #endif /* GL_VERSION_1_2 */

16294 #ifdef GL_VERSION_1_3

16295 if (glewExperimental || GLEW_VERSION_1_3) GLEW_VERSION_1_3 = !_glewInit_GL_VERSION_1_3();

16296 #endif /* GL_VERSION_1_3 */

16297 #ifdef GL_VERSION_1_4

16298 if (glewExperimental || GLEW_VERSION_1_4) GLEW_VERSION_1_4 = !_glewInit_GL_VERSION_1_4();

16299 #endif /* GL_VERSION_1_4 */

16300 #ifdef GL_VERSION_1_5

16301 if (glewExperimental || GLEW_VERSION_1_5) GLEW_VERSION_1_5 = !_glewInit_GL_VERSION_1_5();

16302 #endif /* GL_VERSION_1_5 */

16303 #ifdef GL_VERSION_2_0

16304 if (glewExperimental || GLEW_VERSION_2_0) GLEW_VERSION_2_0 = !_glewInit_GL_VERSION_2_0();

16305 #endif /* GL_VERSION_2_0 */

16306 #ifdef GL_VERSION_2_1

16307 if (glewExperimental || GLEW_VERSION_2_1) GLEW_VERSION_2_1 = !_glewInit_GL_VERSION_2_1();

16308 #endif /* GL_VERSION_2_1 */

16309 #ifdef GL_VERSION_3_0

16310 if (glewExperimental || GLEW_VERSION_3_0) GLEW_VERSION_3_0 = !_glewInit_GL_VERSION_3_0();

16311 #endif /* GL_VERSION_3_0 */

16312 #ifdef GL_VERSION_3_1

16313 if (glewExperimental || GLEW_VERSION_3_1) GLEW_VERSION_3_1 = !_glewInit_GL_VERSION_3_1();

16314 #endif /* GL_VERSION_3_1 */

16315 #ifdef GL_VERSION_3_2

16316 if (glewExperimental || GLEW_VERSION_3_2) GLEW_VERSION_3_2 = !_glewInit_GL_VERSION_3_2();

16317 #endif /* GL_VERSION_3_2 */

16318 #ifdef GL_VERSION_3_3

16319 if (glewExperimental || GLEW_VERSION_3_3) GLEW_VERSION_3_3 = !_glewInit_GL_VERSION_3_3();

16320 #endif /* GL_VERSION_3_3 */

16321 #ifdef GL_VERSION_4_0

16322 if (glewExperimental || GLEW_VERSION_4_0) GLEW_VERSION_4_0 = !_glewInit_GL_VERSION_4_0();

16323 #endif /* GL_VERSION_4_0 */

16324 #ifdef GL_VERSION_4_5

16325 if (glewExperimental || GLEW_VERSION_4_5) GLEW_VERSION_4_5 = !_glewInit_GL_VERSION_4_5();

16326 #endif /* GL_VERSION_4_5 */

16327 #ifdef GL_VERSION_4_6

16328 if (glewExperimental || GLEW_VERSION_4_6) GLEW_VERSION_4_6 = !_glewInit_GL_VERSION_4_6();

16329 #endif /* GL_VERSION_4_6 */

16330 #ifdef GL_3DFX_tbuffer

16331 if (glewExperimental || GLEW_3DFX_tbuffer) GLEW_3DFX_tbuffer = !_glewInit_GL_3DFX_tbuffer();

16332 #endif /* GL_3DFX_tbuffer */

16333 #ifdef GL_AMD_debug_output

16334 if (glewExperimental || GLEW_AMD_debug_output) GLEW_AMD_debug_output = !_glewInit_GL_AMD_debug_output();

16335 #endif /* GL_AMD_debug_output */

16336 #ifdef GL_AMD_draw_buffers_blend

16337 if (glewExperimental || GLEW_AMD_draw_buffers_blend) GLEW_AMD_draw_buffers_blend = !_glewInit_GL_AMD_draw_buffers_blend();

16338 #endif /* GL_AMD_draw_buffers_blend */

16339 #ifdef GL_AMD_framebuffer_sample_positions

16340 if (glewExperimental || GLEW_AMD_framebuffer_sample_positions) GLEW_AMD_framebuffer_sample_positions = !_glewInit_GL_AMD_framebuffer_sample_positions();

16341 #endif /* GL_AMD_framebuffer_sample_positions */

16342 #ifdef GL_AMD_interleaved_elements

16343 if (glewExperimental || GLEW_AMD_interleaved_elements) GLEW_AMD_interleaved_elements = !_glewInit_GL_AMD_interleaved_elements();

16344 #endif /* GL_AMD_interleaved_elements */

16345 #ifdef GL_AMD_multi_draw_indirect

16346 if (glewExperimental || GLEW_AMD_multi_draw_indirect) GLEW_AMD_multi_draw_indirect = !_glewInit_GL_AMD_multi_draw_indirect();

16347 #endif /* GL_AMD_multi_draw_indirect */

16348 #ifdef GL_AMD_name_gen_delete

16349 if (glewExperimental || GLEW_AMD_name_gen_delete) GLEW_AMD_name_gen_delete = !_glewInit_GL_AMD_name_gen_delete();

16350 #endif /* GL_AMD_name_gen_delete */

16351 #ifdef GL_AMD_occlusion_query_event

16352 if (glewExperimental || GLEW_AMD_occlusion_query_event) GLEW_AMD_occlusion_query_event = !_glewInit_GL_AMD_occlusion_query_event();

16353 #endif /* GL_AMD_occlusion_query_event */

16354 #ifdef GL_AMD_performance_monitor

16355 if (glewExperimental || GLEW_AMD_performance_monitor) GLEW_AMD_performance_monitor = !_glewInit_GL_AMD_performance_monitor();

16356 #endif /* GL_AMD_performance_monitor */

16357 #ifdef GL_AMD_sample_positions

16358 if (glewExperimental || GLEW_AMD_sample_positions) GLEW_AMD_sample_positions = !_glewInit_GL_AMD_sample_positions();

16359 #endif /* GL_AMD_sample_positions */

16360 #ifdef GL_AMD_sparse_texture

16361 if (glewExperimental || GLEW_AMD_sparse_texture) GLEW_AMD_sparse_texture = !_glewInit_GL_AMD_sparse_texture();

16362 #endif /* GL_AMD_sparse_texture */

16363 #ifdef GL_AMD_stencil_operation_extended

16364 if (glewExperimental || GLEW_AMD_stencil_operation_extended) GLEW_AMD_stencil_operation_extended = !_glewInit_GL_AMD_stencil_operation_extended();

16365 #endif /* GL_AMD_stencil_operation_extended */

16366 #ifdef GL_AMD_vertex_shader_tessellator

16367 if (glewExperimental || GLEW_AMD_vertex_shader_tessellator) GLEW_AMD_vertex_shader_tessellator = !_glewInit_GL_AMD_vertex_shader_tessellator();

16368 #endif /* GL_AMD_vertex_shader_tessellator */

16369 #ifdef GL_ANGLE_framebuffer_blit

16370 if (glewExperimental || GLEW_ANGLE_framebuffer_blit) GLEW_ANGLE_framebuffer_blit = !_glewInit_GL_ANGLE_framebuffer_blit();

16371 #endif /* GL_ANGLE_framebuffer_blit */

16372 #ifdef GL_ANGLE_framebuffer_multisample

16373 if (glewExperimental || GLEW_ANGLE_framebuffer_multisample) GLEW_ANGLE_framebuffer_multisample = !_glewInit_GL_ANGLE_framebuffer_multisample();

16374 #endif /* GL_ANGLE_framebuffer_multisample */

16375 #ifdef GL_ANGLE_instanced_arrays

16376 if (glewExperimental || GLEW_ANGLE_instanced_arrays) GLEW_ANGLE_instanced_arrays = !_glewInit_GL_ANGLE_instanced_arrays();

16377 #endif /* GL_ANGLE_instanced_arrays */

16378 #ifdef GL_ANGLE_timer_query

16379 if (glewExperimental || GLEW_ANGLE_timer_query) GLEW_ANGLE_timer_query = !_glewInit_GL_ANGLE_timer_query();

16380 #endif /* GL_ANGLE_timer_query */

16381 #ifdef GL_ANGLE_translated_shader_source

16382 if (glewExperimental || GLEW_ANGLE_translated_shader_source) GLEW_ANGLE_translated_shader_source = !_glewInit_GL_ANGLE_translated_shader_source();

16383 #endif /* GL_ANGLE_translated_shader_source */

16384 #ifdef GL_APPLE_copy_texture_levels

16385 if (glewExperimental || GLEW_APPLE_copy_texture_levels) GLEW_APPLE_copy_texture_levels = !_glewInit_GL_APPLE_copy_texture_levels();

16386 #endif /* GL_APPLE_copy_texture_levels */

16387 #ifdef GL_APPLE_element_array

16388 if (glewExperimental || GLEW_APPLE_element_array) GLEW_APPLE_element_array = !_glewInit_GL_APPLE_element_array();

16389 #endif /* GL_APPLE_element_array */

16390 #ifdef GL_APPLE_fence

16391 if (glewExperimental || GLEW_APPLE_fence) GLEW_APPLE_fence = !_glewInit_GL_APPLE_fence();

16392 #endif /* GL_APPLE_fence */

16393 #ifdef GL_APPLE_flush_buffer_range

16394 if (glewExperimental || GLEW_APPLE_flush_buffer_range) GLEW_APPLE_flush_buffer_range = !_glewInit_GL_APPLE_flush_buffer_range();

16395 #endif /* GL_APPLE_flush_buffer_range */

16396 #ifdef GL_APPLE_framebuffer_multisample

16397 if (glewExperimental || GLEW_APPLE_framebuffer_multisample) GLEW_APPLE_framebuffer_multisample = !_glewInit_GL_APPLE_framebuffer_multisample();

16398 #endif /* GL_APPLE_framebuffer_multisample */

16399 #ifdef GL_APPLE_object_purgeable

16400 if (glewExperimental || GLEW_APPLE_object_purgeable) GLEW_APPLE_object_purgeable = !_glewInit_GL_APPLE_object_purgeable();

16401 #endif /* GL_APPLE_object_purgeable */

16402 #ifdef GL_APPLE_sync

16403 if (glewExperimental || GLEW_APPLE_sync) GLEW_APPLE_sync = !_glewInit_GL_APPLE_sync();

16404 #endif /* GL_APPLE_sync */

16405 #ifdef GL_APPLE_texture_range

16406 if (glewExperimental || GLEW_APPLE_texture_range) GLEW_APPLE_texture_range = !_glewInit_GL_APPLE_texture_range();

16407 #endif /* GL_APPLE_texture_range */

16408 #ifdef GL_APPLE_vertex_array_object

16409 if (glewExperimental || GLEW_APPLE_vertex_array_object) GLEW_APPLE_vertex_array_object = !_glewInit_GL_APPLE_vertex_array_object();

16410 #endif /* GL_APPLE_vertex_array_object */

16411 #ifdef GL_APPLE_vertex_array_range

16412 if (glewExperimental || GLEW_APPLE_vertex_array_range) GLEW_APPLE_vertex_array_range = !_glewInit_GL_APPLE_vertex_array_range();

16413 #endif /* GL_APPLE_vertex_array_range */

16414 #ifdef GL_APPLE_vertex_program_evaluators

16415 if (glewExperimental || GLEW_APPLE_vertex_program_evaluators) GLEW_APPLE_vertex_program_evaluators = !_glewInit_GL_APPLE_vertex_program_evaluators();

16416 #endif /* GL_APPLE_vertex_program_evaluators */

16417 #ifdef GL_ARB_ES2_compatibility

16418 if (glewExperimental || GLEW_ARB_ES2_compatibility) GLEW_ARB_ES2_compatibility = !_glewInit_GL_ARB_ES2_compatibility();

16419 #endif /* GL_ARB_ES2_compatibility */

16420 #ifdef GL_ARB_ES3_1_compatibility

16421 if (glewExperimental || GLEW_ARB_ES3_1_compatibility) GLEW_ARB_ES3_1_compatibility = !_glewInit_GL_ARB_ES3_1_compatibility();

16422 #endif /* GL_ARB_ES3_1_compatibility */

16423 #ifdef GL_ARB_ES3_2_compatibility

16424 if (glewExperimental || GLEW_ARB_ES3_2_compatibility) GLEW_ARB_ES3_2_compatibility = !_glewInit_GL_ARB_ES3_2_compatibility();

16425 #endif /* GL_ARB_ES3_2_compatibility */

16426 #ifdef GL_ARB_base_instance

16427 if (glewExperimental || GLEW_ARB_base_instance) GLEW_ARB_base_instance = !_glewInit_GL_ARB_base_instance();

16428 #endif /* GL_ARB_base_instance */

16429 #ifdef GL_ARB_bindless_texture

16430 if (glewExperimental || GLEW_ARB_bindless_texture) GLEW_ARB_bindless_texture = !_glewInit_GL_ARB_bindless_texture();

16431 #endif /* GL_ARB_bindless_texture */

16432 #ifdef GL_ARB_blend_func_extended

16433 if (glewExperimental || GLEW_ARB_blend_func_extended) GLEW_ARB_blend_func_extended = !_glewInit_GL_ARB_blend_func_extended();

16434 #endif /* GL_ARB_blend_func_extended */

16435 #ifdef GL_ARB_buffer_storage

16436 if (glewExperimental || GLEW_ARB_buffer_storage) GLEW_ARB_buffer_storage = !_glewInit_GL_ARB_buffer_storage();

16437 #endif /* GL_ARB_buffer_storage */

16438 #ifdef GL_ARB_cl_event

16439 if (glewExperimental || GLEW_ARB_cl_event) GLEW_ARB_cl_event = !_glewInit_GL_ARB_cl_event();

16440 #endif /* GL_ARB_cl_event */

16441 #ifdef GL_ARB_clear_buffer_object

16442 if (glewExperimental || GLEW_ARB_clear_buffer_object) GLEW_ARB_clear_buffer_object = !_glewInit_GL_ARB_clear_buffer_object();

16443 #endif /* GL_ARB_clear_buffer_object */

16444 #ifdef GL_ARB_clear_texture

16445 if (glewExperimental || GLEW_ARB_clear_texture) GLEW_ARB_clear_texture = !_glewInit_GL_ARB_clear_texture();

16446 #endif /* GL_ARB_clear_texture */

16447 #ifdef GL_ARB_clip_control

16448 if (glewExperimental || GLEW_ARB_clip_control) GLEW_ARB_clip_control = !_glewInit_GL_ARB_clip_control();

16449 #endif /* GL_ARB_clip_control */

16450 #ifdef GL_ARB_color_buffer_float

16451 if (glewExperimental || GLEW_ARB_color_buffer_float) GLEW_ARB_color_buffer_float = !_glewInit_GL_ARB_color_buffer_float();

16452 #endif /* GL_ARB_color_buffer_float */

16453 #ifdef GL_ARB_compute_shader

16454 if (glewExperimental || GLEW_ARB_compute_shader) GLEW_ARB_compute_shader = !_glewInit_GL_ARB_compute_shader();

16455 #endif /* GL_ARB_compute_shader */

16456 #ifdef GL_ARB_compute_variable_group_size

16457 if (glewExperimental || GLEW_ARB_compute_variable_group_size) GLEW_ARB_compute_variable_group_size = !_glewInit_GL_ARB_compute_variable_group_size();

16458 #endif /* GL_ARB_compute_variable_group_size */

16459 #ifdef GL_ARB_copy_buffer

16460 if (glewExperimental || GLEW_ARB_copy_buffer) GLEW_ARB_copy_buffer = !_glewInit_GL_ARB_copy_buffer();

16461 #endif /* GL_ARB_copy_buffer */

16462 #ifdef GL_ARB_copy_image

16463 if (glewExperimental || GLEW_ARB_copy_image) GLEW_ARB_copy_image = !_glewInit_GL_ARB_copy_image();

16464 #endif /* GL_ARB_copy_image */

16465 #ifdef GL_ARB_debug_output

16466 if (glewExperimental || GLEW_ARB_debug_output) GLEW_ARB_debug_output = !_glewInit_GL_ARB_debug_output();

16467 #endif /* GL_ARB_debug_output */

16468 #ifdef GL_ARB_direct_state_access

16469 if (glewExperimental || GLEW_ARB_direct_state_access) GLEW_ARB_direct_state_access = !_glewInit_GL_ARB_direct_state_access();

16470 #endif /* GL_ARB_direct_state_access */

16471 #ifdef GL_ARB_draw_buffers

16472 if (glewExperimental || GLEW_ARB_draw_buffers) GLEW_ARB_draw_buffers = !_glewInit_GL_ARB_draw_buffers();

16473 #endif /* GL_ARB_draw_buffers */

16474 #ifdef GL_ARB_draw_buffers_blend

16475 if (glewExperimental || GLEW_ARB_draw_buffers_blend) GLEW_ARB_draw_buffers_blend = !_glewInit_GL_ARB_draw_buffers_blend();

16476 #endif /* GL_ARB_draw_buffers_blend */

16477 #ifdef GL_ARB_draw_elements_base_vertex

16478 if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) GLEW_ARB_draw_elements_base_vertex = !_glewInit_GL_ARB_draw_elements_base_vertex();

16479 #endif /* GL_ARB_draw_elements_base_vertex */

16480 #ifdef GL_ARB_draw_indirect

16481 if (glewExperimental || GLEW_ARB_draw_indirect) GLEW_ARB_draw_indirect = !_glewInit_GL_ARB_draw_indirect();

16482 #endif /* GL_ARB_draw_indirect */

16483 #ifdef GL_ARB_framebuffer_no_attachments

16484 if (glewExperimental || GLEW_ARB_framebuffer_no_attachments) GLEW_ARB_framebuffer_no_attachments = !_glewInit_GL_ARB_framebuffer_no_attachments();

16485 #endif /* GL_ARB_framebuffer_no_attachments */

16486 #ifdef GL_ARB_framebuffer_object

16487 if (glewExperimental || GLEW_ARB_framebuffer_object) GLEW_ARB_framebuffer_object = !_glewInit_GL_ARB_framebuffer_object();

16488 #endif /* GL_ARB_framebuffer_object */

16489 #ifdef GL_ARB_geometry_shader4

16490 if (glewExperimental || GLEW_ARB_geometry_shader4) GLEW_ARB_geometry_shader4 = !_glewInit_GL_ARB_geometry_shader4();

16491 #endif /* GL_ARB_geometry_shader4 */

16492 #ifdef GL_ARB_get_program_binary

16493 if (glewExperimental || GLEW_ARB_get_program_binary) GLEW_ARB_get_program_binary = !_glewInit_GL_ARB_get_program_binary();

16494 #endif /* GL_ARB_get_program_binary */

16495 #ifdef GL_ARB_get_texture_sub_image

16496 if (glewExperimental || GLEW_ARB_get_texture_sub_image) GLEW_ARB_get_texture_sub_image = !_glewInit_GL_ARB_get_texture_sub_image();

16497 #endif /* GL_ARB_get_texture_sub_image */

16498 #ifdef GL_ARB_gl_spirv

16499 if (glewExperimental || GLEW_ARB_gl_spirv) GLEW_ARB_gl_spirv = !_glewInit_GL_ARB_gl_spirv();

16500 #endif /* GL_ARB_gl_spirv */

16501 #ifdef GL_ARB_gpu_shader_fp64

16502 if (glewExperimental || GLEW_ARB_gpu_shader_fp64) GLEW_ARB_gpu_shader_fp64 = !_glewInit_GL_ARB_gpu_shader_fp64();

16503 #endif /* GL_ARB_gpu_shader_fp64 */

16504 #ifdef GL_ARB_gpu_shader_int64

16505 if (glewExperimental || GLEW_ARB_gpu_shader_int64) GLEW_ARB_gpu_shader_int64 = !_glewInit_GL_ARB_gpu_shader_int64();

16506 #endif /* GL_ARB_gpu_shader_int64 */

16507 #ifdef GL_ARB_imaging

16508 if (glewExperimental || GLEW_ARB_imaging) GLEW_ARB_imaging = !_glewInit_GL_ARB_imaging();

16509 #endif /* GL_ARB_imaging */

16510 #ifdef GL_ARB_indirect_parameters

16511 if (glewExperimental || GLEW_ARB_indirect_parameters) GLEW_ARB_indirect_parameters = !_glewInit_GL_ARB_indirect_parameters();

16512 #endif /* GL_ARB_indirect_parameters */

16513 #ifdef GL_ARB_instanced_arrays

16514 if (glewExperimental || GLEW_ARB_instanced_arrays) GLEW_ARB_instanced_arrays = !_glewInit_GL_ARB_instanced_arrays();

16515 #endif /* GL_ARB_instanced_arrays */

16516 #ifdef GL_ARB_internalformat_query

16517 if (glewExperimental || GLEW_ARB_internalformat_query) GLEW_ARB_internalformat_query = !_glewInit_GL_ARB_internalformat_query();

16518 #endif /* GL_ARB_internalformat_query */

16519 #ifdef GL_ARB_internalformat_query2

16520 if (glewExperimental || GLEW_ARB_internalformat_query2) GLEW_ARB_internalformat_query2 = !_glewInit_GL_ARB_internalformat_query2();

16521 #endif /* GL_ARB_internalformat_query2 */

16522 #ifdef GL_ARB_invalidate_subdata

16523 if (glewExperimental || GLEW_ARB_invalidate_subdata) GLEW_ARB_invalidate_subdata = !_glewInit_GL_ARB_invalidate_subdata();

16524 #endif /* GL_ARB_invalidate_subdata */

16525 #ifdef GL_ARB_map_buffer_range

16526 if (glewExperimental || GLEW_ARB_map_buffer_range) GLEW_ARB_map_buffer_range = !_glewInit_GL_ARB_map_buffer_range();

16527 #endif /* GL_ARB_map_buffer_range */

16528 #ifdef GL_ARB_matrix_palette

16529 if (glewExperimental || GLEW_ARB_matrix_palette) GLEW_ARB_matrix_palette = !_glewInit_GL_ARB_matrix_palette();

16530 #endif /* GL_ARB_matrix_palette */

16531 #ifdef GL_ARB_multi_bind

16532 if (glewExperimental || GLEW_ARB_multi_bind) GLEW_ARB_multi_bind = !_glewInit_GL_ARB_multi_bind();

16533 #endif /* GL_ARB_multi_bind */

16534 #ifdef GL_ARB_multi_draw_indirect

16535 if (glewExperimental || GLEW_ARB_multi_draw_indirect) GLEW_ARB_multi_draw_indirect = !_glewInit_GL_ARB_multi_draw_indirect();

16536 #endif /* GL_ARB_multi_draw_indirect */

16537 #ifdef GL_ARB_multisample

16538 if (glewExperimental || GLEW_ARB_multisample) GLEW_ARB_multisample = !_glewInit_GL_ARB_multisample();

16539 #endif /* GL_ARB_multisample */

16540 #ifdef GL_ARB_multitexture

16541 if (glewExperimental || GLEW_ARB_multitexture) GLEW_ARB_multitexture = !_glewInit_GL_ARB_multitexture();

16542 #endif /* GL_ARB_multitexture */

16543 #ifdef GL_ARB_occlusion_query

16544 if (glewExperimental || GLEW_ARB_occlusion_query) GLEW_ARB_occlusion_query = !_glewInit_GL_ARB_occlusion_query();

16545 #endif /* GL_ARB_occlusion_query */

16546 #ifdef GL_ARB_parallel_shader_compile

16547 if (glewExperimental || GLEW_ARB_parallel_shader_compile) GLEW_ARB_parallel_shader_compile = !_glewInit_GL_ARB_parallel_shader_compile();

16548 #endif /* GL_ARB_parallel_shader_compile */

16549 #ifdef GL_ARB_point_parameters

16550 if (glewExperimental || GLEW_ARB_point_parameters) GLEW_ARB_point_parameters = !_glewInit_GL_ARB_point_parameters();

16551 #endif /* GL_ARB_point_parameters */

16552 #ifdef GL_ARB_polygon_offset_clamp

16553 if (glewExperimental || GLEW_ARB_polygon_offset_clamp) GLEW_ARB_polygon_offset_clamp = !_glewInit_GL_ARB_polygon_offset_clamp();

16554 #endif /* GL_ARB_polygon_offset_clamp */

16555 #ifdef GL_ARB_program_interface_query

16556 if (glewExperimental || GLEW_ARB_program_interface_query) GLEW_ARB_program_interface_query = !_glewInit_GL_ARB_program_interface_query();

16557 #endif /* GL_ARB_program_interface_query */

16558 #ifdef GL_ARB_provoking_vertex

16559 if (glewExperimental || GLEW_ARB_provoking_vertex) GLEW_ARB_provoking_vertex = !_glewInit_GL_ARB_provoking_vertex();

16560 #endif /* GL_ARB_provoking_vertex */

16561 #ifdef GL_ARB_robustness

16562 if (glewExperimental || GLEW_ARB_robustness) GLEW_ARB_robustness = !_glewInit_GL_ARB_robustness();

16563 #endif /* GL_ARB_robustness */

16564 #ifdef GL_ARB_sample_locations

16565 if (glewExperimental || GLEW_ARB_sample_locations) GLEW_ARB_sample_locations = !_glewInit_GL_ARB_sample_locations();

16566 #endif /* GL_ARB_sample_locations */

16567 #ifdef GL_ARB_sample_shading

16568 if (glewExperimental || GLEW_ARB_sample_shading) GLEW_ARB_sample_shading = !_glewInit_GL_ARB_sample_shading();

16569 #endif /* GL_ARB_sample_shading */

16570 #ifdef GL_ARB_sampler_objects

16571 if (glewExperimental || GLEW_ARB_sampler_objects) GLEW_ARB_sampler_objects = !_glewInit_GL_ARB_sampler_objects();

16572 #endif /* GL_ARB_sampler_objects */

16573 #ifdef GL_ARB_separate_shader_objects

16574 if (glewExperimental || GLEW_ARB_separate_shader_objects) GLEW_ARB_separate_shader_objects = !_glewInit_GL_ARB_separate_shader_objects();

16575 #endif /* GL_ARB_separate_shader_objects */

16576 #ifdef GL_ARB_shader_atomic_counters

16577 if (glewExperimental || GLEW_ARB_shader_atomic_counters) GLEW_ARB_shader_atomic_counters = !_glewInit_GL_ARB_shader_atomic_counters();

16578 #endif /* GL_ARB_shader_atomic_counters */

16579 #ifdef GL_ARB_shader_image_load_store

16580 if (glewExperimental || GLEW_ARB_shader_image_load_store) GLEW_ARB_shader_image_load_store = !_glewInit_GL_ARB_shader_image_load_store();

16581 #endif /* GL_ARB_shader_image_load_store */

16582 #ifdef GL_ARB_shader_objects

16583 if (glewExperimental || GLEW_ARB_shader_objects) GLEW_ARB_shader_objects = !_glewInit_GL_ARB_shader_objects();

16584 #endif /* GL_ARB_shader_objects */

16585 #ifdef GL_ARB_shader_storage_buffer_object

16586 if (glewExperimental || GLEW_ARB_shader_storage_buffer_object) GLEW_ARB_shader_storage_buffer_object = !_glewInit_GL_ARB_shader_storage_buffer_object();

16587 #endif /* GL_ARB_shader_storage_buffer_object */

16588 #ifdef GL_ARB_shader_subroutine

16589 if (glewExperimental || GLEW_ARB_shader_subroutine) GLEW_ARB_shader_subroutine = !_glewInit_GL_ARB_shader_subroutine();

16590 #endif /* GL_ARB_shader_subroutine */

16591 #ifdef GL_ARB_shading_language_include

16592 if (glewExperimental || GLEW_ARB_shading_language_include) GLEW_ARB_shading_language_include = !_glewInit_GL_ARB_shading_language_include();

16593 #endif /* GL_ARB_shading_language_include */

16594 #ifdef GL_ARB_sparse_buffer

16595 if (glewExperimental || GLEW_ARB_sparse_buffer) GLEW_ARB_sparse_buffer = !_glewInit_GL_ARB_sparse_buffer();

16596 #endif /* GL_ARB_sparse_buffer */

16597 #ifdef GL_ARB_sparse_texture

16598 if (glewExperimental || GLEW_ARB_sparse_texture) GLEW_ARB_sparse_texture = !_glewInit_GL_ARB_sparse_texture();

16599 #endif /* GL_ARB_sparse_texture */

16600 #ifdef GL_ARB_sync

16601 if (glewExperimental || GLEW_ARB_sync) GLEW_ARB_sync = !_glewInit_GL_ARB_sync();

16602 #endif /* GL_ARB_sync */

16603 #ifdef GL_ARB_tessellation_shader

16604 if (glewExperimental || GLEW_ARB_tessellation_shader) GLEW_ARB_tessellation_shader = !_glewInit_GL_ARB_tessellation_shader();

16605 #endif /* GL_ARB_tessellation_shader */

16606 #ifdef GL_ARB_texture_barrier

16607 if (glewExperimental || GLEW_ARB_texture_barrier) GLEW_ARB_texture_barrier = !_glewInit_GL_ARB_texture_barrier();

16608 #endif /* GL_ARB_texture_barrier */

16609 #ifdef GL_ARB_texture_buffer_object

16610 if (glewExperimental || GLEW_ARB_texture_buffer_object) GLEW_ARB_texture_buffer_object = !_glewInit_GL_ARB_texture_buffer_object();

16611 #endif /* GL_ARB_texture_buffer_object */

16612 #ifdef GL_ARB_texture_buffer_range

16613 if (glewExperimental || GLEW_ARB_texture_buffer_range) GLEW_ARB_texture_buffer_range = !_glewInit_GL_ARB_texture_buffer_range();

16614 #endif /* GL_ARB_texture_buffer_range */

16615 #ifdef GL_ARB_texture_compression

16616 if (glewExperimental || GLEW_ARB_texture_compression) GLEW_ARB_texture_compression = !_glewInit_GL_ARB_texture_compression();

16617 #endif /* GL_ARB_texture_compression */

16618 #ifdef GL_ARB_texture_multisample

16619 if (glewExperimental || GLEW_ARB_texture_multisample) GLEW_ARB_texture_multisample = !_glewInit_GL_ARB_texture_multisample();

16620 #endif /* GL_ARB_texture_multisample */

16621 #ifdef GL_ARB_texture_storage

16622 if (glewExperimental || GLEW_ARB_texture_storage) GLEW_ARB_texture_storage = !_glewInit_GL_ARB_texture_storage();

16623 #endif /* GL_ARB_texture_storage */

16624 #ifdef GL_ARB_texture_storage_multisample

16625 if (glewExperimental || GLEW_ARB_texture_storage_multisample) GLEW_ARB_texture_storage_multisample = !_glewInit_GL_ARB_texture_storage_multisample();

16626 #endif /* GL_ARB_texture_storage_multisample */

16627 #ifdef GL_ARB_texture_view

16628 if (glewExperimental || GLEW_ARB_texture_view) GLEW_ARB_texture_view = !_glewInit_GL_ARB_texture_view();

16629 #endif /* GL_ARB_texture_view */

16630 #ifdef GL_ARB_timer_query

16631 if (glewExperimental || GLEW_ARB_timer_query) GLEW_ARB_timer_query = !_glewInit_GL_ARB_timer_query();

16632 #endif /* GL_ARB_timer_query */

16633 #ifdef GL_ARB_transform_feedback2

16634 if (glewExperimental || GLEW_ARB_transform_feedback2) GLEW_ARB_transform_feedback2 = !_glewInit_GL_ARB_transform_feedback2();

16635 #endif /* GL_ARB_transform_feedback2 */

16636 #ifdef GL_ARB_transform_feedback3

16637 if (glewExperimental || GLEW_ARB_transform_feedback3) GLEW_ARB_transform_feedback3 = !_glewInit_GL_ARB_transform_feedback3();

16638 #endif /* GL_ARB_transform_feedback3 */

16639 #ifdef GL_ARB_transform_feedback_instanced

16640 if (glewExperimental || GLEW_ARB_transform_feedback_instanced) GLEW_ARB_transform_feedback_instanced = !_glewInit_GL_ARB_transform_feedback_instanced();

16641 #endif /* GL_ARB_transform_feedback_instanced */

16642 #ifdef GL_ARB_transpose_matrix

16643 if (glewExperimental || GLEW_ARB_transpose_matrix) GLEW_ARB_transpose_matrix = !_glewInit_GL_ARB_transpose_matrix();

16644 #endif /* GL_ARB_transpose_matrix */

16645 #ifdef GL_ARB_uniform_buffer_object

16646 if (glewExperimental || GLEW_ARB_uniform_buffer_object) GLEW_ARB_uniform_buffer_object = !_glewInit_GL_ARB_uniform_buffer_object();

16647 #endif /* GL_ARB_uniform_buffer_object */

16648 #ifdef GL_ARB_vertex_array_object

16649 if (glewExperimental || GLEW_ARB_vertex_array_object) GLEW_ARB_vertex_array_object = !_glewInit_GL_ARB_vertex_array_object();

16650 #endif /* GL_ARB_vertex_array_object */

16651 #ifdef GL_ARB_vertex_attrib_64bit

16652 if (glewExperimental || GLEW_ARB_vertex_attrib_64bit) GLEW_ARB_vertex_attrib_64bit = !_glewInit_GL_ARB_vertex_attrib_64bit();

16653 #endif /* GL_ARB_vertex_attrib_64bit */

16654 #ifdef GL_ARB_vertex_attrib_binding

16655 if (glewExperimental || GLEW_ARB_vertex_attrib_binding) GLEW_ARB_vertex_attrib_binding = !_glewInit_GL_ARB_vertex_attrib_binding();

16656 #endif /* GL_ARB_vertex_attrib_binding */

16657 #ifdef GL_ARB_vertex_blend

16658 if (glewExperimental || GLEW_ARB_vertex_blend) GLEW_ARB_vertex_blend = !_glewInit_GL_ARB_vertex_blend();

16659 #endif /* GL_ARB_vertex_blend */

16660 #ifdef GL_ARB_vertex_buffer_object

16661 if (glewExperimental || GLEW_ARB_vertex_buffer_object) GLEW_ARB_vertex_buffer_object = !_glewInit_GL_ARB_vertex_buffer_object();

16662 #endif /* GL_ARB_vertex_buffer_object */

16663 #ifdef GL_ARB_vertex_program

16664 if (glewExperimental || GLEW_ARB_vertex_program) GLEW_ARB_vertex_program = !_glewInit_GL_ARB_vertex_program();

16665 #endif /* GL_ARB_vertex_program */

16666 #ifdef GL_ARB_vertex_shader

16667 if (glewExperimental || GLEW_ARB_vertex_shader) { GLEW_ARB_vertex_shader = !_glewInit_GL_ARB_vertex_shader(); _glewInit_GL_ARB_vertex_program(); }

16668 #endif /* GL_ARB_vertex_shader */

16669 #ifdef GL_ARB_vertex_type_2_10_10_10_rev

16670 if (glewExperimental || GLEW_ARB_vertex_type_2_10_10_10_rev) GLEW_ARB_vertex_type_2_10_10_10_rev = !_glewInit_GL_ARB_vertex_type_2_10_10_10_rev();

16671 #endif /* GL_ARB_vertex_type_2_10_10_10_rev */

16672 #ifdef GL_ARB_viewport_array

16673 if (glewExperimental || GLEW_ARB_viewport_array) GLEW_ARB_viewport_array = !_glewInit_GL_ARB_viewport_array();

16674 #endif /* GL_ARB_viewport_array */

16675 #ifdef GL_ARB_window_pos

16676 if (glewExperimental || GLEW_ARB_window_pos) GLEW_ARB_window_pos = !_glewInit_GL_ARB_window_pos();

16677 #endif /* GL_ARB_window_pos */

16678 #ifdef GL_ATI_draw_buffers

16679 if (glewExperimental || GLEW_ATI_draw_buffers) GLEW_ATI_draw_buffers = !_glewInit_GL_ATI_draw_buffers();

16680 #endif /* GL_ATI_draw_buffers */

16681 #ifdef GL_ATI_element_array

16682 if (glewExperimental || GLEW_ATI_element_array) GLEW_ATI_element_array = !_glewInit_GL_ATI_element_array();

16683 #endif /* GL_ATI_element_array */

16684 #ifdef GL_ATI_envmap_bumpmap

16685 if (glewExperimental || GLEW_ATI_envmap_bumpmap) GLEW_ATI_envmap_bumpmap = !_glewInit_GL_ATI_envmap_bumpmap();

16686 #endif /* GL_ATI_envmap_bumpmap */

16687 #ifdef GL_ATI_fragment_shader

16688 if (glewExperimental || GLEW_ATI_fragment_shader) GLEW_ATI_fragment_shader = !_glewInit_GL_ATI_fragment_shader();

16689 #endif /* GL_ATI_fragment_shader */

16690 #ifdef GL_ATI_map_object_buffer

16691 if (glewExperimental || GLEW_ATI_map_object_buffer) GLEW_ATI_map_object_buffer = !_glewInit_GL_ATI_map_object_buffer();

16692 #endif /* GL_ATI_map_object_buffer */

16693 #ifdef GL_ATI_pn_triangles

16694 if (glewExperimental || GLEW_ATI_pn_triangles) GLEW_ATI_pn_triangles = !_glewInit_GL_ATI_pn_triangles();

16695 #endif /* GL_ATI_pn_triangles */

16696 #ifdef GL_ATI_separate_stencil

16697 if (glewExperimental || GLEW_ATI_separate_stencil) GLEW_ATI_separate_stencil = !_glewInit_GL_ATI_separate_stencil();

16698 #endif /* GL_ATI_separate_stencil */

16699 #ifdef GL_ATI_vertex_array_object

16700 if (glewExperimental || GLEW_ATI_vertex_array_object) GLEW_ATI_vertex_array_object = !_glewInit_GL_ATI_vertex_array_object();

16701 #endif /* GL_ATI_vertex_array_object */

16702 #ifdef GL_ATI_vertex_attrib_array_object

16703 if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) GLEW_ATI_vertex_attrib_array_object = !_glewInit_GL_ATI_vertex_attrib_array_object();

16704 #endif /* GL_ATI_vertex_attrib_array_object */

16705 #ifdef GL_ATI_vertex_streams

16706 if (glewExperimental || GLEW_ATI_vertex_streams) GLEW_ATI_vertex_streams = !_glewInit_GL_ATI_vertex_streams();

16707 #endif /* GL_ATI_vertex_streams */

16708 #ifdef GL_EXT_base_instance

16709 if (glewExperimental || GLEW_EXT_base_instance) GLEW_EXT_base_instance = !_glewInit_GL_EXT_base_instance();

16710 #endif /* GL_EXT_base_instance */

16711 #ifdef GL_EXT_bindable_uniform

16712 if (glewExperimental || GLEW_EXT_bindable_uniform) GLEW_EXT_bindable_uniform = !_glewInit_GL_EXT_bindable_uniform();

16713 #endif /* GL_EXT_bindable_uniform */

16714 #ifdef GL_EXT_blend_color

16715 if (glewExperimental || GLEW_EXT_blend_color) GLEW_EXT_blend_color = !_glewInit_GL_EXT_blend_color();

16716 #endif /* GL_EXT_blend_color */

16717 #ifdef GL_EXT_blend_equation_separate

16718 if (glewExperimental || GLEW_EXT_blend_equation_separate) GLEW_EXT_blend_equation_separate = !_glewInit_GL_EXT_blend_equation_separate();

16719 #endif /* GL_EXT_blend_equation_separate */

16720 #ifdef GL_EXT_blend_func_extended

16721 if (glewExperimental || GLEW_EXT_blend_func_extended) GLEW_EXT_blend_func_extended = !_glewInit_GL_EXT_blend_func_extended();

16722 #endif /* GL_EXT_blend_func_extended */

16723 #ifdef GL_EXT_blend_func_separate

16724 if (glewExperimental || GLEW_EXT_blend_func_separate) GLEW_EXT_blend_func_separate = !_glewInit_GL_EXT_blend_func_separate();

16725 #endif /* GL_EXT_blend_func_separate */

16726 #ifdef GL_EXT_blend_minmax

16727 if (glewExperimental || GLEW_EXT_blend_minmax) GLEW_EXT_blend_minmax = !_glewInit_GL_EXT_blend_minmax();

16728 #endif /* GL_EXT_blend_minmax */

16729 #ifdef GL_EXT_buffer_storage

16730 if (glewExperimental || GLEW_EXT_buffer_storage) GLEW_EXT_buffer_storage = !_glewInit_GL_EXT_buffer_storage();

16731 #endif /* GL_EXT_buffer_storage */

16732 #ifdef GL_EXT_clear_texture

16733 if (glewExperimental || GLEW_EXT_clear_texture) GLEW_EXT_clear_texture = !_glewInit_GL_EXT_clear_texture();

16734 #endif /* GL_EXT_clear_texture */

16735 #ifdef GL_EXT_color_subtable

16736 if (glewExperimental || GLEW_EXT_color_subtable) GLEW_EXT_color_subtable = !_glewInit_GL_EXT_color_subtable();

16737 #endif /* GL_EXT_color_subtable */

16738 #ifdef GL_EXT_compiled_vertex_array

16739 if (glewExperimental || GLEW_EXT_compiled_vertex_array) GLEW_EXT_compiled_vertex_array = !_glewInit_GL_EXT_compiled_vertex_array();

16740 #endif /* GL_EXT_compiled_vertex_array */

16741 #ifdef GL_EXT_convolution

16742 if (glewExperimental || GLEW_EXT_convolution) GLEW_EXT_convolution = !_glewInit_GL_EXT_convolution();

16743 #endif /* GL_EXT_convolution */

16744 #ifdef GL_EXT_coordinate_frame

16745 if (glewExperimental || GLEW_EXT_coordinate_frame) GLEW_EXT_coordinate_frame = !_glewInit_GL_EXT_coordinate_frame();

16746 #endif /* GL_EXT_coordinate_frame */

16747 #ifdef GL_EXT_copy_image

16748 if (glewExperimental || GLEW_EXT_copy_image) GLEW_EXT_copy_image = !_glewInit_GL_EXT_copy_image();

16749 #endif /* GL_EXT_copy_image */

16750 #ifdef GL_EXT_copy_texture

16751 if (glewExperimental || GLEW_EXT_copy_texture) GLEW_EXT_copy_texture = !_glewInit_GL_EXT_copy_texture();

16752 #endif /* GL_EXT_copy_texture */

16753 #ifdef GL_EXT_cull_vertex

16754 if (glewExperimental || GLEW_EXT_cull_vertex) GLEW_EXT_cull_vertex = !_glewInit_GL_EXT_cull_vertex();

16755 #endif /* GL_EXT_cull_vertex */

16756 #ifdef GL_EXT_debug_label

16757 if (glewExperimental || GLEW_EXT_debug_label) GLEW_EXT_debug_label = !_glewInit_GL_EXT_debug_label();

16758 #endif /* GL_EXT_debug_label */

16759 #ifdef GL_EXT_debug_marker

16760 if (glewExperimental || GLEW_EXT_debug_marker) GLEW_EXT_debug_marker = !_glewInit_GL_EXT_debug_marker();

16761 #endif /* GL_EXT_debug_marker */

16762 #ifdef GL_EXT_depth_bounds_test

16763 if (glewExperimental || GLEW_EXT_depth_bounds_test) GLEW_EXT_depth_bounds_test = !_glewInit_GL_EXT_depth_bounds_test();

16764 #endif /* GL_EXT_depth_bounds_test */

16765 #ifdef GL_EXT_direct_state_access

16766 if (glewExperimental || GLEW_EXT_direct_state_access) GLEW_EXT_direct_state_access = !_glewInit_GL_EXT_direct_state_access();

16767 #endif /* GL_EXT_direct_state_access */

16768 #ifdef GL_EXT_discard_framebuffer

16769 if (glewExperimental || GLEW_EXT_discard_framebuffer) GLEW_EXT_discard_framebuffer = !_glewInit_GL_EXT_discard_framebuffer();

16770 #endif /* GL_EXT_discard_framebuffer */

16771 #ifdef GL_EXT_draw_buffers

16772 if (glewExperimental || GLEW_EXT_draw_buffers) GLEW_EXT_draw_buffers = !_glewInit_GL_EXT_draw_buffers();

16773 #endif /* GL_EXT_draw_buffers */

16774 #ifdef GL_EXT_draw_buffers2

16775 if (glewExperimental || GLEW_EXT_draw_buffers2) GLEW_EXT_draw_buffers2 = !_glewInit_GL_EXT_draw_buffers2();

16776 #endif /* GL_EXT_draw_buffers2 */

16777 #ifdef GL_EXT_draw_buffers_indexed

16778 if (glewExperimental || GLEW_EXT_draw_buffers_indexed) GLEW_EXT_draw_buffers_indexed = !_glewInit_GL_EXT_draw_buffers_indexed();

16779 #endif /* GL_EXT_draw_buffers_indexed */

16780 #ifdef GL_EXT_draw_elements_base_vertex

16781 if (glewExperimental || GLEW_EXT_draw_elements_base_vertex) GLEW_EXT_draw_elements_base_vertex = !_glewInit_GL_EXT_draw_elements_base_vertex();

16782 #endif /* GL_EXT_draw_elements_base_vertex */

16783 #ifdef GL_EXT_draw_instanced

16784 if (glewExperimental || GLEW_EXT_draw_instanced) GLEW_EXT_draw_instanced = !_glewInit_GL_EXT_draw_instanced();

16785 #endif /* GL_EXT_draw_instanced */

16786 #ifdef GL_EXT_draw_range_elements

16787 if (glewExperimental || GLEW_EXT_draw_range_elements) GLEW_EXT_draw_range_elements = !_glewInit_GL_EXT_draw_range_elements();

16788 #endif /* GL_EXT_draw_range_elements */

16789 #ifdef GL_EXT_external_buffer

16790 if (glewExperimental || GLEW_EXT_external_buffer) GLEW_EXT_external_buffer = !_glewInit_GL_EXT_external_buffer();

16791 #endif /* GL_EXT_external_buffer */

16792 #ifdef GL_EXT_fog_coord

16793 if (glewExperimental || GLEW_EXT_fog_coord) GLEW_EXT_fog_coord = !_glewInit_GL_EXT_fog_coord();

16794 #endif /* GL_EXT_fog_coord */

16795 #ifdef GL_EXT_fragment_lighting

16796 if (glewExperimental || GLEW_EXT_fragment_lighting) GLEW_EXT_fragment_lighting = !_glewInit_GL_EXT_fragment_lighting();

16797 #endif /* GL_EXT_fragment_lighting */

16798 #ifdef GL_EXT_framebuffer_blit

16799 if (glewExperimental || GLEW_EXT_framebuffer_blit) GLEW_EXT_framebuffer_blit = !_glewInit_GL_EXT_framebuffer_blit();

16800 #endif /* GL_EXT_framebuffer_blit */

16801 #ifdef GL_EXT_framebuffer_multisample

16802 if (glewExperimental || GLEW_EXT_framebuffer_multisample) GLEW_EXT_framebuffer_multisample = !_glewInit_GL_EXT_framebuffer_multisample();

16803 #endif /* GL_EXT_framebuffer_multisample */

16804 #ifdef GL_EXT_framebuffer_object

16805 if (glewExperimental || GLEW_EXT_framebuffer_object) GLEW_EXT_framebuffer_object = !_glewInit_GL_EXT_framebuffer_object();

16806 #endif /* GL_EXT_framebuffer_object */

16807 #ifdef GL_EXT_geometry_shader4

16808 if (glewExperimental || GLEW_EXT_geometry_shader4) GLEW_EXT_geometry_shader4 = !_glewInit_GL_EXT_geometry_shader4();

16809 #endif /* GL_EXT_geometry_shader4 */

16810 #ifdef GL_EXT_gpu_program_parameters

16811 if (glewExperimental || GLEW_EXT_gpu_program_parameters) GLEW_EXT_gpu_program_parameters = !_glewInit_GL_EXT_gpu_program_parameters();

16812 #endif /* GL_EXT_gpu_program_parameters */

16813 #ifdef GL_EXT_gpu_shader4

16814 if (glewExperimental || GLEW_EXT_gpu_shader4) GLEW_EXT_gpu_shader4 = !_glewInit_GL_EXT_gpu_shader4();

16815 #endif /* GL_EXT_gpu_shader4 */

16816 #ifdef GL_EXT_histogram

16817 if (glewExperimental || GLEW_EXT_histogram) GLEW_EXT_histogram = !_glewInit_GL_EXT_histogram();

16818 #endif /* GL_EXT_histogram */

16819 #ifdef GL_EXT_index_func

16820 if (glewExperimental || GLEW_EXT_index_func) GLEW_EXT_index_func = !_glewInit_GL_EXT_index_func();

16821 #endif /* GL_EXT_index_func */

16822 #ifdef GL_EXT_index_material

16823 if (glewExperimental || GLEW_EXT_index_material) GLEW_EXT_index_material = !_glewInit_GL_EXT_index_material();

16824 #endif /* GL_EXT_index_material */

16825 #ifdef GL_EXT_instanced_arrays

16826 if (glewExperimental || GLEW_EXT_instanced_arrays) GLEW_EXT_instanced_arrays = !_glewInit_GL_EXT_instanced_arrays();

16827 #endif /* GL_EXT_instanced_arrays */

16828 #ifdef GL_EXT_light_texture

16829 if (glewExperimental || GLEW_EXT_light_texture) GLEW_EXT_light_texture = !_glewInit_GL_EXT_light_texture();

16830 #endif /* GL_EXT_light_texture */

16831 #ifdef GL_EXT_map_buffer_range

16832 if (glewExperimental || GLEW_EXT_map_buffer_range) GLEW_EXT_map_buffer_range = !_glewInit_GL_EXT_map_buffer_range();

16833 #endif /* GL_EXT_map_buffer_range */

16834 #ifdef GL_EXT_memory_object

16835 if (glewExperimental || GLEW_EXT_memory_object) GLEW_EXT_memory_object = !_glewInit_GL_EXT_memory_object();

16836 #endif /* GL_EXT_memory_object */

16837 #ifdef GL_EXT_memory_object_fd

16838 if (glewExperimental || GLEW_EXT_memory_object_fd) GLEW_EXT_memory_object_fd = !_glewInit_GL_EXT_memory_object_fd();

16839 #endif /* GL_EXT_memory_object_fd */

16840 #ifdef GL_EXT_memory_object_win32

16841 if (glewExperimental || GLEW_EXT_memory_object_win32) GLEW_EXT_memory_object_win32 = !_glewInit_GL_EXT_memory_object_win32();

16842 #endif /* GL_EXT_memory_object_win32 */

16843 #ifdef GL_EXT_multi_draw_arrays

16844 if (glewExperimental || GLEW_EXT_multi_draw_arrays) GLEW_EXT_multi_draw_arrays = !_glewInit_GL_EXT_multi_draw_arrays();

16845 #endif /* GL_EXT_multi_draw_arrays */

16846 #ifdef GL_EXT_multi_draw_indirect

16847 if (glewExperimental || GLEW_EXT_multi_draw_indirect) GLEW_EXT_multi_draw_indirect = !_glewInit_GL_EXT_multi_draw_indirect();

16848 #endif /* GL_EXT_multi_draw_indirect */

16849 #ifdef GL_EXT_multisample

16850 if (glewExperimental || GLEW_EXT_multisample) GLEW_EXT_multisample = !_glewInit_GL_EXT_multisample();

16851 #endif /* GL_EXT_multisample */

16852 #ifdef GL_EXT_multisampled_render_to_texture

16853 if (glewExperimental || GLEW_EXT_multisampled_render_to_texture) GLEW_EXT_multisampled_render_to_texture = !_glewInit_GL_EXT_multisampled_render_to_texture();

16854 #endif /* GL_EXT_multisampled_render_to_texture */

16855 #ifdef GL_EXT_multiview_draw_buffers

16856 if (glewExperimental || GLEW_EXT_multiview_draw_buffers) GLEW_EXT_multiview_draw_buffers = !_glewInit_GL_EXT_multiview_draw_buffers();

16857 #endif /* GL_EXT_multiview_draw_buffers */

16858 #ifdef GL_EXT_paletted_texture

16859 if (glewExperimental || GLEW_EXT_paletted_texture) GLEW_EXT_paletted_texture = !_glewInit_GL_EXT_paletted_texture();

16860 #endif /* GL_EXT_paletted_texture */

16861 #ifdef GL_EXT_pixel_transform

16862 if (glewExperimental || GLEW_EXT_pixel_transform) GLEW_EXT_pixel_transform = !_glewInit_GL_EXT_pixel_transform();

16863 #endif /* GL_EXT_pixel_transform */

16864 #ifdef GL_EXT_point_parameters

16865 if (glewExperimental || GLEW_EXT_point_parameters) GLEW_EXT_point_parameters = !_glewInit_GL_EXT_point_parameters();

16866 #endif /* GL_EXT_point_parameters */

16867 #ifdef GL_EXT_polygon_offset

16868 if (glewExperimental || GLEW_EXT_polygon_offset) GLEW_EXT_polygon_offset = !_glewInit_GL_EXT_polygon_offset();

16869 #endif /* GL_EXT_polygon_offset */

16870 #ifdef GL_EXT_polygon_offset_clamp

16871 if (glewExperimental || GLEW_EXT_polygon_offset_clamp) GLEW_EXT_polygon_offset_clamp = !_glewInit_GL_EXT_polygon_offset_clamp();

16872 #endif /* GL_EXT_polygon_offset_clamp */

16873 #ifdef GL_EXT_provoking_vertex

16874 if (glewExperimental || GLEW_EXT_provoking_vertex) GLEW_EXT_provoking_vertex = !_glewInit_GL_EXT_provoking_vertex();

16875 #endif /* GL_EXT_provoking_vertex */

16876 #ifdef GL_EXT_raster_multisample

16877 if (glewExperimental || GLEW_EXT_raster_multisample) GLEW_EXT_raster_multisample = !_glewInit_GL_EXT_raster_multisample();

16878 #endif /* GL_EXT_raster_multisample */

16879 #ifdef GL_EXT_scene_marker

16880 if (glewExperimental || GLEW_EXT_scene_marker) GLEW_EXT_scene_marker = !_glewInit_GL_EXT_scene_marker();

16881 #endif /* GL_EXT_scene_marker */

16882 #ifdef GL_EXT_secondary_color

16883 if (glewExperimental || GLEW_EXT_secondary_color) GLEW_EXT_secondary_color = !_glewInit_GL_EXT_secondary_color();

16884 #endif /* GL_EXT_secondary_color */

16885 #ifdef GL_EXT_semaphore

16886 if (glewExperimental || GLEW_EXT_semaphore) GLEW_EXT_semaphore = !_glewInit_GL_EXT_semaphore();

16887 #endif /* GL_EXT_semaphore */

16888 #ifdef GL_EXT_semaphore_fd

16889 if (glewExperimental || GLEW_EXT_semaphore_fd) GLEW_EXT_semaphore_fd = !_glewInit_GL_EXT_semaphore_fd();

16890 #endif /* GL_EXT_semaphore_fd */

16891 #ifdef GL_EXT_semaphore_win32

16892 if (glewExperimental || GLEW_EXT_semaphore_win32) GLEW_EXT_semaphore_win32 = !_glewInit_GL_EXT_semaphore_win32();

16893 #endif /* GL_EXT_semaphore_win32 */

16894 #ifdef GL_EXT_separate_shader_objects

16895 if (glewExperimental || GLEW_EXT_separate_shader_objects) GLEW_EXT_separate_shader_objects = !_glewInit_GL_EXT_separate_shader_objects();

16896 #endif /* GL_EXT_separate_shader_objects */

16897 #ifdef GL_EXT_shader_image_load_store

16898 if (glewExperimental || GLEW_EXT_shader_image_load_store) GLEW_EXT_shader_image_load_store = !_glewInit_GL_EXT_shader_image_load_store();

16899 #endif /* GL_EXT_shader_image_load_store */

16900 #ifdef GL_EXT_shader_pixel_local_storage2

16901 if (glewExperimental || GLEW_EXT_shader_pixel_local_storage2) GLEW_EXT_shader_pixel_local_storage2 = !_glewInit_GL_EXT_shader_pixel_local_storage2();

16902 #endif /* GL_EXT_shader_pixel_local_storage2 */

16903 #ifdef GL_EXT_sparse_texture

16904 if (glewExperimental || GLEW_EXT_sparse_texture) GLEW_EXT_sparse_texture = !_glewInit_GL_EXT_sparse_texture();

16905 #endif /* GL_EXT_sparse_texture */

16906 #ifdef GL_EXT_stencil_two_side

16907 if (glewExperimental || GLEW_EXT_stencil_two_side) GLEW_EXT_stencil_two_side = !_glewInit_GL_EXT_stencil_two_side();

16908 #endif /* GL_EXT_stencil_two_side */

16909 #ifdef GL_EXT_subtexture

16910 if (glewExperimental || GLEW_EXT_subtexture) GLEW_EXT_subtexture = !_glewInit_GL_EXT_subtexture();

16911 #endif /* GL_EXT_subtexture */

16912 #ifdef GL_EXT_texture3D

16913 if (glewExperimental || GLEW_EXT_texture3D) GLEW_EXT_texture3D = !_glewInit_GL_EXT_texture3D();

16914 #endif /* GL_EXT_texture3D */

16915 #ifdef GL_EXT_texture_array

16916 if (glewExperimental || GLEW_EXT_texture_array) GLEW_EXT_texture_array = !_glewInit_GL_EXT_texture_array();

16917 #endif /* GL_EXT_texture_array */

16918 #ifdef GL_EXT_texture_buffer_object

16919 if (glewExperimental || GLEW_EXT_texture_buffer_object) GLEW_EXT_texture_buffer_object = !_glewInit_GL_EXT_texture_buffer_object();

16920 #endif /* GL_EXT_texture_buffer_object */

16921 #ifdef GL_EXT_texture_integer

16922 if (glewExperimental || GLEW_EXT_texture_integer) GLEW_EXT_texture_integer = !_glewInit_GL_EXT_texture_integer();

16923 #endif /* GL_EXT_texture_integer */

16924 #ifdef GL_EXT_texture_object

16925 if (glewExperimental || GLEW_EXT_texture_object) GLEW_EXT_texture_object = !_glewInit_GL_EXT_texture_object();

16926 #endif /* GL_EXT_texture_object */

16927 #ifdef GL_EXT_texture_perturb_normal

16928 if (glewExperimental || GLEW_EXT_texture_perturb_normal) GLEW_EXT_texture_perturb_normal = !_glewInit_GL_EXT_texture_perturb_normal();

16929 #endif /* GL_EXT_texture_perturb_normal */

16930 #ifdef GL_EXT_texture_storage

16931 if (glewExperimental || GLEW_EXT_texture_storage) GLEW_EXT_texture_storage = !_glewInit_GL_EXT_texture_storage();

16932 #endif /* GL_EXT_texture_storage */

16933 #ifdef GL_EXT_texture_view

16934 if (glewExperimental || GLEW_EXT_texture_view) GLEW_EXT_texture_view = !_glewInit_GL_EXT_texture_view();

16935 #endif /* GL_EXT_texture_view */

16936 #ifdef GL_EXT_timer_query

16937 if (glewExperimental || GLEW_EXT_timer_query) GLEW_EXT_timer_query = !_glewInit_GL_EXT_timer_query();

16938 #endif /* GL_EXT_timer_query */

16939 #ifdef GL_EXT_transform_feedback

16940 if (glewExperimental || GLEW_EXT_transform_feedback) GLEW_EXT_transform_feedback = !_glewInit_GL_EXT_transform_feedback();

16941 #endif /* GL_EXT_transform_feedback */

16942 #ifdef GL_EXT_vertex_array

16943 if (glewExperimental || GLEW_EXT_vertex_array) GLEW_EXT_vertex_array = !_glewInit_GL_EXT_vertex_array();

16944 #endif /* GL_EXT_vertex_array */

16945 #ifdef GL_EXT_vertex_array_setXXX

16946 if (glewExperimental || GLEW_EXT_vertex_array_setXXX) GLEW_EXT_vertex_array_setXXX = !_glewInit_GL_EXT_vertex_array_setXXX();

16947 #endif /* GL_EXT_vertex_array_setXXX */

16948 #ifdef GL_EXT_vertex_attrib_64bit

16949 if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) GLEW_EXT_vertex_attrib_64bit = !_glewInit_GL_EXT_vertex_attrib_64bit();

16950 #endif /* GL_EXT_vertex_attrib_64bit */

16951 #ifdef GL_EXT_vertex_shader

16952 if (glewExperimental || GLEW_EXT_vertex_shader) GLEW_EXT_vertex_shader = !_glewInit_GL_EXT_vertex_shader();

16953 #endif /* GL_EXT_vertex_shader */

16954 #ifdef GL_EXT_vertex_weighting

16955 if (glewExperimental || GLEW_EXT_vertex_weighting) GLEW_EXT_vertex_weighting = !_glewInit_GL_EXT_vertex_weighting();

16956 #endif /* GL_EXT_vertex_weighting */

16957 #ifdef GL_EXT_win32_keyed_mutex

16958 if (glewExperimental || GLEW_EXT_win32_keyed_mutex) GLEW_EXT_win32_keyed_mutex = !_glewInit_GL_EXT_win32_keyed_mutex();

16959 #endif /* GL_EXT_win32_keyed_mutex */

16960 #ifdef GL_EXT_window_rectangles

16961 if (glewExperimental || GLEW_EXT_window_rectangles) GLEW_EXT_window_rectangles = !_glewInit_GL_EXT_window_rectangles();

16962 #endif /* GL_EXT_window_rectangles */

16963 #ifdef GL_EXT_x11_sync_object

16964 if (glewExperimental || GLEW_EXT_x11_sync_object) GLEW_EXT_x11_sync_object = !_glewInit_GL_EXT_x11_sync_object();

16965 #endif /* GL_EXT_x11_sync_object */

16966 #ifdef GL_GREMEDY_frame_terminator

16967 if (glewExperimental || GLEW_GREMEDY_frame_terminator) GLEW_GREMEDY_frame_terminator = !_glewInit_GL_GREMEDY_frame_terminator();

16968 #endif /* GL_GREMEDY_frame_terminator */

16969 #ifdef GL_GREMEDY_string_marker

16970 if (glewExperimental || GLEW_GREMEDY_string_marker) GLEW_GREMEDY_string_marker = !_glewInit_GL_GREMEDY_string_marker();

16971 #endif /* GL_GREMEDY_string_marker */

16972 #ifdef GL_HP_image_transform

16973 if (glewExperimental || GLEW_HP_image_transform) GLEW_HP_image_transform = !_glewInit_GL_HP_image_transform();

16974 #endif /* GL_HP_image_transform */

16975 #ifdef GL_IBM_multimode_draw_arrays

16976 if (glewExperimental || GLEW_IBM_multimode_draw_arrays) GLEW_IBM_multimode_draw_arrays = !_glewInit_GL_IBM_multimode_draw_arrays();

16977 #endif /* GL_IBM_multimode_draw_arrays */

16978 #ifdef GL_IBM_vertex_array_lists

16979 if (glewExperimental || GLEW_IBM_vertex_array_lists) GLEW_IBM_vertex_array_lists = !_glewInit_GL_IBM_vertex_array_lists();

16980 #endif /* GL_IBM_vertex_array_lists */

16981 #ifdef GL_INTEL_map_texture

16982 if (glewExperimental || GLEW_INTEL_map_texture) GLEW_INTEL_map_texture = !_glewInit_GL_INTEL_map_texture();

16983 #endif /* GL_INTEL_map_texture */

16984 #ifdef GL_INTEL_parallel_arrays

16985 if (glewExperimental || GLEW_INTEL_parallel_arrays) GLEW_INTEL_parallel_arrays = !_glewInit_GL_INTEL_parallel_arrays();

16986 #endif /* GL_INTEL_parallel_arrays */

16987 #ifdef GL_INTEL_performance_query

16988 if (glewExperimental || GLEW_INTEL_performance_query) GLEW_INTEL_performance_query = !_glewInit_GL_INTEL_performance_query();

16989 #endif /* GL_INTEL_performance_query */

16990 #ifdef GL_INTEL_texture_scissor

16991 if (glewExperimental || GLEW_INTEL_texture_scissor) GLEW_INTEL_texture_scissor = !_glewInit_GL_INTEL_texture_scissor();

16992 #endif /* GL_INTEL_texture_scissor */

16993 #ifdef GL_KHR_blend_equation_advanced

16994 if (glewExperimental || GLEW_KHR_blend_equation_advanced) GLEW_KHR_blend_equation_advanced = !_glewInit_GL_KHR_blend_equation_advanced();

16995 #endif /* GL_KHR_blend_equation_advanced */

16996 #ifdef GL_KHR_debug

16997 if (glewExperimental || GLEW_KHR_debug) GLEW_KHR_debug = !_glewInit_GL_KHR_debug();

16998 #endif /* GL_KHR_debug */

16999 #ifdef GL_KHR_parallel_shader_compile

17000 if (glewExperimental || GLEW_KHR_parallel_shader_compile) GLEW_KHR_parallel_shader_compile = !_glewInit_GL_KHR_parallel_shader_compile();

17001 #endif /* GL_KHR_parallel_shader_compile */

17002 #ifdef GL_KHR_robustness

17003 if (glewExperimental || GLEW_KHR_robustness) GLEW_KHR_robustness = !_glewInit_GL_KHR_robustness();

17004 #endif /* GL_KHR_robustness */

17005 #ifdef GL_KTX_buffer_region

17006 if (glewExperimental || GLEW_KTX_buffer_region) GLEW_KTX_buffer_region = !_glewInit_GL_KTX_buffer_region();

17007 #endif /* GL_KTX_buffer_region */

17008 #ifdef GL_MESA_resize_buffers

17009 if (glewExperimental || GLEW_MESA_resize_buffers) GLEW_MESA_resize_buffers = !_glewInit_GL_MESA_resize_buffers();

17010 #endif /* GL_MESA_resize_buffers */

17011 #ifdef GL_MESA_window_pos

17012 if (glewExperimental || GLEW_MESA_window_pos) GLEW_MESA_window_pos = !_glewInit_GL_MESA_window_pos();

17013 #endif /* GL_MESA_window_pos */

17014 #ifdef GL_NVX_conditional_render

17015 if (glewExperimental || GLEW_NVX_conditional_render) GLEW_NVX_conditional_render = !_glewInit_GL_NVX_conditional_render();

17016 #endif /* GL_NVX_conditional_render */

17017 #ifdef GL_NVX_linked_gpu_multicast

17018 if (glewExperimental || GLEW_NVX_linked_gpu_multicast) GLEW_NVX_linked_gpu_multicast = !_glewInit_GL_NVX_linked_gpu_multicast();

17019 #endif /* GL_NVX_linked_gpu_multicast */

17020 #ifdef GL_NV_3dvision_settings

17021 if (glewExperimental || GLEW_NV_3dvision_settings) GLEW_NV_3dvision_settings = !_glewInit_GL_NV_3dvision_settings();

17022 #endif /* GL_NV_3dvision_settings */

17023 #ifdef GL_NV_bindless_multi_draw_indirect

17024 if (glewExperimental || GLEW_NV_bindless_multi_draw_indirect) GLEW_NV_bindless_multi_draw_indirect = !_glewInit_GL_NV_bindless_multi_draw_indirect();

17025 #endif /* GL_NV_bindless_multi_draw_indirect */

17026 #ifdef GL_NV_bindless_multi_draw_indirect_count

17027 if (glewExperimental || GLEW_NV_bindless_multi_draw_indirect_count) GLEW_NV_bindless_multi_draw_indirect_count = !_glewInit_GL_NV_bindless_multi_draw_indirect_count();

17028 #endif /* GL_NV_bindless_multi_draw_indirect_count */

17029 #ifdef GL_NV_bindless_texture

17030 if (glewExperimental || GLEW_NV_bindless_texture) GLEW_NV_bindless_texture = !_glewInit_GL_NV_bindless_texture();

17031 #endif /* GL_NV_bindless_texture */

17032 #ifdef GL_NV_blend_equation_advanced

17033 if (glewExperimental || GLEW_NV_blend_equation_advanced) GLEW_NV_blend_equation_advanced = !_glewInit_GL_NV_blend_equation_advanced();

17034 #endif /* GL_NV_blend_equation_advanced */

17035 #ifdef GL_NV_clip_space_w_scaling

17036 if (glewExperimental || GLEW_NV_clip_space_w_scaling) GLEW_NV_clip_space_w_scaling = !_glewInit_GL_NV_clip_space_w_scaling();

17037 #endif /* GL_NV_clip_space_w_scaling */

17038 #ifdef GL_NV_command_list

17039 if (glewExperimental || GLEW_NV_command_list) GLEW_NV_command_list = !_glewInit_GL_NV_command_list();

17040 #endif /* GL_NV_command_list */

17041 #ifdef GL_NV_conditional_render

17042 if (glewExperimental || GLEW_NV_conditional_render) GLEW_NV_conditional_render = !_glewInit_GL_NV_conditional_render();

17043 #endif /* GL_NV_conditional_render */

17044 #ifdef GL_NV_conservative_raster

17045 if (glewExperimental || GLEW_NV_conservative_raster) GLEW_NV_conservative_raster = !_glewInit_GL_NV_conservative_raster();

17046 #endif /* GL_NV_conservative_raster */

17047 #ifdef GL_NV_conservative_raster_dilate

17048 if (glewExperimental || GLEW_NV_conservative_raster_dilate) GLEW_NV_conservative_raster_dilate = !_glewInit_GL_NV_conservative_raster_dilate();

17049 #endif /* GL_NV_conservative_raster_dilate */

17050 #ifdef GL_NV_conservative_raster_pre_snap_triangles

17051 if (glewExperimental || GLEW_NV_conservative_raster_pre_snap_triangles) GLEW_NV_conservative_raster_pre_snap_triangles = !_glewInit_GL_NV_conservative_raster_pre_snap_triangles();

17052 #endif /* GL_NV_conservative_raster_pre_snap_triangles */

17053 #ifdef GL_NV_copy_buffer

17054 if (glewExperimental || GLEW_NV_copy_buffer) GLEW_NV_copy_buffer = !_glewInit_GL_NV_copy_buffer();

17055 #endif /* GL_NV_copy_buffer */

17056 #ifdef GL_NV_copy_image

17057 if (glewExperimental || GLEW_NV_copy_image) GLEW_NV_copy_image = !_glewInit_GL_NV_copy_image();

17058 #endif /* GL_NV_copy_image */

17059 #ifdef GL_NV_depth_buffer_float

17060 if (glewExperimental || GLEW_NV_depth_buffer_float) GLEW_NV_depth_buffer_float = !_glewInit_GL_NV_depth_buffer_float();

17061 #endif /* GL_NV_depth_buffer_float */

17062 #ifdef GL_NV_draw_buffers

17063 if (glewExperimental || GLEW_NV_draw_buffers) GLEW_NV_draw_buffers = !_glewInit_GL_NV_draw_buffers();

17064 #endif /* GL_NV_draw_buffers */

17065 #ifdef GL_NV_draw_instanced

17066 if (glewExperimental || GLEW_NV_draw_instanced) GLEW_NV_draw_instanced = !_glewInit_GL_NV_draw_instanced();

17067 #endif /* GL_NV_draw_instanced */

17068 #ifdef GL_NV_draw_texture

17069 if (glewExperimental || GLEW_NV_draw_texture) GLEW_NV_draw_texture = !_glewInit_GL_NV_draw_texture();

17070 #endif /* GL_NV_draw_texture */

17071 #ifdef GL_NV_draw_vulkan_image

17072 if (glewExperimental || GLEW_NV_draw_vulkan_image) GLEW_NV_draw_vulkan_image = !_glewInit_GL_NV_draw_vulkan_image();

17073 #endif /* GL_NV_draw_vulkan_image */

17074 #ifdef GL_NV_evaluators

17075 if (glewExperimental || GLEW_NV_evaluators) GLEW_NV_evaluators = !_glewInit_GL_NV_evaluators();

17076 #endif /* GL_NV_evaluators */

17077 #ifdef GL_NV_explicit_multisample

17078 if (glewExperimental || GLEW_NV_explicit_multisample) GLEW_NV_explicit_multisample = !_glewInit_GL_NV_explicit_multisample();

17079 #endif /* GL_NV_explicit_multisample */

17080 #ifdef GL_NV_fence

17081 if (glewExperimental || GLEW_NV_fence) GLEW_NV_fence = !_glewInit_GL_NV_fence();

17082 #endif /* GL_NV_fence */

17083 #ifdef GL_NV_fragment_coverage_to_color

17084 if (glewExperimental || GLEW_NV_fragment_coverage_to_color) GLEW_NV_fragment_coverage_to_color = !_glewInit_GL_NV_fragment_coverage_to_color();

17085 #endif /* GL_NV_fragment_coverage_to_color */

17086 #ifdef GL_NV_fragment_program

17087 if (glewExperimental || GLEW_NV_fragment_program) GLEW_NV_fragment_program = !_glewInit_GL_NV_fragment_program();

17088 #endif /* GL_NV_fragment_program */

17089 #ifdef GL_NV_framebuffer_blit

17090 if (glewExperimental || GLEW_NV_framebuffer_blit) GLEW_NV_framebuffer_blit = !_glewInit_GL_NV_framebuffer_blit();

17091 #endif /* GL_NV_framebuffer_blit */

17092 #ifdef GL_NV_framebuffer_multisample

17093 if (glewExperimental || GLEW_NV_framebuffer_multisample) GLEW_NV_framebuffer_multisample = !_glewInit_GL_NV_framebuffer_multisample();

17094 #endif /* GL_NV_framebuffer_multisample */

17095 #ifdef GL_NV_framebuffer_multisample_coverage

17096 if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) GLEW_NV_framebuffer_multisample_coverage = !_glewInit_GL_NV_framebuffer_multisample_coverage();

17097 #endif /* GL_NV_framebuffer_multisample_coverage */

17098 #ifdef GL_NV_geometry_program4

17099 if (glewExperimental || GLEW_NV_geometry_program4) GLEW_NV_geometry_program4 = !_glewInit_GL_NV_geometry_program4();

17100 #endif /* GL_NV_geometry_program4 */

17101 #ifdef GL_NV_gpu_multicast

17102 if (glewExperimental || GLEW_NV_gpu_multicast) GLEW_NV_gpu_multicast = !_glewInit_GL_NV_gpu_multicast();

17103 #endif /* GL_NV_gpu_multicast */

17104 #ifdef GL_NV_gpu_program4

17105 if (glewExperimental || GLEW_NV_gpu_program4) GLEW_NV_gpu_program4 = !_glewInit_GL_NV_gpu_program4();

17106 #endif /* GL_NV_gpu_program4 */

17107 #ifdef GL_NV_gpu_shader5

17108 if (glewExperimental || GLEW_NV_gpu_shader5) GLEW_NV_gpu_shader5 = !_glewInit_GL_NV_gpu_shader5();

17109 #endif /* GL_NV_gpu_shader5 */

17110 #ifdef GL_NV_half_float

17111 if (glewExperimental || GLEW_NV_half_float) GLEW_NV_half_float = !_glewInit_GL_NV_half_float();

17112 #endif /* GL_NV_half_float */

17113 #ifdef GL_NV_instanced_arrays

17114 if (glewExperimental || GLEW_NV_instanced_arrays) GLEW_NV_instanced_arrays = !_glewInit_GL_NV_instanced_arrays();

17115 #endif /* GL_NV_instanced_arrays */

17116 #ifdef GL_NV_internalformat_sample_query

17117 if (glewExperimental || GLEW_NV_internalformat_sample_query) GLEW_NV_internalformat_sample_query = !_glewInit_GL_NV_internalformat_sample_query();

17118 #endif /* GL_NV_internalformat_sample_query */

17119 #ifdef GL_NV_non_square_matrices

17120 if (glewExperimental || GLEW_NV_non_square_matrices) GLEW_NV_non_square_matrices = !_glewInit_GL_NV_non_square_matrices();

17121 #endif /* GL_NV_non_square_matrices */

17122 #ifdef GL_NV_occlusion_query

17123 if (glewExperimental || GLEW_NV_occlusion_query) GLEW_NV_occlusion_query = !_glewInit_GL_NV_occlusion_query();

17124 #endif /* GL_NV_occlusion_query */

17125 #ifdef GL_NV_parameter_buffer_object

17126 if (glewExperimental || GLEW_NV_parameter_buffer_object) GLEW_NV_parameter_buffer_object = !_glewInit_GL_NV_parameter_buffer_object();

17127 #endif /* GL_NV_parameter_buffer_object */

17128 #ifdef GL_NV_path_rendering

17129 if (glewExperimental || GLEW_NV_path_rendering) GLEW_NV_path_rendering = !_glewInit_GL_NV_path_rendering();

17130 #endif /* GL_NV_path_rendering */

17131 #ifdef GL_NV_pixel_data_range

17132 if (glewExperimental || GLEW_NV_pixel_data_range) GLEW_NV_pixel_data_range = !_glewInit_GL_NV_pixel_data_range();

17133 #endif /* GL_NV_pixel_data_range */

17134 #ifdef GL_NV_point_sprite

17135 if (glewExperimental || GLEW_NV_point_sprite) GLEW_NV_point_sprite = !_glewInit_GL_NV_point_sprite();

17136 #endif /* GL_NV_point_sprite */

17137 #ifdef GL_NV_polygon_mode

17138 if (glewExperimental || GLEW_NV_polygon_mode) GLEW_NV_polygon_mode = !_glewInit_GL_NV_polygon_mode();

17139 #endif /* GL_NV_polygon_mode */

17140 #ifdef GL_NV_present_video

17141 if (glewExperimental || GLEW_NV_present_video) GLEW_NV_present_video = !_glewInit_GL_NV_present_video();

17142 #endif /* GL_NV_present_video */

17143 #ifdef GL_NV_primitive_restart

17144 if (glewExperimental || GLEW_NV_primitive_restart) GLEW_NV_primitive_restart = !_glewInit_GL_NV_primitive_restart();

17145 #endif /* GL_NV_primitive_restart */

17146 #ifdef GL_NV_register_combiners

17147 if (glewExperimental || GLEW_NV_register_combiners) GLEW_NV_register_combiners = !_glewInit_GL_NV_register_combiners();

17148 #endif /* GL_NV_register_combiners */

17149 #ifdef GL_NV_register_combiners2

17150 if (glewExperimental || GLEW_NV_register_combiners2) GLEW_NV_register_combiners2 = !_glewInit_GL_NV_register_combiners2();

17151 #endif /* GL_NV_register_combiners2 */

17152 #ifdef GL_NV_sample_locations

17153 if (glewExperimental || GLEW_NV_sample_locations) GLEW_NV_sample_locations = !_glewInit_GL_NV_sample_locations();

17154 #endif /* GL_NV_sample_locations */

17155 #ifdef GL_NV_shader_buffer_load

17156 if (glewExperimental || GLEW_NV_shader_buffer_load) GLEW_NV_shader_buffer_load = !_glewInit_GL_NV_shader_buffer_load();

17157 #endif /* GL_NV_shader_buffer_load */

17158 #ifdef GL_NV_texture_array

17159 if (glewExperimental || GLEW_NV_texture_array) GLEW_NV_texture_array = !_glewInit_GL_NV_texture_array();

17160 #endif /* GL_NV_texture_array */

17161 #ifdef GL_NV_texture_barrier

17162 if (glewExperimental || GLEW_NV_texture_barrier) GLEW_NV_texture_barrier = !_glewInit_GL_NV_texture_barrier();

17163 #endif /* GL_NV_texture_barrier */

17164 #ifdef GL_NV_texture_multisample

17165 if (glewExperimental || GLEW_NV_texture_multisample) GLEW_NV_texture_multisample = !_glewInit_GL_NV_texture_multisample();

17166 #endif /* GL_NV_texture_multisample */

17167 #ifdef GL_NV_transform_feedback

17168 if (glewExperimental || GLEW_NV_transform_feedback) GLEW_NV_transform_feedback = !_glewInit_GL_NV_transform_feedback();

17169 #endif /* GL_NV_transform_feedback */

17170 #ifdef GL_NV_transform_feedback2

17171 if (glewExperimental || GLEW_NV_transform_feedback2) GLEW_NV_transform_feedback2 = !_glewInit_GL_NV_transform_feedback2();

17172 #endif /* GL_NV_transform_feedback2 */

17173 #ifdef GL_NV_vdpau_interop

17174 if (glewExperimental || GLEW_NV_vdpau_interop) GLEW_NV_vdpau_interop = !_glewInit_GL_NV_vdpau_interop();

17175 #endif /* GL_NV_vdpau_interop */

17176 #ifdef GL_NV_vertex_array_range

17177 if (glewExperimental || GLEW_NV_vertex_array_range) GLEW_NV_vertex_array_range = !_glewInit_GL_NV_vertex_array_range();

17178 #endif /* GL_NV_vertex_array_range */

17179 #ifdef GL_NV_vertex_attrib_integer_64bit

17180 if (glewExperimental || GLEW_NV_vertex_attrib_integer_64bit) GLEW_NV_vertex_attrib_integer_64bit = !_glewInit_GL_NV_vertex_attrib_integer_64bit();

17181 #endif /* GL_NV_vertex_attrib_integer_64bit */

17182 #ifdef GL_NV_vertex_buffer_unified_memory

17183 if (glewExperimental || GLEW_NV_vertex_buffer_unified_memory) GLEW_NV_vertex_buffer_unified_memory = !_glewInit_GL_NV_vertex_buffer_unified_memory();

17184 #endif /* GL_NV_vertex_buffer_unified_memory */

17185 #ifdef GL_NV_vertex_program

17186 if (glewExperimental || GLEW_NV_vertex_program) GLEW_NV_vertex_program = !_glewInit_GL_NV_vertex_program();

17187 #endif /* GL_NV_vertex_program */

17188 #ifdef GL_NV_video_capture

17189 if (glewExperimental || GLEW_NV_video_capture) GLEW_NV_video_capture = !_glewInit_GL_NV_video_capture();

17190 #endif /* GL_NV_video_capture */

17191 #ifdef GL_NV_viewport_array

17192 if (glewExperimental || GLEW_NV_viewport_array) GLEW_NV_viewport_array = !_glewInit_GL_NV_viewport_array();

17193 #endif /* GL_NV_viewport_array */

17194 #ifdef GL_NV_viewport_swizzle

17195 if (glewExperimental || GLEW_NV_viewport_swizzle) GLEW_NV_viewport_swizzle = !_glewInit_GL_NV_viewport_swizzle();

17196 #endif /* GL_NV_viewport_swizzle */

17197 #ifdef GL_OVR_multiview

17198 if (glewExperimental || GLEW_OVR_multiview) GLEW_OVR_multiview = !_glewInit_GL_OVR_multiview();

17199 #endif /* GL_OVR_multiview */

17200 #ifdef GL_OVR_multiview_multisampled_render_to_texture

17201 if (glewExperimental || GLEW_OVR_multiview_multisampled_render_to_texture) GLEW_OVR_multiview_multisampled_render_to_texture = !_glewInit_GL_OVR_multiview_multisampled_render_to_texture();

17202 #endif /* GL_OVR_multiview_multisampled_render_to_texture */

17203 #ifdef GL_QCOM_alpha_test

17204 if (glewExperimental || GLEW_QCOM_alpha_test) GLEW_QCOM_alpha_test = !_glewInit_GL_QCOM_alpha_test();

17205 #endif /* GL_QCOM_alpha_test */

17206 #ifdef GL_QCOM_driver_control

17207 if (glewExperimental || GLEW_QCOM_driver_control) GLEW_QCOM_driver_control = !_glewInit_GL_QCOM_driver_control();

17208 #endif /* GL_QCOM_driver_control */

17209 #ifdef GL_QCOM_extended_get

17210 if (glewExperimental || GLEW_QCOM_extended_get) GLEW_QCOM_extended_get = !_glewInit_GL_QCOM_extended_get();

17211 #endif /* GL_QCOM_extended_get */

17212 #ifdef GL_QCOM_extended_get2

17213 if (glewExperimental || GLEW_QCOM_extended_get2) GLEW_QCOM_extended_get2 = !_glewInit_GL_QCOM_extended_get2();

17214 #endif /* GL_QCOM_extended_get2 */

17215 #ifdef GL_QCOM_framebuffer_foveated

17216 if (glewExperimental || GLEW_QCOM_framebuffer_foveated) GLEW_QCOM_framebuffer_foveated = !_glewInit_GL_QCOM_framebuffer_foveated();

17217 #endif /* GL_QCOM_framebuffer_foveated */

17218 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent

17219 if (glewExperimental || GLEW_QCOM_shader_framebuffer_fetch_noncoherent) GLEW_QCOM_shader_framebuffer_fetch_noncoherent = !_glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent();

17220 #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */

17221 #ifdef GL_QCOM_tiled_rendering

17222 if (glewExperimental || GLEW_QCOM_tiled_rendering) GLEW_QCOM_tiled_rendering = !_glewInit_GL_QCOM_tiled_rendering();

17223 #endif /* GL_QCOM_tiled_rendering */

17224 #ifdef GL_REGAL_ES1_0_compatibility

17225 if (glewExperimental || GLEW_REGAL_ES1_0_compatibility) GLEW_REGAL_ES1_0_compatibility = !_glewInit_GL_REGAL_ES1_0_compatibility();

17226 #endif /* GL_REGAL_ES1_0_compatibility */

17227 #ifdef GL_REGAL_ES1_1_compatibility

17228 if (glewExperimental || GLEW_REGAL_ES1_1_compatibility) GLEW_REGAL_ES1_1_compatibility = !_glewInit_GL_REGAL_ES1_1_compatibility();

17229 #endif /* GL_REGAL_ES1_1_compatibility */

17230 #ifdef GL_REGAL_error_string

17231 if (glewExperimental || GLEW_REGAL_error_string) GLEW_REGAL_error_string = !_glewInit_GL_REGAL_error_string();

17232 #endif /* GL_REGAL_error_string */

17233 #ifdef GL_REGAL_extension_query

17234 if (glewExperimental || GLEW_REGAL_extension_query) GLEW_REGAL_extension_query = !_glewInit_GL_REGAL_extension_query();

17235 #endif /* GL_REGAL_extension_query */

17236 #ifdef GL_REGAL_log

17237 if (glewExperimental || GLEW_REGAL_log) GLEW_REGAL_log = !_glewInit_GL_REGAL_log();

17238 #endif /* GL_REGAL_log */

17239 #ifdef GL_REGAL_proc_address

17240 if (glewExperimental || GLEW_REGAL_proc_address) GLEW_REGAL_proc_address = !_glewInit_GL_REGAL_proc_address();

17241 #endif /* GL_REGAL_proc_address */

17242 #ifdef GL_SGIS_detail_texture

17243 if (glewExperimental || GLEW_SGIS_detail_texture) GLEW_SGIS_detail_texture = !_glewInit_GL_SGIS_detail_texture();

17244 #endif /* GL_SGIS_detail_texture */

17245 #ifdef GL_SGIS_fog_function

17246 if (glewExperimental || GLEW_SGIS_fog_function) GLEW_SGIS_fog_function = !_glewInit_GL_SGIS_fog_function();

17247 #endif /* GL_SGIS_fog_function */

17248 #ifdef GL_SGIS_multisample

17249 if (glewExperimental || GLEW_SGIS_multisample) GLEW_SGIS_multisample = !_glewInit_GL_SGIS_multisample();

17250 #endif /* GL_SGIS_multisample */

17251 #ifdef GL_SGIS_multitexture

17252 if (glewExperimental || GLEW_SGIS_multitexture) GLEW_SGIS_multitexture = !_glewInit_GL_SGIS_multitexture();

17253 #endif /* GL_SGIS_multitexture */

17254 #ifdef GL_SGIS_shared_multisample

17255 if (glewExperimental || GLEW_SGIS_shared_multisample) GLEW_SGIS_shared_multisample = !_glewInit_GL_SGIS_shared_multisample();

17256 #endif /* GL_SGIS_shared_multisample */

17257 #ifdef GL_SGIS_sharpen_texture

17258 if (glewExperimental || GLEW_SGIS_sharpen_texture) GLEW_SGIS_sharpen_texture = !_glewInit_GL_SGIS_sharpen_texture();

17259 #endif /* GL_SGIS_sharpen_texture */

17260 #ifdef GL_SGIS_texture4D

17261 if (glewExperimental || GLEW_SGIS_texture4D) GLEW_SGIS_texture4D = !_glewInit_GL_SGIS_texture4D();

17262 #endif /* GL_SGIS_texture4D */

17263 #ifdef GL_SGIS_texture_filter4

17264 if (glewExperimental || GLEW_SGIS_texture_filter4) GLEW_SGIS_texture_filter4 = !_glewInit_GL_SGIS_texture_filter4();

17265 #endif /* GL_SGIS_texture_filter4 */

17266 #ifdef GL_SGIX_async

17267 if (glewExperimental || GLEW_SGIX_async) GLEW_SGIX_async = !_glewInit_GL_SGIX_async();

17268 #endif /* GL_SGIX_async */

17269 #ifdef GL_SGIX_datapipe

17270 if (glewExperimental || GLEW_SGIX_datapipe) GLEW_SGIX_datapipe = !_glewInit_GL_SGIX_datapipe();

17271 #endif /* GL_SGIX_datapipe */

17272 #ifdef GL_SGIX_flush_raster

17273 if (glewExperimental || GLEW_SGIX_flush_raster) GLEW_SGIX_flush_raster = !_glewInit_GL_SGIX_flush_raster();

17274 #endif /* GL_SGIX_flush_raster */

17275 #ifdef GL_SGIX_fog_layers

17276 if (glewExperimental || GLEW_SGIX_fog_layers) GLEW_SGIX_fog_layers = !_glewInit_GL_SGIX_fog_layers();

17277 #endif /* GL_SGIX_fog_layers */

17278 #ifdef GL_SGIX_fog_texture

17279 if (glewExperimental || GLEW_SGIX_fog_texture) GLEW_SGIX_fog_texture = !_glewInit_GL_SGIX_fog_texture();

17280 #endif /* GL_SGIX_fog_texture */

17281 #ifdef GL_SGIX_fragment_specular_lighting

17282 if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) GLEW_SGIX_fragment_specular_lighting = !_glewInit_GL_SGIX_fragment_specular_lighting();

17283 #endif /* GL_SGIX_fragment_specular_lighting */

17284 #ifdef GL_SGIX_framezoom

17285 if (glewExperimental || GLEW_SGIX_framezoom) GLEW_SGIX_framezoom = !_glewInit_GL_SGIX_framezoom();

17286 #endif /* GL_SGIX_framezoom */

17287 #ifdef GL_SGIX_igloo_interface

17288 if (glewExperimental || GLEW_SGIX_igloo_interface) GLEW_SGIX_igloo_interface = !_glewInit_GL_SGIX_igloo_interface();

17289 #endif /* GL_SGIX_igloo_interface */

17290 #ifdef GL_SGIX_mpeg1

17291 if (glewExperimental || GLEW_SGIX_mpeg1) GLEW_SGIX_mpeg1 = !_glewInit_GL_SGIX_mpeg1();

17292 #endif /* GL_SGIX_mpeg1 */

17293 #ifdef GL_SGIX_nonlinear_lighting_pervertex

17294 if (glewExperimental || GLEW_SGIX_nonlinear_lighting_pervertex) GLEW_SGIX_nonlinear_lighting_pervertex = !_glewInit_GL_SGIX_nonlinear_lighting_pervertex();

17295 #endif /* GL_SGIX_nonlinear_lighting_pervertex */

17296 #ifdef GL_SGIX_pixel_texture

17297 if (glewExperimental || GLEW_SGIX_pixel_texture) GLEW_SGIX_pixel_texture = !_glewInit_GL_SGIX_pixel_texture();

17298 #endif /* GL_SGIX_pixel_texture */

17299 #ifdef GL_SGIX_polynomial_ffd

17300 if (glewExperimental || GLEW_SGIX_polynomial_ffd) GLEW_SGIX_polynomial_ffd = !_glewInit_GL_SGIX_polynomial_ffd();

17301 #endif /* GL_SGIX_polynomial_ffd */

17302 #ifdef GL_SGIX_quad_mesh

17303 if (glewExperimental || GLEW_SGIX_quad_mesh) GLEW_SGIX_quad_mesh = !_glewInit_GL_SGIX_quad_mesh();

17304 #endif /* GL_SGIX_quad_mesh */

17305 #ifdef GL_SGIX_reference_plane

17306 if (glewExperimental || GLEW_SGIX_reference_plane) GLEW_SGIX_reference_plane = !_glewInit_GL_SGIX_reference_plane();

17307 #endif /* GL_SGIX_reference_plane */

17308 #ifdef GL_SGIX_sprite

17309 if (glewExperimental || GLEW_SGIX_sprite) GLEW_SGIX_sprite = !_glewInit_GL_SGIX_sprite();

17310 #endif /* GL_SGIX_sprite */

17311 #ifdef GL_SGIX_tag_sample_buffer

17312 if (glewExperimental || GLEW_SGIX_tag_sample_buffer) GLEW_SGIX_tag_sample_buffer = !_glewInit_GL_SGIX_tag_sample_buffer();

17313 #endif /* GL_SGIX_tag_sample_buffer */

17314 #ifdef GL_SGIX_vector_ops

17315 if (glewExperimental || GLEW_SGIX_vector_ops) GLEW_SGIX_vector_ops = !_glewInit_GL_SGIX_vector_ops();

17316 #endif /* GL_SGIX_vector_ops */

17317 #ifdef GL_SGIX_vertex_array_object

17318 if (glewExperimental || GLEW_SGIX_vertex_array_object) GLEW_SGIX_vertex_array_object = !_glewInit_GL_SGIX_vertex_array_object();

17319 #endif /* GL_SGIX_vertex_array_object */

17320 #ifdef GL_SGI_color_table

17321 if (glewExperimental || GLEW_SGI_color_table) GLEW_SGI_color_table = !_glewInit_GL_SGI_color_table();

17322 #endif /* GL_SGI_color_table */

17323 #ifdef GL_SGI_fft

17324 if (glewExperimental || GLEW_SGI_fft) GLEW_SGI_fft = !_glewInit_GL_SGI_fft();

17325 #endif /* GL_SGI_fft */

17326 #ifdef GL_SUNX_constant_data

17327 if (glewExperimental || GLEW_SUNX_constant_data) GLEW_SUNX_constant_data = !_glewInit_GL_SUNX_constant_data();

17328 #endif /* GL_SUNX_constant_data */

17329 #ifdef GL_SUN_global_alpha

17330 if (glewExperimental || GLEW_SUN_global_alpha) GLEW_SUN_global_alpha = !_glewInit_GL_SUN_global_alpha();

17331 #endif /* GL_SUN_global_alpha */

17332 #ifdef GL_SUN_read_video_pixels

17333 if (glewExperimental || GLEW_SUN_read_video_pixels) GLEW_SUN_read_video_pixels = !_glewInit_GL_SUN_read_video_pixels();

17334 #endif /* GL_SUN_read_video_pixels */

17335 #ifdef GL_SUN_triangle_list

17336 if (glewExperimental || GLEW_SUN_triangle_list) GLEW_SUN_triangle_list = !_glewInit_GL_SUN_triangle_list();

17337 #endif /* GL_SUN_triangle_list */

17338 #ifdef GL_SUN_vertex

17339 if (glewExperimental || GLEW_SUN_vertex) GLEW_SUN_vertex = !_glewInit_GL_SUN_vertex();

17340 #endif /* GL_SUN_vertex */

17341 #ifdef GL_WIN_swap_hint

17342 if (glewExperimental || GLEW_WIN_swap_hint) GLEW_WIN_swap_hint = !_glewInit_GL_WIN_swap_hint();

17343 #endif /* GL_WIN_swap_hint */

17344 #ifdef GL_NV_fragment_program4

17345 GLEW_NV_fragment_program4 = GLEW_NV_gpu_program4;

17346 #endif /* GL_NV_fragment_program4 */

17347 #ifdef GL_NV_geometry_program4

17348 GLEW_NV_geometry_program4 = GLEW_NV_gpu_program4;

17349 #endif /* GL_NV_geometry_program4 */

17350 #ifdef GL_NV_tessellation_program5

17351 GLEW_NV_tessellation_program5 = GLEW_NV_gpu_program5;

17352 #endif /* GL_NV_tessellation_program5 */

17353 #ifdef GL_NV_vertex_program4

17354 GLEW_NV_vertex_program4 = GLEW_NV_gpu_program4;

17355 #endif /* GL_NV_vertex_program4 */

17356

17357 return GLEW_OK;

17358 }

17359

17360

17361 #if defined(GLEW_OSMESA)

17362

17363 #elif defined(GLEW_EGL)

17364

17365 PFNEGLCHOOSECONFIGPROC __eglewChooseConfig = NULL;

17366 PFNEGLCOPYBUFFERSPROC __eglewCopyBuffers = NULL;

17367 PFNEGLCREATECONTEXTPROC __eglewCreateContext = NULL;

17368 PFNEGLCREATEPBUFFERSURFACEPROC __eglewCreatePbufferSurface = NULL;

17369 PFNEGLCREATEPIXMAPSURFACEPROC __eglewCreatePixmapSurface = NULL;

17370 PFNEGLCREATEWINDOWSURFACEPROC __eglewCreateWindowSurface = NULL;

17371 PFNEGLDESTROYCONTEXTPROC __eglewDestroyContext = NULL;

17372 PFNEGLDESTROYSURFACEPROC __eglewDestroySurface = NULL;

17373 PFNEGLGETCONFIGATTRIBPROC __eglewGetConfigAttrib = NULL;

17374 PFNEGLGETCONFIGSPROC __eglewGetConfigs = NULL;

17375 PFNEGLGETCURRENTDISPLAYPROC __eglewGetCurrentDisplay = NULL;

17376 PFNEGLGETCURRENTSURFACEPROC __eglewGetCurrentSurface = NULL;

17377 PFNEGLGETDISPLAYPROC __eglewGetDisplay = NULL;

17378 PFNEGLGETERRORPROC __eglewGetError = NULL;

17379 PFNEGLINITIALIZEPROC __eglewInitialize = NULL;

17380 PFNEGLMAKECURRENTPROC __eglewMakeCurrent = NULL;

17381 PFNEGLQUERYCONTEXTPROC __eglewQueryContext = NULL;

17382 PFNEGLQUERYSTRINGPROC __eglewQueryString = NULL;

17383 PFNEGLQUERYSURFACEPROC __eglewQuerySurface = NULL;

17384 PFNEGLSWAPBUFFERSPROC __eglewSwapBuffers = NULL;

17385 PFNEGLTERMINATEPROC __eglewTerminate = NULL;

17386 PFNEGLWAITGLPROC __eglewWaitGL = NULL;

17387 PFNEGLWAITNATIVEPROC __eglewWaitNative = NULL;

17388

17389 PFNEGLBINDTEXIMAGEPROC __eglewBindTexImage = NULL;

17390 PFNEGLRELEASETEXIMAGEPROC __eglewReleaseTexImage = NULL;

17391 PFNEGLSURFACEATTRIBPROC __eglewSurfaceAttrib = NULL;

17392 PFNEGLSWAPINTERVALPROC __eglewSwapInterval = NULL;

17393

17394 PFNEGLBINDAPIPROC __eglewBindAPI = NULL;

17395 PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC __eglewCreatePbufferFromClientBuffer = NULL;

17396 PFNEGLQUERYAPIPROC __eglewQueryAPI = NULL;

17397 PFNEGLRELEASETHREADPROC __eglewReleaseThread = NULL;

17398 PFNEGLWAITCLIENTPROC __eglewWaitClient = NULL;

17399

17400 PFNEGLGETCURRENTCONTEXTPROC __eglewGetCurrentContext = NULL;

17401

17402 PFNEGLCLIENTWAITSYNCPROC __eglewClientWaitSync = NULL;

17403 PFNEGLCREATEIMAGEPROC __eglewCreateImage = NULL;

17404 PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC __eglewCreatePlatformPixmapSurface = NULL;

17405 PFNEGLCREATEPLATFORMWINDOWSURFACEPROC __eglewCreatePlatformWindowSurface = NULL;

17406 PFNEGLCREATESYNCPROC __eglewCreateSync = NULL;

17407 PFNEGLDESTROYIMAGEPROC __eglewDestroyImage = NULL;

17408 PFNEGLDESTROYSYNCPROC __eglewDestroySync = NULL;

17409 PFNEGLGETPLATFORMDISPLAYPROC __eglewGetPlatformDisplay = NULL;

17410 PFNEGLGETSYNCATTRIBPROC __eglewGetSyncAttrib = NULL;

17411 PFNEGLWAITSYNCPROC __eglewWaitSync = NULL;

17412

17413 PFNEGLSETBLOBCACHEFUNCSANDROIDPROC __eglewSetBlobCacheFuncsANDROID = NULL;

17414

17415 PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC __eglewCreateNativeClientBufferANDROID = NULL;

17416

17417 PFNEGLDUPNATIVEFENCEFDANDROIDPROC __eglewDupNativeFenceFDANDROID = NULL;

17418

17419 PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROID = NULL;

17420

17421 PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE = NULL;

17422

17423 PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT = NULL;

17424

17425 PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT = NULL;

17426 PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT = NULL;

17427 PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT = NULL;

17428

17429 PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT = NULL;

17430 PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT = NULL;

17431

17432 PFNEGLGETOUTPUTLAYERSEXTPROC __eglewGetOutputLayersEXT = NULL;

17433 PFNEGLGETOUTPUTPORTSEXTPROC __eglewGetOutputPortsEXT = NULL;

17434 PFNEGLOUTPUTLAYERATTRIBEXTPROC __eglewOutputLayerAttribEXT = NULL;

17435 PFNEGLOUTPUTPORTATTRIBEXTPROC __eglewOutputPortAttribEXT = NULL;

17436 PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC __eglewQueryOutputLayerAttribEXT = NULL;

17437 PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC __eglewQueryOutputLayerStringEXT = NULL;

17438 PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC __eglewQueryOutputPortAttribEXT = NULL;

17439 PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC __eglewQueryOutputPortStringEXT = NULL;

17440

17441 PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC __eglewCreatePlatformPixmapSurfaceEXT = NULL;

17442 PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC __eglewCreatePlatformWindowSurfaceEXT = NULL;

17443 PFNEGLGETPLATFORMDISPLAYEXTPROC __eglewGetPlatformDisplayEXT = NULL;

17444

17445 PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEXT = NULL;

17446

17447 PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT = NULL;

17448

17449 PFNEGLCREATEPIXMAPSURFACEHIPROC __eglewCreatePixmapSurfaceHI = NULL;

17450

17451 PFNEGLCREATESYNC64KHRPROC __eglewCreateSync64KHR = NULL;

17452

17453 PFNEGLDEBUGMESSAGECONTROLKHRPROC __eglewDebugMessageControlKHR = NULL;

17454 PFNEGLLABELOBJECTKHRPROC __eglewLabelObjectKHR = NULL;

17455 PFNEGLQUERYDEBUGKHRPROC __eglewQueryDebugKHR = NULL;

17456

17457 PFNEGLCREATEIMAGEKHRPROC __eglewCreateImageKHR = NULL;

17458 PFNEGLDESTROYIMAGEKHRPROC __eglewDestroyImageKHR = NULL;

17459

17460 PFNEGLLOCKSURFACEKHRPROC __eglewLockSurfaceKHR = NULL;

17461 PFNEGLUNLOCKSURFACEKHRPROC __eglewUnlockSurfaceKHR = NULL;

17462

17463 PFNEGLQUERYSURFACE64KHRPROC __eglewQuerySurface64KHR = NULL;

17464

17465 PFNEGLSETDAMAGEREGIONKHRPROC __eglewSetDamageRegionKHR = NULL;

17466

17467 PFNEGLCLIENTWAITSYNCKHRPROC __eglewClientWaitSyncKHR = NULL;

17468 PFNEGLCREATESYNCKHRPROC __eglewCreateSyncKHR = NULL;

17469 PFNEGLDESTROYSYNCKHRPROC __eglewDestroySyncKHR = NULL;

17470 PFNEGLGETSYNCATTRIBKHRPROC __eglewGetSyncAttribKHR = NULL;

17471 PFNEGLSIGNALSYNCKHRPROC __eglewSignalSyncKHR = NULL;

17472

17473 PFNEGLCREATESTREAMKHRPROC __eglewCreateStreamKHR = NULL;

17474 PFNEGLDESTROYSTREAMKHRPROC __eglewDestroyStreamKHR = NULL;

17475 PFNEGLQUERYSTREAMKHRPROC __eglewQueryStreamKHR = NULL;

17476 PFNEGLQUERYSTREAMU64KHRPROC __eglewQueryStreamu64KHR = NULL;

17477 PFNEGLSTREAMATTRIBKHRPROC __eglewStreamAttribKHR = NULL;

17478

17479 PFNEGLCREATESTREAMATTRIBKHRPROC __eglewCreateStreamAttribKHR = NULL;

17480 PFNEGLQUERYSTREAMATTRIBKHRPROC __eglewQueryStreamAttribKHR = NULL;

17481 PFNEGLSETSTREAMATTRIBKHRPROC __eglewSetStreamAttribKHR = NULL;

17482 PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC __eglewStreamConsumerAcquireAttribKHR = NULL;

17483 PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC __eglewStreamConsumerReleaseAttribKHR = NULL;

17484

17485 PFNEGLSTREAMCONSUMERACQUIREKHRPROC __eglewStreamConsumerAcquireKHR = NULL;

17486 PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC __eglewStreamConsumerGLTextureExternalKHR = NULL;

17487 PFNEGLSTREAMCONSUMERRELEASEKHRPROC __eglewStreamConsumerReleaseKHR = NULL;

17488

17489 PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC __eglewCreateStreamFromFileDescriptorKHR = NULL;

17490 PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC __eglewGetStreamFileDescriptorKHR = NULL;

17491

17492 PFNEGLQUERYSTREAMTIMEKHRPROC __eglewQueryStreamTimeKHR = NULL;

17493

17494 PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC __eglewCreateStreamProducerSurfaceKHR = NULL;

17495

17496 PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC __eglewSwapBuffersWithDamageKHR = NULL;

17497

17498 PFNEGLWAITSYNCKHRPROC __eglewWaitSyncKHR = NULL;

17499

17500 PFNEGLCREATEDRMIMAGEMESAPROC __eglewCreateDRMImageMESA = NULL;

17501 PFNEGLEXPORTDRMIMAGEMESAPROC __eglewExportDRMImageMESA = NULL;

17502

17503 PFNEGLEXPORTDMABUFIMAGEMESAPROC __eglewExportDMABUFImageMESA = NULL;

17504 PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC __eglewExportDMABUFImageQueryMESA = NULL;

17505

17506 PFNEGLSWAPBUFFERSREGIONNOKPROC __eglewSwapBuffersRegionNOK = NULL;

17507

17508 PFNEGLSWAPBUFFERSREGION2NOKPROC __eglewSwapBuffersRegion2NOK = NULL;

17509

17510 PFNEGLQUERYNATIVEDISPLAYNVPROC __eglewQueryNativeDisplayNV = NULL;

17511 PFNEGLQUERYNATIVEPIXMAPNVPROC __eglewQueryNativePixmapNV = NULL;

17512 PFNEGLQUERYNATIVEWINDOWNVPROC __eglewQueryNativeWindowNV = NULL;

17513

17514 PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV = NULL;

17515

17516 PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV = NULL;

17517

17518 PFNEGLQUERYDISPLAYATTRIBNVPROC __eglewQueryDisplayAttribNV = NULL;

17519 PFNEGLQUERYSTREAMMETADATANVPROC __eglewQueryStreamMetadataNV = NULL;

17520 PFNEGLSETSTREAMMETADATANVPROC __eglewSetStreamMetadataNV = NULL;

17521

17522 PFNEGLRESETSTREAMNVPROC __eglewResetStreamNV = NULL;

17523

17524 PFNEGLCREATESTREAMSYNCNVPROC __eglewCreateStreamSyncNV = NULL;

17525

17526 PFNEGLCLIENTWAITSYNCNVPROC __eglewClientWaitSyncNV = NULL;

17527 PFNEGLCREATEFENCESYNCNVPROC __eglewCreateFenceSyncNV = NULL;

17528 PFNEGLDESTROYSYNCNVPROC __eglewDestroySyncNV = NULL;

17529 PFNEGLFENCENVPROC __eglewFenceNV = NULL;

17530 PFNEGLGETSYNCATTRIBNVPROC __eglewGetSyncAttribNV = NULL;

17531 PFNEGLSIGNALSYNCNVPROC __eglewSignalSyncNV = NULL;

17532

17533 PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC __eglewGetSystemTimeFrequencyNV = NULL;

17534 PFNEGLGETSYSTEMTIMENVPROC __eglewGetSystemTimeNV = NULL;

17535 GLboolean __EGLEW_VERSION_1_0 = GL_FALSE;

17536 GLboolean __EGLEW_VERSION_1_1 = GL_FALSE;

17537 GLboolean __EGLEW_VERSION_1_2 = GL_FALSE;

17538 GLboolean __EGLEW_VERSION_1_3 = GL_FALSE;

17539 GLboolean __EGLEW_VERSION_1_4 = GL_FALSE;

17540 GLboolean __EGLEW_VERSION_1_5 = GL_FALSE;

17541 GLboolean __EGLEW_ANDROID_blob_cache = GL_FALSE;

17542 GLboolean __EGLEW_ANDROID_create_native_client_buffer = GL_FALSE;

17543 GLboolean __EGLEW_ANDROID_framebuffer_target = GL_FALSE;

17544 GLboolean __EGLEW_ANDROID_front_buffer_auto_refresh = GL_FALSE;

17545 GLboolean __EGLEW_ANDROID_image_native_buffer = GL_FALSE;

17546 GLboolean __EGLEW_ANDROID_native_fence_sync = GL_FALSE;

17547 GLboolean __EGLEW_ANDROID_presentation_time = GL_FALSE;

17548 GLboolean __EGLEW_ANDROID_recordable = GL_FALSE;

17549 GLboolean __EGLEW_ANGLE_d3d_share_handle_client_buffer = GL_FALSE;

17550 GLboolean __EGLEW_ANGLE_device_d3d = GL_FALSE;

17551 GLboolean __EGLEW_ANGLE_query_surface_pointer = GL_FALSE;

17552 GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = GL_FALSE;

17553 GLboolean __EGLEW_ANGLE_window_fixed_size = GL_FALSE;

17554 GLboolean __EGLEW_ARM_implicit_external_sync = GL_FALSE;

17555 GLboolean __EGLEW_ARM_pixmap_multisample_discard = GL_FALSE;

17556 GLboolean __EGLEW_EXT_buffer_age = GL_FALSE;

17557 GLboolean __EGLEW_EXT_client_extensions = GL_FALSE;

17558 GLboolean __EGLEW_EXT_create_context_robustness = GL_FALSE;

17559 GLboolean __EGLEW_EXT_device_base = GL_FALSE;

17560 GLboolean __EGLEW_EXT_device_drm = GL_FALSE;

17561 GLboolean __EGLEW_EXT_device_enumeration = GL_FALSE;

17562 GLboolean __EGLEW_EXT_device_openwf = GL_FALSE;

17563 GLboolean __EGLEW_EXT_device_query = GL_FALSE;

17564 GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear = GL_FALSE;

17565 GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq = GL_FALSE;

17566 GLboolean __EGLEW_EXT_gl_colorspace_scrgb_linear = GL_FALSE;

17567 GLboolean __EGLEW_EXT_image_dma_buf_import = GL_FALSE;

17568 GLboolean __EGLEW_EXT_image_dma_buf_import_modifiers = GL_FALSE;

17569 GLboolean __EGLEW_EXT_multiview_window = GL_FALSE;

17570 GLboolean __EGLEW_EXT_output_base = GL_FALSE;

17571 GLboolean __EGLEW_EXT_output_drm = GL_FALSE;

17572 GLboolean __EGLEW_EXT_output_openwf = GL_FALSE;

17573 GLboolean __EGLEW_EXT_pixel_format_float = GL_FALSE;

17574 GLboolean __EGLEW_EXT_platform_base = GL_FALSE;

17575 GLboolean __EGLEW_EXT_platform_device = GL_FALSE;

17576 GLboolean __EGLEW_EXT_platform_wayland = GL_FALSE;

17577 GLboolean __EGLEW_EXT_platform_x11 = GL_FALSE;

17578 GLboolean __EGLEW_EXT_protected_content = GL_FALSE;

17579 GLboolean __EGLEW_EXT_protected_surface = GL_FALSE;

17580 GLboolean __EGLEW_EXT_stream_consumer_egloutput = GL_FALSE;

17581 GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata = GL_FALSE;

17582 GLboolean __EGLEW_EXT_swap_buffers_with_damage = GL_FALSE;

17583 GLboolean __EGLEW_EXT_yuv_surface = GL_FALSE;

17584 GLboolean __EGLEW_HI_clientpixmap = GL_FALSE;

17585 GLboolean __EGLEW_HI_colorformats = GL_FALSE;

17586 GLboolean __EGLEW_IMG_context_priority = GL_FALSE;

17587 GLboolean __EGLEW_IMG_image_plane_attribs = GL_FALSE;

17588 GLboolean __EGLEW_KHR_cl_event = GL_FALSE;

17589 GLboolean __EGLEW_KHR_cl_event2 = GL_FALSE;

17590 GLboolean __EGLEW_KHR_client_get_all_proc_addresses = GL_FALSE;

17591 GLboolean __EGLEW_KHR_config_attribs = GL_FALSE;

17592 GLboolean __EGLEW_KHR_context_flush_control = GL_FALSE;

17593 GLboolean __EGLEW_KHR_create_context = GL_FALSE;

17594 GLboolean __EGLEW_KHR_create_context_no_error = GL_FALSE;

17595 GLboolean __EGLEW_KHR_debug = GL_FALSE;

17596 GLboolean __EGLEW_KHR_fence_sync = GL_FALSE;

17597 GLboolean __EGLEW_KHR_get_all_proc_addresses = GL_FALSE;

17598 GLboolean __EGLEW_KHR_gl_colorspace = GL_FALSE;

17599 GLboolean __EGLEW_KHR_gl_renderbuffer_image = GL_FALSE;

17600 GLboolean __EGLEW_KHR_gl_texture_2D_image = GL_FALSE;

17601 GLboolean __EGLEW_KHR_gl_texture_3D_image = GL_FALSE;

17602 GLboolean __EGLEW_KHR_gl_texture_cubemap_image = GL_FALSE;

17603 GLboolean __EGLEW_KHR_image = GL_FALSE;

17604 GLboolean __EGLEW_KHR_image_base = GL_FALSE;

17605 GLboolean __EGLEW_KHR_image_pixmap = GL_FALSE;

17606 GLboolean __EGLEW_KHR_lock_surface = GL_FALSE;

17607 GLboolean __EGLEW_KHR_lock_surface2 = GL_FALSE;

17608 GLboolean __EGLEW_KHR_lock_surface3 = GL_FALSE;

17609 GLboolean __EGLEW_KHR_mutable_render_buffer = GL_FALSE;

17610 GLboolean __EGLEW_KHR_no_config_context = GL_FALSE;

17611 GLboolean __EGLEW_KHR_partial_update = GL_FALSE;

17612 GLboolean __EGLEW_KHR_platform_android = GL_FALSE;

17613 GLboolean __EGLEW_KHR_platform_gbm = GL_FALSE;

17614 GLboolean __EGLEW_KHR_platform_wayland = GL_FALSE;

17615 GLboolean __EGLEW_KHR_platform_x11 = GL_FALSE;

17616 GLboolean __EGLEW_KHR_reusable_sync = GL_FALSE;

17617 GLboolean __EGLEW_KHR_stream = GL_FALSE;

17618 GLboolean __EGLEW_KHR_stream_attrib = GL_FALSE;

17619 GLboolean __EGLEW_KHR_stream_consumer_gltexture = GL_FALSE;

17620 GLboolean __EGLEW_KHR_stream_cross_process_fd = GL_FALSE;

17621 GLboolean __EGLEW_KHR_stream_fifo = GL_FALSE;

17622 GLboolean __EGLEW_KHR_stream_producer_aldatalocator = GL_FALSE;

17623 GLboolean __EGLEW_KHR_stream_producer_eglsurface = GL_FALSE;

17624 GLboolean __EGLEW_KHR_surfaceless_context = GL_FALSE;

17625 GLboolean __EGLEW_KHR_swap_buffers_with_damage = GL_FALSE;

17626 GLboolean __EGLEW_KHR_vg_parent_image = GL_FALSE;

17627 GLboolean __EGLEW_KHR_wait_sync = GL_FALSE;

17628 GLboolean __EGLEW_MESA_drm_image = GL_FALSE;

17629 GLboolean __EGLEW_MESA_image_dma_buf_export = GL_FALSE;

17630 GLboolean __EGLEW_MESA_platform_gbm = GL_FALSE;

17631 GLboolean __EGLEW_MESA_platform_surfaceless = GL_FALSE;

17632 GLboolean __EGLEW_NOK_swap_region = GL_FALSE;

17633 GLboolean __EGLEW_NOK_swap_region2 = GL_FALSE;

17634 GLboolean __EGLEW_NOK_texture_from_pixmap = GL_FALSE;

17635 GLboolean __EGLEW_NV_3dvision_surface = GL_FALSE;

17636 GLboolean __EGLEW_NV_coverage_sample = GL_FALSE;

17637 GLboolean __EGLEW_NV_coverage_sample_resolve = GL_FALSE;

17638 GLboolean __EGLEW_NV_cuda_event = GL_FALSE;

17639 GLboolean __EGLEW_NV_depth_nonlinear = GL_FALSE;

17640 GLboolean __EGLEW_NV_device_cuda = GL_FALSE;

17641 GLboolean __EGLEW_NV_native_query = GL_FALSE;

17642 GLboolean __EGLEW_NV_post_convert_rounding = GL_FALSE;

17643 GLboolean __EGLEW_NV_post_sub_buffer = GL_FALSE;

17644 GLboolean __EGLEW_NV_robustness_video_memory_purge = GL_FALSE;

17645 GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv = GL_FALSE;

17646 GLboolean __EGLEW_NV_stream_cross_display = GL_FALSE;

17647 GLboolean __EGLEW_NV_stream_cross_object = GL_FALSE;

17648 GLboolean __EGLEW_NV_stream_cross_partition = GL_FALSE;

17649 GLboolean __EGLEW_NV_stream_cross_process = GL_FALSE;

17650 GLboolean __EGLEW_NV_stream_cross_system = GL_FALSE;

17651 GLboolean __EGLEW_NV_stream_fifo_next = GL_FALSE;

17652 GLboolean __EGLEW_NV_stream_fifo_synchronous = GL_FALSE;

17653 GLboolean __EGLEW_NV_stream_frame_limits = GL_FALSE;

17654 GLboolean __EGLEW_NV_stream_metadata = GL_FALSE;

17655 GLboolean __EGLEW_NV_stream_remote = GL_FALSE;

17656 GLboolean __EGLEW_NV_stream_reset = GL_FALSE;

17657 GLboolean __EGLEW_NV_stream_socket = GL_FALSE;

17658 GLboolean __EGLEW_NV_stream_socket_inet = GL_FALSE;

17659 GLboolean __EGLEW_NV_stream_socket_unix = GL_FALSE;

17660 GLboolean __EGLEW_NV_stream_sync = GL_FALSE;

17661 GLboolean __EGLEW_NV_sync = GL_FALSE;

17662 GLboolean __EGLEW_NV_system_time = GL_FALSE;

17663 GLboolean __EGLEW_TIZEN_image_native_buffer = GL_FALSE;

17664 GLboolean __EGLEW_TIZEN_image_native_surface = GL_FALSE;

17665 #ifdef EGL_VERSION_1_0

17666

17667 static GLboolean _glewInit_EGL_VERSION_1_0 ()

17668 {

17669 GLboolean r = GL_FALSE;

17670

17671 r = ((eglChooseConfig = (PFNEGLCHOOSECONFIGPROC)glewGetProcAddress((const GLubyte*)"eglChooseConfig")) == NULL) || r;

17672 r = ((eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC)glewGetProcAddress((const GLubyte*)"eglCopyBuffers")) == NULL) || r;

17673 r = ((eglCreateContext = (PFNEGLCREATECONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglCreateContext")) == NULL) || r;

17674 r = ((eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePbufferSurface")) == NULL) || r;

17675 r = ((eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePixmapSurface")) == NULL) || r;

17676 r = ((eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreateWindowSurface")) == NULL) || r;

17677 r = ((eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglDestroyContext")) == NULL) || r;

17678 r = ((eglDestroySurface = (PFNEGLDESTROYSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglDestroySurface")) == NULL) || r;

17679 r = ((eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"eglGetConfigAttrib")) == NULL) || r;

17680 r = ((eglGetConfigs = (PFNEGLGETCONFIGSPROC)glewGetProcAddress((const GLubyte*)"eglGetConfigs")) == NULL) || r;

17681 r = ((eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"eglGetCurrentDisplay")) == NULL) || r;

17682 r = ((eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglGetCurrentSurface")) == NULL) || r;

17683 r = ((eglGetDisplay = (PFNEGLGETDISPLAYPROC)glewGetProcAddress((const GLubyte*)"eglGetDisplay")) == NULL) || r;

17684 r = ((eglGetError = (PFNEGLGETERRORPROC)glewGetProcAddress((const GLubyte*)"eglGetError")) == NULL) || r;

17685 r = ((eglInitialize = (PFNEGLINITIALIZEPROC)glewGetProcAddress((const GLubyte*)"eglInitialize")) == NULL) || r;

17686 r = ((eglMakeCurrent = (PFNEGLMAKECURRENTPROC)glewGetProcAddress((const GLubyte*)"eglMakeCurrent")) == NULL) || r;

17687 r = ((eglQueryContext = (PFNEGLQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryContext")) == NULL) || r;

17688 r = ((eglQueryString = (PFNEGLQUERYSTRINGPROC)glewGetProcAddress((const GLubyte*)"eglQueryString")) == NULL) || r;

17689 r = ((eglQuerySurface = (PFNEGLQUERYSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglQuerySurface")) == NULL) || r;

17690 r = ((eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC)glewGetProcAddress((const GLubyte*)"eglSwapBuffers")) == NULL) || r;

17691 r = ((eglTerminate = (PFNEGLTERMINATEPROC)glewGetProcAddress((const GLubyte*)"eglTerminate")) == NULL) || r;

17692 r = ((eglWaitGL = (PFNEGLWAITGLPROC)glewGetProcAddress((const GLubyte*)"eglWaitGL")) == NULL) || r;

17693 r = ((eglWaitNative = (PFNEGLWAITNATIVEPROC)glewGetProcAddress((const GLubyte*)"eglWaitNative")) == NULL) || r;

17694

17695 return r;

17696 }

17697

17698 #endif /* EGL_VERSION_1_0 */

17699

17700 #ifdef EGL_VERSION_1_1

17701

17702 static GLboolean _glewInit_EGL_VERSION_1_1 ()

17703 {

17704 GLboolean r = GL_FALSE;

17705

17706 r = ((eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglBindTexImage")) == NULL) || r;

17707 r = ((eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglReleaseTexImage")) == NULL) || r;

17708 r = ((eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC)glewGetProcAddress((const GLubyte*)"eglSurfaceAttrib")) == NULL) || r;

17709 r = ((eglSwapInterval = (PFNEGLSWAPINTERVALPROC)glewGetProcAddress((const GLubyte*)"eglSwapInterval")) == NULL) || r;

17710

17711 return r;

17712 }

17713

17714 #endif /* EGL_VERSION_1_1 */

17715

17716 #ifdef EGL_VERSION_1_2

17717

17718 static GLboolean _glewInit_EGL_VERSION_1_2 ()

17719 {

17720 GLboolean r = GL_FALSE;

17721

17722 r = ((eglBindAPI = (PFNEGLBINDAPIPROC)glewGetProcAddress((const GLubyte*)"eglBindAPI")) == NULL) || r;

17723 r = ((eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)glewGetProcAddress((const GLubyte*)"eglCreatePbufferFromClientBuffer")) == NULL) || r;

17724 r = ((eglQueryAPI = (PFNEGLQUERYAPIPROC)glewGetProcAddress((const GLubyte*)"eglQueryAPI")) == NULL) || r;

17725 r = ((eglReleaseThread = (PFNEGLRELEASETHREADPROC)glewGetProcAddress((const GLubyte*)"eglReleaseThread")) == NULL) || r;

17726 r = ((eglWaitClient = (PFNEGLWAITCLIENTPROC)glewGetProcAddress((const GLubyte*)"eglWaitClient")) == NULL) || r;

17727

17728 return r;

17729 }

17730

17731 #endif /* EGL_VERSION_1_2 */

17732

17733 #ifdef EGL_VERSION_1_4

17734

17735 static GLboolean _glewInit_EGL_VERSION_1_4 ()

17736 {

17737 GLboolean r = GL_FALSE;

17738

17739 r = ((eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC)glewGetProcAddress((const GLubyte*)"eglGetCurrentContext")) == NULL) || r;

17740

17741 return r;

17742 }

17743

17744 #endif /* EGL_VERSION_1_4 */

17745

17746 #ifdef EGL_VERSION_1_5

17747

17748 static GLboolean _glewInit_EGL_VERSION_1_5 ()

17749 {

17750 GLboolean r = GL_FALSE;

17751

17752 r = ((eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"eglClientWaitSync")) == NULL) || r;

17753 r = ((eglCreateImage = (PFNEGLCREATEIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglCreateImage")) == NULL) || r;

17754 r = ((eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePlatformPixmapSurface")) == NULL) || r;

17755 r = ((eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)glewGetProcAddress((const GLubyte*)"eglCreatePlatformWindowSurface")) == NULL) || r;

17756 r = ((eglCreateSync = (PFNEGLCREATESYNCPROC)glewGetProcAddress((const GLubyte*)"eglCreateSync")) == NULL) || r;

17757 r = ((eglDestroyImage = (PFNEGLDESTROYIMAGEPROC)glewGetProcAddress((const GLubyte*)"eglDestroyImage")) == NULL) || r;

17758 r = ((eglDestroySync = (PFNEGLDESTROYSYNCPROC)glewGetProcAddress((const GLubyte*)"eglDestroySync")) == NULL) || r;

17759 r = ((eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC)glewGetProcAddress((const GLubyte*)"eglGetPlatformDisplay")) == NULL) || r;

17760 r = ((eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC)glewGetProcAddress((const GLubyte*)"eglGetSyncAttrib")) == NULL) || r;

17761 r = ((eglWaitSync = (PFNEGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"eglWaitSync")) == NULL) || r;

17762

17763 return r;

17764 }

17765

17766 #endif /* EGL_VERSION_1_5 */

17767

17768 #ifdef EGL_ANDROID_blob_cache

17769

17770 static GLboolean _glewInit_EGL_ANDROID_blob_cache ()

17771 {

17772 GLboolean r = GL_FALSE;

17773

17774 r = ((eglSetBlobCacheFuncsANDROID = (PFNEGLSETBLOBCACHEFUNCSANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglSetBlobCacheFuncsANDROID")) == NULL) || r;

17775

17776 return r;

17777 }

17778

17779 #endif /* EGL_ANDROID_blob_cache */

17780

17781 #ifdef EGL_ANDROID_create_native_client_buffer

17782

17783 static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer ()

17784 {

17785 GLboolean r = GL_FALSE;

17786

17787 r = ((eglCreateNativeClientBufferANDROID = (PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglCreateNativeClientBufferANDROID")) == NULL) || r;

17788

17789 return r;

17790 }

17791

17792 #endif /* EGL_ANDROID_create_native_client_buffer */

17793

17794 #ifdef EGL_ANDROID_native_fence_sync

17795

17796 static GLboolean _glewInit_EGL_ANDROID_native_fence_sync ()

17797 {

17798 GLboolean r = GL_FALSE;

17799

17800 r = ((eglDupNativeFenceFDANDROID = (PFNEGLDUPNATIVEFENCEFDANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglDupNativeFenceFDANDROID")) == NULL) || r;

17801

17802 return r;

17803 }

17804

17805 #endif /* EGL_ANDROID_native_fence_sync */

17806

17807 #ifdef EGL_ANDROID_presentation_time

17808

17809 static GLboolean _glewInit_EGL_ANDROID_presentation_time ()

17810 {

17811 GLboolean r = GL_FALSE;

17812

17813 r = ((eglPresentationTimeANDROID = (PFNEGLPRESENTATIONTIMEANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglPresentationTimeANDROID")) == NULL) || r;

17814

17815 return r;

17816 }

17817

17818 #endif /* EGL_ANDROID_presentation_time */

17819

17820 #ifdef EGL_ANGLE_query_surface_pointer

17821

17822 static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer ()

17823 {

17824 GLboolean r = GL_FALSE;

17825

17826 r = ((eglQuerySurfacePointerANGLE = (PFNEGLQUERYSURFACEPOINTERANGLEPROC)glewGetProcAddress((const GLubyte*)"eglQuerySurfacePointerANGLE")) == NULL) || r;

17827

17828 return r;

17829 }

17830

17831 #endif /* EGL_ANGLE_query_surface_pointer */

17832

17833 #ifdef EGL_EXT_device_enumeration

17834

17835 static GLboolean _glewInit_EGL_EXT_device_enumeration ()

17836 {

17837 GLboolean r = GL_FALSE;

17838

17839 r = ((eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDevicesEXT")) == NULL) || r;

17840

17841 return r;

17842 }

17843

17844 #endif /* EGL_EXT_device_enumeration */

17845

17846 #ifdef EGL_EXT_device_query

17847

17848 static GLboolean _glewInit_EGL_EXT_device_query ()

17849 {

17850 GLboolean r = GL_FALSE;

17851

17852 r = ((eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDeviceAttribEXT")) == NULL) || r;

17853 r = ((eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDeviceStringEXT")) == NULL) || r;

17854 r = ((eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDisplayAttribEXT")) == NULL) || r;

17855

17856 return r;

17857 }

17858

17859 #endif /* EGL_EXT_device_query */

17860

17861 #ifdef EGL_EXT_image_dma_buf_import_modifiers

17862

17863 static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers ()

17864 {

17865 GLboolean r = GL_FALSE;

17866

17867 r = ((eglQueryDmaBufFormatsEXT = (PFNEGLQUERYDMABUFFORMATSEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDmaBufFormatsEXT")) == NULL) || r;

17868 r = ((eglQueryDmaBufModifiersEXT = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDmaBufModifiersEXT")) == NULL) || r;

17869

17870 return r;

17871 }

17872

17873 #endif /* EGL_EXT_image_dma_buf_import_modifiers */

17874

17875 #ifdef EGL_EXT_output_base

17876

17877 static GLboolean _glewInit_EGL_EXT_output_base ()

17878 {

17879 GLboolean r = GL_FALSE;

17880

17881 r = ((eglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXTPROC)glewGetProcAddress((const GLubyte*)"eglGetOutputLayersEXT")) == NULL) || r;

17882 r = ((eglGetOutputPortsEXT = (PFNEGLGETOUTPUTPORTSEXTPROC)glewGetProcAddress((const GLubyte*)"eglGetOutputPortsEXT")) == NULL) || r;

17883 r = ((eglOutputLayerAttribEXT = (PFNEGLOUTPUTLAYERATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"eglOutputLayerAttribEXT")) == NULL) || r;

17884 r = ((eglOutputPortAttribEXT = (PFNEGLOUTPUTPORTATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"eglOutputPortAttribEXT")) == NULL) || r;

17885 r = ((eglQueryOutputLayerAttribEXT = (PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryOutputLayerAttribEXT")) == NULL) || r;

17886 r = ((eglQueryOutputLayerStringEXT = (PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryOutputLayerStringEXT")) == NULL) || r;

17887 r = ((eglQueryOutputPortAttribEXT = (PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryOutputPortAttribEXT")) == NULL) || r;

17888 r = ((eglQueryOutputPortStringEXT = (PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryOutputPortStringEXT")) == NULL) || r;

17889

17890 return r;

17891 }

17892

17893 #endif /* EGL_EXT_output_base */

17894

17895 #ifdef EGL_EXT_platform_base

17896

17897 static GLboolean _glewInit_EGL_EXT_platform_base ()

17898 {

17899 GLboolean r = GL_FALSE;

17900

17901 r = ((eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)glewGetProcAddress((const GLubyte*)"eglCreatePlatformPixmapSurfaceEXT")) == NULL) || r;

17902 r = ((eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)glewGetProcAddress((const GLubyte*)"eglCreatePlatformWindowSurfaceEXT")) == NULL) || r;

17903 r = ((eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)glewGetProcAddress((const GLubyte*)"eglGetPlatformDisplayEXT")) == NULL) || r;

17904

17905 return r;

17906 }

17907

17908 #endif /* EGL_EXT_platform_base */

17909

17910 #ifdef EGL_EXT_stream_consumer_egloutput

17911

17912 static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput ()

17913 {

17914 GLboolean r = GL_FALSE;

17915

17916 r = ((eglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXTPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerOutputEXT")) == NULL) || r;

17917

17918 return r;

17919 }

17920

17921 #endif /* EGL_EXT_stream_consumer_egloutput */

17922

17923 #ifdef EGL_EXT_swap_buffers_with_damage

17924

17925 static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage ()

17926 {

17927 GLboolean r = GL_FALSE;

17928

17929 r = ((eglSwapBuffersWithDamageEXT = (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"eglSwapBuffersWithDamageEXT")) == NULL) || r;

17930

17931 return r;

17932 }

17933

17934 #endif /* EGL_EXT_swap_buffers_with_damage */

17935

17936 #ifdef EGL_HI_clientpixmap

17937

17938 static GLboolean _glewInit_EGL_HI_clientpixmap ()

17939 {

17940 GLboolean r = GL_FALSE;

17941

17942 r = ((eglCreatePixmapSurfaceHI = (PFNEGLCREATEPIXMAPSURFACEHIPROC)glewGetProcAddress((const GLubyte*)"eglCreatePixmapSurfaceHI")) == NULL) || r;

17943

17944 return r;

17945 }

17946

17947 #endif /* EGL_HI_clientpixmap */

17948

17949 #ifdef EGL_KHR_cl_event2

17950

17951 static GLboolean _glewInit_EGL_KHR_cl_event2 ()

17952 {

17953 GLboolean r = GL_FALSE;

17954

17955 r = ((eglCreateSync64KHR = (PFNEGLCREATESYNC64KHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateSync64KHR")) == NULL) || r;

17956

17957 return r;

17958 }

17959

17960 #endif /* EGL_KHR_cl_event2 */

17961

17962 #ifdef EGL_KHR_debug

17963

17964 static GLboolean _glewInit_EGL_KHR_debug ()

17965 {

17966 GLboolean r = GL_FALSE;

17967

17968 r = ((eglDebugMessageControlKHR = (PFNEGLDEBUGMESSAGECONTROLKHRPROC)glewGetProcAddress((const GLubyte*)"eglDebugMessageControlKHR")) == NULL) || r;

17969 r = ((eglLabelObjectKHR = (PFNEGLLABELOBJECTKHRPROC)glewGetProcAddress((const GLubyte*)"eglLabelObjectKHR")) == NULL) || r;

17970 r = ((eglQueryDebugKHR = (PFNEGLQUERYDEBUGKHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryDebugKHR")) == NULL) || r;

17971

17972 return r;

17973 }

17974

17975 #endif /* EGL_KHR_debug */

17976

17977 #ifdef EGL_KHR_image

17978

17979 static GLboolean _glewInit_EGL_KHR_image ()

17980 {

17981 GLboolean r = GL_FALSE;

17982

17983 r = ((eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateImageKHR")) == NULL) || r;

17984 r = ((eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)glewGetProcAddress((const GLubyte*)"eglDestroyImageKHR")) == NULL) || r;

17985

17986 return r;

17987 }

17988

17989 #endif /* EGL_KHR_image */

17990

17991 #ifdef EGL_KHR_lock_surface

17992

17993 static GLboolean _glewInit_EGL_KHR_lock_surface ()

17994 {

17995 GLboolean r = GL_FALSE;

17996

17997 r = ((eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC)glewGetProcAddress((const GLubyte*)"eglLockSurfaceKHR")) == NULL) || r;

17998 r = ((eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC)glewGetProcAddress((const GLubyte*)"eglUnlockSurfaceKHR")) == NULL) || r;

17999

18000 return r;

18001 }

18002

18003 #endif /* EGL_KHR_lock_surface */

18004

18005 #ifdef EGL_KHR_lock_surface3

18006

18007 static GLboolean _glewInit_EGL_KHR_lock_surface3 ()

18008 {

18009 GLboolean r = GL_FALSE;

18010

18011 r = ((eglQuerySurface64KHR = (PFNEGLQUERYSURFACE64KHRPROC)glewGetProcAddress((const GLubyte*)"eglQuerySurface64KHR")) == NULL) || r;

18012

18013 return r;

18014 }

18015

18016 #endif /* EGL_KHR_lock_surface3 */

18017

18018 #ifdef EGL_KHR_partial_update

18019

18020 static GLboolean _glewInit_EGL_KHR_partial_update ()

18021 {

18022 GLboolean r = GL_FALSE;

18023

18024 r = ((eglSetDamageRegionKHR = (PFNEGLSETDAMAGEREGIONKHRPROC)glewGetProcAddress((const GLubyte*)"eglSetDamageRegionKHR")) == NULL) || r;

18025

18026 return r;

18027 }

18028

18029 #endif /* EGL_KHR_partial_update */

18030

18031 #ifdef EGL_KHR_reusable_sync

18032

18033 static GLboolean _glewInit_EGL_KHR_reusable_sync ()

18034 {

18035 GLboolean r = GL_FALSE;

18036

18037 r = ((eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC)glewGetProcAddress((const GLubyte*)"eglClientWaitSyncKHR")) == NULL) || r;

18038 r = ((eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateSyncKHR")) == NULL) || r;

18039 r = ((eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC)glewGetProcAddress((const GLubyte*)"eglDestroySyncKHR")) == NULL) || r;

18040 r = ((eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglGetSyncAttribKHR")) == NULL) || r;

18041 r = ((eglSignalSyncKHR = (PFNEGLSIGNALSYNCKHRPROC)glewGetProcAddress((const GLubyte*)"eglSignalSyncKHR")) == NULL) || r;

18042

18043 return r;

18044 }

18045

18046 #endif /* EGL_KHR_reusable_sync */

18047

18048 #ifdef EGL_KHR_stream

18049

18050 static GLboolean _glewInit_EGL_KHR_stream ()

18051 {

18052 GLboolean r = GL_FALSE;

18053

18054 r = ((eglCreateStreamKHR = (PFNEGLCREATESTREAMKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateStreamKHR")) == NULL) || r;

18055 r = ((eglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHRPROC)glewGetProcAddress((const GLubyte*)"eglDestroyStreamKHR")) == NULL) || r;

18056 r = ((eglQueryStreamKHR = (PFNEGLQUERYSTREAMKHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamKHR")) == NULL) || r;

18057 r = ((eglQueryStreamu64KHR = (PFNEGLQUERYSTREAMU64KHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamu64KHR")) == NULL) || r;

18058 r = ((eglStreamAttribKHR = (PFNEGLSTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamAttribKHR")) == NULL) || r;

18059

18060 return r;

18061 }

18062

18063 #endif /* EGL_KHR_stream */

18064

18065 #ifdef EGL_KHR_stream_attrib

18066

18067 static GLboolean _glewInit_EGL_KHR_stream_attrib ()

18068 {

18069 GLboolean r = GL_FALSE;

18070

18071 r = ((eglCreateStreamAttribKHR = (PFNEGLCREATESTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateStreamAttribKHR")) == NULL) || r;

18072 r = ((eglQueryStreamAttribKHR = (PFNEGLQUERYSTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamAttribKHR")) == NULL) || r;

18073 r = ((eglSetStreamAttribKHR = (PFNEGLSETSTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglSetStreamAttribKHR")) == NULL) || r;

18074 r = ((eglStreamConsumerAcquireAttribKHR = (PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerAcquireAttribKHR")) == NULL) || r;

18075 r = ((eglStreamConsumerReleaseAttribKHR = (PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerReleaseAttribKHR")) == NULL) || r;

18076

18077 return r;

18078 }

18079

18080 #endif /* EGL_KHR_stream_attrib */

18081

18082 #ifdef EGL_KHR_stream_consumer_gltexture

18083

18084 static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture ()

18085 {

18086 GLboolean r = GL_FALSE;

18087

18088 r = ((eglStreamConsumerAcquireKHR = (PFNEGLSTREAMCONSUMERACQUIREKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerAcquireKHR")) == NULL) || r;

18089 r = ((eglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerGLTextureExternalKHR")) == NULL) || r;

18090 r = ((eglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerReleaseKHR")) == NULL) || r;

18091

18092 return r;

18093 }

18094

18095 #endif /* EGL_KHR_stream_consumer_gltexture */

18096

18097 #ifdef EGL_KHR_stream_cross_process_fd

18098

18099 static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd ()

18100 {

18101 GLboolean r = GL_FALSE;

18102

18103 r = ((eglCreateStreamFromFileDescriptorKHR = (PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateStreamFromFileDescriptorKHR")) == NULL) || r;

18104 r = ((eglGetStreamFileDescriptorKHR = (PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC)glewGetProcAddress((const GLubyte*)"eglGetStreamFileDescriptorKHR")) == NULL) || r;

18105

18106 return r;

18107 }

18108

18109 #endif /* EGL_KHR_stream_cross_process_fd */

18110

18111 #ifdef EGL_KHR_stream_fifo

18112

18113 static GLboolean _glewInit_EGL_KHR_stream_fifo ()

18114 {

18115 GLboolean r = GL_FALSE;

18116

18117 r = ((eglQueryStreamTimeKHR = (PFNEGLQUERYSTREAMTIMEKHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamTimeKHR")) == NULL) || r;

18118

18119 return r;

18120 }

18121

18122 #endif /* EGL_KHR_stream_fifo */

18123

18124 #ifdef EGL_KHR_stream_producer_eglsurface

18125

18126 static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface ()

18127 {

18128 GLboolean r = GL_FALSE;

18129

18130 r = ((eglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateStreamProducerSurfaceKHR")) == NULL) || r;

18131

18132 return r;

18133 }

18134

18135 #endif /* EGL_KHR_stream_producer_eglsurface */

18136

18137 #ifdef EGL_KHR_swap_buffers_with_damage

18138

18139 static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage ()

18140 {

18141 GLboolean r = GL_FALSE;

18142

18143 r = ((eglSwapBuffersWithDamageKHR = (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)glewGetProcAddress((const GLubyte*)"eglSwapBuffersWithDamageKHR")) == NULL) || r;

18144

18145 return r;

18146 }

18147

18148 #endif /* EGL_KHR_swap_buffers_with_damage */

18149

18150 #ifdef EGL_KHR_wait_sync

18151

18152 static GLboolean _glewInit_EGL_KHR_wait_sync ()

18153 {

18154 GLboolean r = GL_FALSE;

18155

18156 r = ((eglWaitSyncKHR = (PFNEGLWAITSYNCKHRPROC)glewGetProcAddress((const GLubyte*)"eglWaitSyncKHR")) == NULL) || r;

18157

18158 return r;

18159 }

18160

18161 #endif /* EGL_KHR_wait_sync */

18162

18163 #ifdef EGL_MESA_drm_image

18164

18165 static GLboolean _glewInit_EGL_MESA_drm_image ()

18166 {

18167 GLboolean r = GL_FALSE;

18168

18169 r = ((eglCreateDRMImageMESA = (PFNEGLCREATEDRMIMAGEMESAPROC)glewGetProcAddress((const GLubyte*)"eglCreateDRMImageMESA")) == NULL) || r;

18170 r = ((eglExportDRMImageMESA = (PFNEGLEXPORTDRMIMAGEMESAPROC)glewGetProcAddress((const GLubyte*)"eglExportDRMImageMESA")) == NULL) || r;

18171

18172 return r;

18173 }

18174

18175 #endif /* EGL_MESA_drm_image */

18176

18177 #ifdef EGL_MESA_image_dma_buf_export

18178

18179 static GLboolean _glewInit_EGL_MESA_image_dma_buf_export ()

18180 {

18181 GLboolean r = GL_FALSE;

18182

18183 r = ((eglExportDMABUFImageMESA = (PFNEGLEXPORTDMABUFIMAGEMESAPROC)glewGetProcAddress((const GLubyte*)"eglExportDMABUFImageMESA")) == NULL) || r;

18184 r = ((eglExportDMABUFImageQueryMESA = (PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC)glewGetProcAddress((const GLubyte*)"eglExportDMABUFImageQueryMESA")) == NULL) || r;

18185

18186 return r;

18187 }

18188

18189 #endif /* EGL_MESA_image_dma_buf_export */

18190

18191 #ifdef EGL_NOK_swap_region

18192

18193 static GLboolean _glewInit_EGL_NOK_swap_region ()

18194 {

18195 GLboolean r = GL_FALSE;

18196

18197 r = ((eglSwapBuffersRegionNOK = (PFNEGLSWAPBUFFERSREGIONNOKPROC)glewGetProcAddress((const GLubyte*)"eglSwapBuffersRegionNOK")) == NULL) || r;

18198

18199 return r;

18200 }

18201

18202 #endif /* EGL_NOK_swap_region */

18203

18204 #ifdef EGL_NOK_swap_region2

18205

18206 static GLboolean _glewInit_EGL_NOK_swap_region2 ()

18207 {

18208 GLboolean r = GL_FALSE;

18209

18210 r = ((eglSwapBuffersRegion2NOK = (PFNEGLSWAPBUFFERSREGION2NOKPROC)glewGetProcAddress((const GLubyte*)"eglSwapBuffersRegion2NOK")) == NULL) || r;

18211

18212 return r;

18213 }

18214

18215 #endif /* EGL_NOK_swap_region2 */

18216

18217 #ifdef EGL_NV_native_query

18218

18219 static GLboolean _glewInit_EGL_NV_native_query ()

18220 {

18221 GLboolean r = GL_FALSE;

18222

18223 r = ((eglQueryNativeDisplayNV = (PFNEGLQUERYNATIVEDISPLAYNVPROC)glewGetProcAddress((const GLubyte*)"eglQueryNativeDisplayNV")) == NULL) || r;

18224 r = ((eglQueryNativePixmapNV = (PFNEGLQUERYNATIVEPIXMAPNVPROC)glewGetProcAddress((const GLubyte*)"eglQueryNativePixmapNV")) == NULL) || r;

18225 r = ((eglQueryNativeWindowNV = (PFNEGLQUERYNATIVEWINDOWNVPROC)glewGetProcAddress((const GLubyte*)"eglQueryNativeWindowNV")) == NULL) || r;

18226

18227 return r;

18228 }

18229

18230 #endif /* EGL_NV_native_query */

18231

18232 #ifdef EGL_NV_post_sub_buffer

18233

18234 static GLboolean _glewInit_EGL_NV_post_sub_buffer ()

18235 {

18236 GLboolean r = GL_FALSE;

18237

18238 r = ((eglPostSubBufferNV = (PFNEGLPOSTSUBBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"eglPostSubBufferNV")) == NULL) || r;

18239

18240 return r;

18241 }

18242

18243 #endif /* EGL_NV_post_sub_buffer */

18244

18245 #ifdef EGL_NV_stream_consumer_gltexture_yuv

18246

18247 static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv ()

18248 {

18249 GLboolean r = GL_FALSE;

18250

18251 r = ((eglStreamConsumerGLTextureExternalAttribsNV = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerGLTextureExternalAttribsNV")) == NULL) || r;

18252

18253 return r;

18254 }

18255

18256 #endif /* EGL_NV_stream_consumer_gltexture_yuv */

18257

18258 #ifdef EGL_NV_stream_metadata

18259

18260 static GLboolean _glewInit_EGL_NV_stream_metadata ()

18261 {

18262 GLboolean r = GL_FALSE;

18263

18264 r = ((eglQueryDisplayAttribNV = (PFNEGLQUERYDISPLAYATTRIBNVPROC)glewGetProcAddress((const GLubyte*)"eglQueryDisplayAttribNV")) == NULL) || r;

18265 r = ((eglQueryStreamMetadataNV = (PFNEGLQUERYSTREAMMETADATANVPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamMetadataNV")) == NULL) || r;

18266 r = ((eglSetStreamMetadataNV = (PFNEGLSETSTREAMMETADATANVPROC)glewGetProcAddress((const GLubyte*)"eglSetStreamMetadataNV")) == NULL) || r;

18267

18268 return r;

18269 }

18270

18271 #endif /* EGL_NV_stream_metadata */

18272

18273 #ifdef EGL_NV_stream_reset

18274

18275 static GLboolean _glewInit_EGL_NV_stream_reset ()

18276 {

18277 GLboolean r = GL_FALSE;

18278

18279 r = ((eglResetStreamNV = (PFNEGLRESETSTREAMNVPROC)glewGetProcAddress((const GLubyte*)"eglResetStreamNV")) == NULL) || r;

18280

18281 return r;

18282 }

18283

18284 #endif /* EGL_NV_stream_reset */

18285

18286 #ifdef EGL_NV_stream_sync

18287

18288 static GLboolean _glewInit_EGL_NV_stream_sync ()

18289 {

18290 GLboolean r = GL_FALSE;

18291

18292 r = ((eglCreateStreamSyncNV = (PFNEGLCREATESTREAMSYNCNVPROC)glewGetProcAddress((const GLubyte*)"eglCreateStreamSyncNV")) == NULL) || r;

18293

18294 return r;

18295 }

18296

18297 #endif /* EGL_NV_stream_sync */

18298

18299 #ifdef EGL_NV_sync

18300

18301 static GLboolean _glewInit_EGL_NV_sync ()

18302 {

18303 GLboolean r = GL_FALSE;

18304

18305 r = ((eglClientWaitSyncNV = (PFNEGLCLIENTWAITSYNCNVPROC)glewGetProcAddress((const GLubyte*)"eglClientWaitSyncNV")) == NULL) || r;

18306 r = ((eglCreateFenceSyncNV = (PFNEGLCREATEFENCESYNCNVPROC)glewGetProcAddress((const GLubyte*)"eglCreateFenceSyncNV")) == NULL) || r;

18307 r = ((eglDestroySyncNV = (PFNEGLDESTROYSYNCNVPROC)glewGetProcAddress((const GLubyte*)"eglDestroySyncNV")) == NULL) || r;

18308 r = ((eglFenceNV = (PFNEGLFENCENVPROC)glewGetProcAddress((const GLubyte*)"eglFenceNV")) == NULL) || r;

18309 r = ((eglGetSyncAttribNV = (PFNEGLGETSYNCATTRIBNVPROC)glewGetProcAddress((const GLubyte*)"eglGetSyncAttribNV")) == NULL) || r;

18310 r = ((eglSignalSyncNV = (PFNEGLSIGNALSYNCNVPROC)glewGetProcAddress((const GLubyte*)"eglSignalSyncNV")) == NULL) || r;

18311

18312 return r;

18313 }

18314

18315 #endif /* EGL_NV_sync */

18316

18317 #ifdef EGL_NV_system_time

18318

18319 static GLboolean _glewInit_EGL_NV_system_time ()

18320 {

18321 GLboolean r = GL_FALSE;

18322

18323 r = ((eglGetSystemTimeFrequencyNV = (PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC)glewGetProcAddress((const GLubyte*)"eglGetSystemTimeFrequencyNV")) == NULL) || r;

18324 r = ((eglGetSystemTimeNV = (PFNEGLGETSYSTEMTIMENVPROC)glewGetProcAddress((const GLubyte*)"eglGetSystemTimeNV")) == NULL) || r;

18325

18326 return r;

18327 }

18328

18329 #endif /* EGL_NV_system_time */

18330

18331 /* ------------------------------------------------------------------------ */

18332

18333 GLboolean eglewGetExtension (const char* name)

18334 {

18335 const GLubyte* start;

18336 const GLubyte* end;

18337

18338 start = (const GLubyte*) eglQueryString(eglGetCurrentDisplay(), EGL_EXTENSIONS);

18339 if (0 == start) return GL_FALSE;

18340 end = start + _glewStrLen(start);

18341 return _glewSearchExtension(name, start, end);

18342 }

18343

18344 GLenum eglewInit (EGLDisplay display)

18345 {

18346 EGLint major, minor;

18347 const GLubyte* extStart;

18348 const GLubyte* extEnd;

18349 PFNEGLINITIALIZEPROC initialize = NULL;

18350 PFNEGLQUERYSTRINGPROC queryString = NULL;

18351

18352 /* Load necessary entry points */

18353 initialize = (PFNEGLINITIALIZEPROC) glewGetProcAddress("eglInitialize");

18354 queryString = (PFNEGLQUERYSTRINGPROC) glewGetProcAddress("eglQueryString");

18355 if (!initialize || !queryString)

18356 return 1;

18357

18358 /* query EGK version */

18359 if (initialize(display, &major, &minor) != EGL_TRUE)

18360 return 1;

18361

18362 EGLEW_VERSION_1_5 = ( major > 1 ) || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE;

18363 EGLEW_VERSION_1_4 = EGLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE;

18364 EGLEW_VERSION_1_3 = EGLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE;

18365 EGLEW_VERSION_1_2 = EGLEW_VERSION_1_3 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE;

18366 EGLEW_VERSION_1_1 = EGLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE;

18367 EGLEW_VERSION_1_0 = EGLEW_VERSION_1_1 == GL_TRUE || ( major == 1 && minor >= 0 ) ? GL_TRUE : GL_FALSE;

18368

18369 /* query EGL extension string */

18370 extStart = (const GLubyte*) queryString(display, EGL_EXTENSIONS);

18371 if (extStart == 0)

18372 extStart = (const GLubyte *)"";

18373 extEnd = extStart + _glewStrLen(extStart);

18374

18375 /* initialize extensions */

18376 #ifdef EGL_VERSION_1_0

18377 if (glewExperimental || EGLEW_VERSION_1_0) EGLEW_VERSION_1_0 = !_glewInit_EGL_VERSION_1_0();

18378 #endif /* EGL_VERSION_1_0 */

18379 #ifdef EGL_VERSION_1_1

18380 if (glewExperimental || EGLEW_VERSION_1_1) EGLEW_VERSION_1_1 = !_glewInit_EGL_VERSION_1_1();

18381 #endif /* EGL_VERSION_1_1 */

18382 #ifdef EGL_VERSION_1_2

18383 if (glewExperimental || EGLEW_VERSION_1_2) EGLEW_VERSION_1_2 = !_glewInit_EGL_VERSION_1_2();

18384 #endif /* EGL_VERSION_1_2 */

18385 #ifdef EGL_VERSION_1_4

18386 if (glewExperimental || EGLEW_VERSION_1_4) EGLEW_VERSION_1_4 = !_glewInit_EGL_VERSION_1_4();

18387 #endif /* EGL_VERSION_1_4 */

18388 #ifdef EGL_VERSION_1_5

18389 if (glewExperimental || EGLEW_VERSION_1_5) EGLEW_VERSION_1_5 = !_glewInit_EGL_VERSION_1_5();

18390 #endif /* EGL_VERSION_1_5 */

18391 #ifdef EGL_ANDROID_blob_cache

18392 EGLEW_ANDROID_blob_cache = _glewSearchExtension("EGL_ANDROID_blob_cache", extStart, extEnd);

18393 if (glewExperimental || EGLEW_ANDROID_blob_cache) EGLEW_ANDROID_blob_cache = !_glewInit_EGL_ANDROID_blob_cache();

18394 #endif /* EGL_ANDROID_blob_cache */

18395 #ifdef EGL_ANDROID_create_native_client_buffer

18396 EGLEW_ANDROID_create_native_client_buffer = _glewSearchExtension("EGL_ANDROID_create_native_client_buffer", extStart, extEnd);

18397 if (glewExperimental || EGLEW_ANDROID_create_native_client_buffer) EGLEW_ANDROID_create_native_client_buffer = !_glewInit_EGL_ANDROID_create_native_client_buffer();

18398 #endif /* EGL_ANDROID_create_native_client_buffer */

18399 #ifdef EGL_ANDROID_framebuffer_target

18400 EGLEW_ANDROID_framebuffer_target = _glewSearchExtension("EGL_ANDROID_framebuffer_target", extStart, extEnd);

18401 #endif /* EGL_ANDROID_framebuffer_target */

18402 #ifdef EGL_ANDROID_front_buffer_auto_refresh

18403 EGLEW_ANDROID_front_buffer_auto_refresh = _glewSearchExtension("EGL_ANDROID_front_buffer_auto_refresh", extStart, extEnd);

18404 #endif /* EGL_ANDROID_front_buffer_auto_refresh */

18405 #ifdef EGL_ANDROID_image_native_buffer

18406 EGLEW_ANDROID_image_native_buffer = _glewSearchExtension("EGL_ANDROID_image_native_buffer", extStart, extEnd);

18407 #endif /* EGL_ANDROID_image_native_buffer */

18408 #ifdef EGL_ANDROID_native_fence_sync

18409 EGLEW_ANDROID_native_fence_sync = _glewSearchExtension("EGL_ANDROID_native_fence_sync", extStart, extEnd);

18410 if (glewExperimental || EGLEW_ANDROID_native_fence_sync) EGLEW_ANDROID_native_fence_sync = !_glewInit_EGL_ANDROID_native_fence_sync();

18411 #endif /* EGL_ANDROID_native_fence_sync */

18412 #ifdef EGL_ANDROID_presentation_time

18413 EGLEW_ANDROID_presentation_time = _glewSearchExtension("EGL_ANDROID_presentation_time", extStart, extEnd);

18414 if (glewExperimental || EGLEW_ANDROID_presentation_time) EGLEW_ANDROID_presentation_time = !_glewInit_EGL_ANDROID_presentation_time();

18415 #endif /* EGL_ANDROID_presentation_time */

18416 #ifdef EGL_ANDROID_recordable

18417 EGLEW_ANDROID_recordable = _glewSearchExtension("EGL_ANDROID_recordable", extStart, extEnd);

18418 #endif /* EGL_ANDROID_recordable */

18419 #ifdef EGL_ANGLE_d3d_share_handle_client_buffer

18420 EGLEW_ANGLE_d3d_share_handle_client_buffer = _glewSearchExtension("EGL_ANGLE_d3d_share_handle_client_buffer", extStart, extEnd);

18421 #endif /* EGL_ANGLE_d3d_share_handle_client_buffer */

18422 #ifdef EGL_ANGLE_device_d3d

18423 EGLEW_ANGLE_device_d3d = _glewSearchExtension("EGL_ANGLE_device_d3d", extStart, extEnd);

18424 #endif /* EGL_ANGLE_device_d3d */

18425 #ifdef EGL_ANGLE_query_surface_pointer

18426 EGLEW_ANGLE_query_surface_pointer = _glewSearchExtension("EGL_ANGLE_query_surface_pointer", extStart, extEnd);

18427 if (glewExperimental || EGLEW_ANGLE_query_surface_pointer) EGLEW_ANGLE_query_surface_pointer = !_glewInit_EGL_ANGLE_query_surface_pointer();

18428 #endif /* EGL_ANGLE_query_surface_pointer */

18429 #ifdef EGL_ANGLE_surface_d3d_texture_2d_share_handle

18430 EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = _glewSearchExtension("EGL_ANGLE_surface_d3d_texture_2d_share_handle", extStart, extEnd);

18431 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */

18432 #ifdef EGL_ANGLE_window_fixed_size

18433 EGLEW_ANGLE_window_fixed_size = _glewSearchExtension("EGL_ANGLE_window_fixed_size", extStart, extEnd);

18434 #endif /* EGL_ANGLE_window_fixed_size */

18435 #ifdef EGL_ARM_implicit_external_sync

18436 EGLEW_ARM_implicit_external_sync = _glewSearchExtension("EGL_ARM_implicit_external_sync", extStart, extEnd);

18437 #endif /* EGL_ARM_implicit_external_sync */

18438 #ifdef EGL_ARM_pixmap_multisample_discard

18439 EGLEW_ARM_pixmap_multisample_discard = _glewSearchExtension("EGL_ARM_pixmap_multisample_discard", extStart, extEnd);

18440 #endif /* EGL_ARM_pixmap_multisample_discard */

18441 #ifdef EGL_EXT_buffer_age

18442 EGLEW_EXT_buffer_age = _glewSearchExtension("EGL_EXT_buffer_age", extStart, extEnd);

18443 #endif /* EGL_EXT_buffer_age */

18444 #ifdef EGL_EXT_client_extensions

18445 EGLEW_EXT_client_extensions = _glewSearchExtension("EGL_EXT_client_extensions", extStart, extEnd);

18446 #endif /* EGL_EXT_client_extensions */

18447 #ifdef EGL_EXT_create_context_robustness

18448 EGLEW_EXT_create_context_robustness = _glewSearchExtension("EGL_EXT_create_context_robustness", extStart, extEnd);

18449 #endif /* EGL_EXT_create_context_robustness */

18450 #ifdef EGL_EXT_device_base

18451 EGLEW_EXT_device_base = _glewSearchExtension("EGL_EXT_device_base", extStart, extEnd);

18452 #endif /* EGL_EXT_device_base */

18453 #ifdef EGL_EXT_device_drm

18454 EGLEW_EXT_device_drm = _glewSearchExtension("EGL_EXT_device_drm", extStart, extEnd);

18455 #endif /* EGL_EXT_device_drm */

18456 #ifdef EGL_EXT_device_enumeration

18457 EGLEW_EXT_device_enumeration = _glewSearchExtension("EGL_EXT_device_enumeration", extStart, extEnd);

18458 if (glewExperimental || EGLEW_EXT_device_enumeration) EGLEW_EXT_device_enumeration = !_glewInit_EGL_EXT_device_enumeration();

18459 #endif /* EGL_EXT_device_enumeration */

18460 #ifdef EGL_EXT_device_openwf

18461 EGLEW_EXT_device_openwf = _glewSearchExtension("EGL_EXT_device_openwf", extStart, extEnd);

18462 #endif /* EGL_EXT_device_openwf */

18463 #ifdef EGL_EXT_device_query

18464 EGLEW_EXT_device_query = _glewSearchExtension("EGL_EXT_device_query", extStart, extEnd);

18465 if (glewExperimental || EGLEW_EXT_device_query) EGLEW_EXT_device_query = !_glewInit_EGL_EXT_device_query();

18466 #endif /* EGL_EXT_device_query */

18467 #ifdef EGL_EXT_gl_colorspace_bt2020_linear

18468 EGLEW_EXT_gl_colorspace_bt2020_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_linear", extStart, extEnd);

18469 #endif /* EGL_EXT_gl_colorspace_bt2020_linear */

18470 #ifdef EGL_EXT_gl_colorspace_bt2020_pq

18471 EGLEW_EXT_gl_colorspace_bt2020_pq = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_pq", extStart, extEnd);

18472 #endif /* EGL_EXT_gl_colorspace_bt2020_pq */

18473 #ifdef EGL_EXT_gl_colorspace_scrgb_linear

18474 EGLEW_EXT_gl_colorspace_scrgb_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_scrgb_linear", extStart, extEnd);

18475 #endif /* EGL_EXT_gl_colorspace_scrgb_linear */

18476 #ifdef EGL_EXT_image_dma_buf_import

18477 EGLEW_EXT_image_dma_buf_import = _glewSearchExtension("EGL_EXT_image_dma_buf_import", extStart, extEnd);

18478 #endif /* EGL_EXT_image_dma_buf_import */

18479 #ifdef EGL_EXT_image_dma_buf_import_modifiers

18480 EGLEW_EXT_image_dma_buf_import_modifiers = _glewSearchExtension("EGL_EXT_image_dma_buf_import_modifiers", extStart, extEnd);

18481 if (glewExperimental || EGLEW_EXT_image_dma_buf_import_modifiers) EGLEW_EXT_image_dma_buf_import_modifiers = !_glewInit_EGL_EXT_image_dma_buf_import_modifiers();

18482 #endif /* EGL_EXT_image_dma_buf_import_modifiers */

18483 #ifdef EGL_EXT_multiview_window

18484 EGLEW_EXT_multiview_window = _glewSearchExtension("EGL_EXT_multiview_window", extStart, extEnd);

18485 #endif /* EGL_EXT_multiview_window */

18486 #ifdef EGL_EXT_output_base

18487 EGLEW_EXT_output_base = _glewSearchExtension("EGL_EXT_output_base", extStart, extEnd);

18488 if (glewExperimental || EGLEW_EXT_output_base) EGLEW_EXT_output_base = !_glewInit_EGL_EXT_output_base();

18489 #endif /* EGL_EXT_output_base */

18490 #ifdef EGL_EXT_output_drm

18491 EGLEW_EXT_output_drm = _glewSearchExtension("EGL_EXT_output_drm", extStart, extEnd);

18492 #endif /* EGL_EXT_output_drm */

18493 #ifdef EGL_EXT_output_openwf

18494 EGLEW_EXT_output_openwf = _glewSearchExtension("EGL_EXT_output_openwf", extStart, extEnd);

18495 #endif /* EGL_EXT_output_openwf */

18496 #ifdef EGL_EXT_pixel_format_float

18497 EGLEW_EXT_pixel_format_float = _glewSearchExtension("EGL_EXT_pixel_format_float", extStart, extEnd);

18498 #endif /* EGL_EXT_pixel_format_float */

18499 #ifdef EGL_EXT_platform_base

18500 EGLEW_EXT_platform_base = _glewSearchExtension("EGL_EXT_platform_base", extStart, extEnd);

18501 if (glewExperimental || EGLEW_EXT_platform_base) EGLEW_EXT_platform_base = !_glewInit_EGL_EXT_platform_base();

18502 #endif /* EGL_EXT_platform_base */

18503 #ifdef EGL_EXT_platform_device

18504 EGLEW_EXT_platform_device = _glewSearchExtension("EGL_EXT_platform_device", extStart, extEnd);

18505 #endif /* EGL_EXT_platform_device */

18506 #ifdef EGL_EXT_platform_wayland

18507 EGLEW_EXT_platform_wayland = _glewSearchExtension("EGL_EXT_platform_wayland", extStart, extEnd);

18508 #endif /* EGL_EXT_platform_wayland */

18509 #ifdef EGL_EXT_platform_x11

18510 EGLEW_EXT_platform_x11 = _glewSearchExtension("EGL_EXT_platform_x11", extStart, extEnd);

18511 #endif /* EGL_EXT_platform_x11 */

18512 #ifdef EGL_EXT_protected_content

18513 EGLEW_EXT_protected_content = _glewSearchExtension("EGL_EXT_protected_content", extStart, extEnd);

18514 #endif /* EGL_EXT_protected_content */

18515 #ifdef EGL_EXT_protected_surface

18516 EGLEW_EXT_protected_surface = _glewSearchExtension("EGL_EXT_protected_surface", extStart, extEnd);

18517 #endif /* EGL_EXT_protected_surface */

18518 #ifdef EGL_EXT_stream_consumer_egloutput

18519 EGLEW_EXT_stream_consumer_egloutput = _glewSearchExtension("EGL_EXT_stream_consumer_egloutput", extStart, extEnd);

18520 if (glewExperimental || EGLEW_EXT_stream_consumer_egloutput) EGLEW_EXT_stream_consumer_egloutput = !_glewInit_EGL_EXT_stream_consumer_egloutput();

18521 #endif /* EGL_EXT_stream_consumer_egloutput */

18522 #ifdef EGL_EXT_surface_SMPTE2086_metadata

18523 EGLEW_EXT_surface_SMPTE2086_metadata = _glewSearchExtension("EGL_EXT_surface_SMPTE2086_metadata", extStart, extEnd);

18524 #endif /* EGL_EXT_surface_SMPTE2086_metadata */

18525 #ifdef EGL_EXT_swap_buffers_with_damage

18526 EGLEW_EXT_swap_buffers_with_damage = _glewSearchExtension("EGL_EXT_swap_buffers_with_damage", extStart, extEnd);

18527 if (glewExperimental || EGLEW_EXT_swap_buffers_with_damage) EGLEW_EXT_swap_buffers_with_damage = !_glewInit_EGL_EXT_swap_buffers_with_damage();

18528 #endif /* EGL_EXT_swap_buffers_with_damage */

18529 #ifdef EGL_EXT_yuv_surface

18530 EGLEW_EXT_yuv_surface = _glewSearchExtension("EGL_EXT_yuv_surface", extStart, extEnd);

18531 #endif /* EGL_EXT_yuv_surface */

18532 #ifdef EGL_HI_clientpixmap

18533 EGLEW_HI_clientpixmap = _glewSearchExtension("EGL_HI_clientpixmap", extStart, extEnd);

18534 if (glewExperimental || EGLEW_HI_clientpixmap) EGLEW_HI_clientpixmap = !_glewInit_EGL_HI_clientpixmap();

18535 #endif /* EGL_HI_clientpixmap */

18536 #ifdef EGL_HI_colorformats

18537 EGLEW_HI_colorformats = _glewSearchExtension("EGL_HI_colorformats", extStart, extEnd);

18538 #endif /* EGL_HI_colorformats */

18539 #ifdef EGL_IMG_context_priority

18540 EGLEW_IMG_context_priority = _glewSearchExtension("EGL_IMG_context_priority", extStart, extEnd);

18541 #endif /* EGL_IMG_context_priority */

18542 #ifdef EGL_IMG_image_plane_attribs

18543 EGLEW_IMG_image_plane_attribs = _glewSearchExtension("EGL_IMG_image_plane_attribs", extStart, extEnd);

18544 #endif /* EGL_IMG_image_plane_attribs */

18545 #ifdef EGL_KHR_cl_event

18546 EGLEW_KHR_cl_event = _glewSearchExtension("EGL_KHR_cl_event", extStart, extEnd);

18547 #endif /* EGL_KHR_cl_event */

18548 #ifdef EGL_KHR_cl_event2

18549 EGLEW_KHR_cl_event2 = _glewSearchExtension("EGL_KHR_cl_event2", extStart, extEnd);

18550 if (glewExperimental || EGLEW_KHR_cl_event2) EGLEW_KHR_cl_event2 = !_glewInit_EGL_KHR_cl_event2();

18551 #endif /* EGL_KHR_cl_event2 */

18552 #ifdef EGL_KHR_client_get_all_proc_addresses

18553 EGLEW_KHR_client_get_all_proc_addresses = _glewSearchExtension("EGL_KHR_client_get_all_proc_addresses", extStart, extEnd);

18554 #endif /* EGL_KHR_client_get_all_proc_addresses */

18555 #ifdef EGL_KHR_config_attribs

18556 EGLEW_KHR_config_attribs = _glewSearchExtension("EGL_KHR_config_attribs", extStart, extEnd);

18557 #endif /* EGL_KHR_config_attribs */

18558 #ifdef EGL_KHR_context_flush_control

18559 EGLEW_KHR_context_flush_control = _glewSearchExtension("EGL_KHR_context_flush_control", extStart, extEnd);

18560 #endif /* EGL_KHR_context_flush_control */

18561 #ifdef EGL_KHR_create_context

18562 EGLEW_KHR_create_context = _glewSearchExtension("EGL_KHR_create_context", extStart, extEnd);

18563 #endif /* EGL_KHR_create_context */

18564 #ifdef EGL_KHR_create_context_no_error

18565 EGLEW_KHR_create_context_no_error = _glewSearchExtension("EGL_KHR_create_context_no_error", extStart, extEnd);

18566 #endif /* EGL_KHR_create_context_no_error */

18567 #ifdef EGL_KHR_debug

18568 EGLEW_KHR_debug = _glewSearchExtension("EGL_KHR_debug", extStart, extEnd);

18569 if (glewExperimental || EGLEW_KHR_debug) EGLEW_KHR_debug = !_glewInit_EGL_KHR_debug();

18570 #endif /* EGL_KHR_debug */

18571 #ifdef EGL_KHR_fence_sync

18572 EGLEW_KHR_fence_sync = _glewSearchExtension("EGL_KHR_fence_sync", extStart, extEnd);

18573 #endif /* EGL_KHR_fence_sync */

18574 #ifdef EGL_KHR_get_all_proc_addresses

18575 EGLEW_KHR_get_all_proc_addresses = _glewSearchExtension("EGL_KHR_get_all_proc_addresses", extStart, extEnd);

18576 #endif /* EGL_KHR_get_all_proc_addresses */

18577 #ifdef EGL_KHR_gl_colorspace

18578 EGLEW_KHR_gl_colorspace = _glewSearchExtension("EGL_KHR_gl_colorspace", extStart, extEnd);

18579 #endif /* EGL_KHR_gl_colorspace */

18580 #ifdef EGL_KHR_gl_renderbuffer_image

18581 EGLEW_KHR_gl_renderbuffer_image = _glewSearchExtension("EGL_KHR_gl_renderbuffer_image", extStart, extEnd);

18582 #endif /* EGL_KHR_gl_renderbuffer_image */

18583 #ifdef EGL_KHR_gl_texture_2D_image

18584 EGLEW_KHR_gl_texture_2D_image = _glewSearchExtension("EGL_KHR_gl_texture_2D_image", extStart, extEnd);

18585 #endif /* EGL_KHR_gl_texture_2D_image */

18586 #ifdef EGL_KHR_gl_texture_3D_image

18587 EGLEW_KHR_gl_texture_3D_image = _glewSearchExtension("EGL_KHR_gl_texture_3D_image", extStart, extEnd);

18588 #endif /* EGL_KHR_gl_texture_3D_image */

18589 #ifdef EGL_KHR_gl_texture_cubemap_image

18590 EGLEW_KHR_gl_texture_cubemap_image = _glewSearchExtension("EGL_KHR_gl_texture_cubemap_image", extStart, extEnd);

18591 #endif /* EGL_KHR_gl_texture_cubemap_image */

18592 #ifdef EGL_KHR_image

18593 EGLEW_KHR_image = _glewSearchExtension("EGL_KHR_image", extStart, extEnd);

18594 if (glewExperimental || EGLEW_KHR_image) EGLEW_KHR_image = !_glewInit_EGL_KHR_image();

18595 #endif /* EGL_KHR_image */

18596 #ifdef EGL_KHR_image_base

18597 EGLEW_KHR_image_base = _glewSearchExtension("EGL_KHR_image_base", extStart, extEnd);

18598 #endif /* EGL_KHR_image_base */

18599 #ifdef EGL_KHR_image_pixmap

18600 EGLEW_KHR_image_pixmap = _glewSearchExtension("EGL_KHR_image_pixmap", extStart, extEnd);

18601 #endif /* EGL_KHR_image_pixmap */

18602 #ifdef EGL_KHR_lock_surface

18603 EGLEW_KHR_lock_surface = _glewSearchExtension("EGL_KHR_lock_surface", extStart, extEnd);

18604 if (glewExperimental || EGLEW_KHR_lock_surface) EGLEW_KHR_lock_surface = !_glewInit_EGL_KHR_lock_surface();

18605 #endif /* EGL_KHR_lock_surface */

18606 #ifdef EGL_KHR_lock_surface2

18607 EGLEW_KHR_lock_surface2 = _glewSearchExtension("EGL_KHR_lock_surface2", extStart, extEnd);

18608 #endif /* EGL_KHR_lock_surface2 */

18609 #ifdef EGL_KHR_lock_surface3

18610 EGLEW_KHR_lock_surface3 = _glewSearchExtension("EGL_KHR_lock_surface3", extStart, extEnd);

18611 if (glewExperimental || EGLEW_KHR_lock_surface3) EGLEW_KHR_lock_surface3 = !_glewInit_EGL_KHR_lock_surface3();

18612 #endif /* EGL_KHR_lock_surface3 */

18613 #ifdef EGL_KHR_mutable_render_buffer

18614 EGLEW_KHR_mutable_render_buffer = _glewSearchExtension("EGL_KHR_mutable_render_buffer", extStart, extEnd);

18615 #endif /* EGL_KHR_mutable_render_buffer */

18616 #ifdef EGL_KHR_no_config_context

18617 EGLEW_KHR_no_config_context = _glewSearchExtension("EGL_KHR_no_config_context", extStart, extEnd);

18618 #endif /* EGL_KHR_no_config_context */

18619 #ifdef EGL_KHR_partial_update

18620 EGLEW_KHR_partial_update = _glewSearchExtension("EGL_KHR_partial_update", extStart, extEnd);

18621 if (glewExperimental || EGLEW_KHR_partial_update) EGLEW_KHR_partial_update = !_glewInit_EGL_KHR_partial_update();

18622 #endif /* EGL_KHR_partial_update */

18623 #ifdef EGL_KHR_platform_android

18624 EGLEW_KHR_platform_android = _glewSearchExtension("EGL_KHR_platform_android", extStart, extEnd);

18625 #endif /* EGL_KHR_platform_android */

18626 #ifdef EGL_KHR_platform_gbm

18627 EGLEW_KHR_platform_gbm = _glewSearchExtension("EGL_KHR_platform_gbm", extStart, extEnd);

18628 #endif /* EGL_KHR_platform_gbm */

18629 #ifdef EGL_KHR_platform_wayland

18630 EGLEW_KHR_platform_wayland = _glewSearchExtension("EGL_KHR_platform_wayland", extStart, extEnd);

18631 #endif /* EGL_KHR_platform_wayland */

18632 #ifdef EGL_KHR_platform_x11

18633 EGLEW_KHR_platform_x11 = _glewSearchExtension("EGL_KHR_platform_x11", extStart, extEnd);

18634 #endif /* EGL_KHR_platform_x11 */

18635 #ifdef EGL_KHR_reusable_sync

18636 EGLEW_KHR_reusable_sync = _glewSearchExtension("EGL_KHR_reusable_sync", extStart, extEnd);

18637 if (glewExperimental || EGLEW_KHR_reusable_sync) EGLEW_KHR_reusable_sync = !_glewInit_EGL_KHR_reusable_sync();

18638 #endif /* EGL_KHR_reusable_sync */

18639 #ifdef EGL_KHR_stream

18640 EGLEW_KHR_stream = _glewSearchExtension("EGL_KHR_stream", extStart, extEnd);

18641 if (glewExperimental || EGLEW_KHR_stream) EGLEW_KHR_stream = !_glewInit_EGL_KHR_stream();

18642 #endif /* EGL_KHR_stream */

18643 #ifdef EGL_KHR_stream_attrib

18644 EGLEW_KHR_stream_attrib = _glewSearchExtension("EGL_KHR_stream_attrib", extStart, extEnd);

18645 if (glewExperimental || EGLEW_KHR_stream_attrib) EGLEW_KHR_stream_attrib = !_glewInit_EGL_KHR_stream_attrib();

18646 #endif /* EGL_KHR_stream_attrib */

18647 #ifdef EGL_KHR_stream_consumer_gltexture

18648 EGLEW_KHR_stream_consumer_gltexture = _glewSearchExtension("EGL_KHR_stream_consumer_gltexture", extStart, extEnd);

18649 if (glewExperimental || EGLEW_KHR_stream_consumer_gltexture) EGLEW_KHR_stream_consumer_gltexture = !_glewInit_EGL_KHR_stream_consumer_gltexture();

18650 #endif /* EGL_KHR_stream_consumer_gltexture */

18651 #ifdef EGL_KHR_stream_cross_process_fd

18652 EGLEW_KHR_stream_cross_process_fd = _glewSearchExtension("EGL_KHR_stream_cross_process_fd", extStart, extEnd);

18653 if (glewExperimental || EGLEW_KHR_stream_cross_process_fd) EGLEW_KHR_stream_cross_process_fd = !_glewInit_EGL_KHR_stream_cross_process_fd();

18654 #endif /* EGL_KHR_stream_cross_process_fd */

18655 #ifdef EGL_KHR_stream_fifo

18656 EGLEW_KHR_stream_fifo = _glewSearchExtension("EGL_KHR_stream_fifo", extStart, extEnd);

18657 if (glewExperimental || EGLEW_KHR_stream_fifo) EGLEW_KHR_stream_fifo = !_glewInit_EGL_KHR_stream_fifo();

18658 #endif /* EGL_KHR_stream_fifo */

18659 #ifdef EGL_KHR_stream_producer_aldatalocator

18660 EGLEW_KHR_stream_producer_aldatalocator = _glewSearchExtension("EGL_KHR_stream_producer_aldatalocator", extStart, extEnd);

18661 #endif /* EGL_KHR_stream_producer_aldatalocator */

18662 #ifdef EGL_KHR_stream_producer_eglsurface

18663 EGLEW_KHR_stream_producer_eglsurface = _glewSearchExtension("EGL_KHR_stream_producer_eglsurface", extStart, extEnd);

18664 if (glewExperimental || EGLEW_KHR_stream_producer_eglsurface) EGLEW_KHR_stream_producer_eglsurface = !_glewInit_EGL_KHR_stream_producer_eglsurface();

18665 #endif /* EGL_KHR_stream_producer_eglsurface */

18666 #ifdef EGL_KHR_surfaceless_context

18667 EGLEW_KHR_surfaceless_context = _glewSearchExtension("EGL_KHR_surfaceless_context", extStart, extEnd);

18668 #endif /* EGL_KHR_surfaceless_context */

18669 #ifdef EGL_KHR_swap_buffers_with_damage

18670 EGLEW_KHR_swap_buffers_with_damage = _glewSearchExtension("EGL_KHR_swap_buffers_with_damage", extStart, extEnd);

18671 if (glewExperimental || EGLEW_KHR_swap_buffers_with_damage) EGLEW_KHR_swap_buffers_with_damage = !_glewInit_EGL_KHR_swap_buffers_with_damage();

18672 #endif /* EGL_KHR_swap_buffers_with_damage */

18673 #ifdef EGL_KHR_vg_parent_image

18674 EGLEW_KHR_vg_parent_image = _glewSearchExtension("EGL_KHR_vg_parent_image", extStart, extEnd);

18675 #endif /* EGL_KHR_vg_parent_image */

18676 #ifdef EGL_KHR_wait_sync

18677 EGLEW_KHR_wait_sync = _glewSearchExtension("EGL_KHR_wait_sync", extStart, extEnd);

18678 if (glewExperimental || EGLEW_KHR_wait_sync) EGLEW_KHR_wait_sync = !_glewInit_EGL_KHR_wait_sync();

18679 #endif /* EGL_KHR_wait_sync */

18680 #ifdef EGL_MESA_drm_image

18681 EGLEW_MESA_drm_image = _glewSearchExtension("EGL_MESA_drm_image", extStart, extEnd);

18682 if (glewExperimental || EGLEW_MESA_drm_image) EGLEW_MESA_drm_image = !_glewInit_EGL_MESA_drm_image();

18683 #endif /* EGL_MESA_drm_image */

18684 #ifdef EGL_MESA_image_dma_buf_export

18685 EGLEW_MESA_image_dma_buf_export = _glewSearchExtension("EGL_MESA_image_dma_buf_export", extStart, extEnd);

18686 if (glewExperimental || EGLEW_MESA_image_dma_buf_export) EGLEW_MESA_image_dma_buf_export = !_glewInit_EGL_MESA_image_dma_buf_export();

18687 #endif /* EGL_MESA_image_dma_buf_export */

18688 #ifdef EGL_MESA_platform_gbm

18689 EGLEW_MESA_platform_gbm = _glewSearchExtension("EGL_MESA_platform_gbm", extStart, extEnd);

18690 #endif /* EGL_MESA_platform_gbm */

18691 #ifdef EGL_MESA_platform_surfaceless

18692 EGLEW_MESA_platform_surfaceless = _glewSearchExtension("EGL_MESA_platform_surfaceless", extStart, extEnd);

18693 #endif /* EGL_MESA_platform_surfaceless */

18694 #ifdef EGL_NOK_swap_region

18695 EGLEW_NOK_swap_region = _glewSearchExtension("EGL_NOK_swap_region", extStart, extEnd);

18696 if (glewExperimental || EGLEW_NOK_swap_region) EGLEW_NOK_swap_region = !_glewInit_EGL_NOK_swap_region();

18697 #endif /* EGL_NOK_swap_region */

18698 #ifdef EGL_NOK_swap_region2

18699 EGLEW_NOK_swap_region2 = _glewSearchExtension("EGL_NOK_swap_region2", extStart, extEnd);

18700 if (glewExperimental || EGLEW_NOK_swap_region2) EGLEW_NOK_swap_region2 = !_glewInit_EGL_NOK_swap_region2();

18701 #endif /* EGL_NOK_swap_region2 */

18702 #ifdef EGL_NOK_texture_from_pixmap

18703 EGLEW_NOK_texture_from_pixmap = _glewSearchExtension("EGL_NOK_texture_from_pixmap", extStart, extEnd);

18704 #endif /* EGL_NOK_texture_from_pixmap */

18705 #ifdef EGL_NV_3dvision_surface

18706 EGLEW_NV_3dvision_surface = _glewSearchExtension("EGL_NV_3dvision_surface", extStart, extEnd);

18707 #endif /* EGL_NV_3dvision_surface */

18708 #ifdef EGL_NV_coverage_sample

18709 EGLEW_NV_coverage_sample = _glewSearchExtension("EGL_NV_coverage_sample", extStart, extEnd);

18710 #endif /* EGL_NV_coverage_sample */

18711 #ifdef EGL_NV_coverage_sample_resolve

18712 EGLEW_NV_coverage_sample_resolve = _glewSearchExtension("EGL_NV_coverage_sample_resolve", extStart, extEnd);

18713 #endif /* EGL_NV_coverage_sample_resolve */

18714 #ifdef EGL_NV_cuda_event

18715 EGLEW_NV_cuda_event = _glewSearchExtension("EGL_NV_cuda_event", extStart, extEnd);

18716 #endif /* EGL_NV_cuda_event */

18717 #ifdef EGL_NV_depth_nonlinear

18718 EGLEW_NV_depth_nonlinear = _glewSearchExtension("EGL_NV_depth_nonlinear", extStart, extEnd);

18719 #endif /* EGL_NV_depth_nonlinear */

18720 #ifdef EGL_NV_device_cuda

18721 EGLEW_NV_device_cuda = _glewSearchExtension("EGL_NV_device_cuda", extStart, extEnd);

18722 #endif /* EGL_NV_device_cuda */

18723 #ifdef EGL_NV_native_query

18724 EGLEW_NV_native_query = _glewSearchExtension("EGL_NV_native_query", extStart, extEnd);

18725 if (glewExperimental || EGLEW_NV_native_query) EGLEW_NV_native_query = !_glewInit_EGL_NV_native_query();

18726 #endif /* EGL_NV_native_query */

18727 #ifdef EGL_NV_post_convert_rounding

18728 EGLEW_NV_post_convert_rounding = _glewSearchExtension("EGL_NV_post_convert_rounding", extStart, extEnd);

18729 #endif /* EGL_NV_post_convert_rounding */

18730 #ifdef EGL_NV_post_sub_buffer

18731 EGLEW_NV_post_sub_buffer = _glewSearchExtension("EGL_NV_post_sub_buffer", extStart, extEnd);

18732 if (glewExperimental || EGLEW_NV_post_sub_buffer) EGLEW_NV_post_sub_buffer = !_glewInit_EGL_NV_post_sub_buffer();

18733 #endif /* EGL_NV_post_sub_buffer */

18734 #ifdef EGL_NV_robustness_video_memory_purge

18735 EGLEW_NV_robustness_video_memory_purge = _glewSearchExtension("EGL_NV_robustness_video_memory_purge", extStart, extEnd);

18736 #endif /* EGL_NV_robustness_video_memory_purge */

18737 #ifdef EGL_NV_stream_consumer_gltexture_yuv

18738 EGLEW_NV_stream_consumer_gltexture_yuv = _glewSearchExtension("EGL_NV_stream_consumer_gltexture_yuv", extStart, extEnd);

18739 if (glewExperimental || EGLEW_NV_stream_consumer_gltexture_yuv) EGLEW_NV_stream_consumer_gltexture_yuv = !_glewInit_EGL_NV_stream_consumer_gltexture_yuv();

18740 #endif /* EGL_NV_stream_consumer_gltexture_yuv */

18741 #ifdef EGL_NV_stream_cross_display

18742 EGLEW_NV_stream_cross_display = _glewSearchExtension("EGL_NV_stream_cross_display", extStart, extEnd);

18743 #endif /* EGL_NV_stream_cross_display */

18744 #ifdef EGL_NV_stream_cross_object

18745 EGLEW_NV_stream_cross_object = _glewSearchExtension("EGL_NV_stream_cross_object", extStart, extEnd);

18746 #endif /* EGL_NV_stream_cross_object */

18747 #ifdef EGL_NV_stream_cross_partition

18748 EGLEW_NV_stream_cross_partition = _glewSearchExtension("EGL_NV_stream_cross_partition", extStart, extEnd);

18749 #endif /* EGL_NV_stream_cross_partition */

18750 #ifdef EGL_NV_stream_cross_process

18751 EGLEW_NV_stream_cross_process = _glewSearchExtension("EGL_NV_stream_cross_process", extStart, extEnd);

18752 #endif /* EGL_NV_stream_cross_process */

18753 #ifdef EGL_NV_stream_cross_system

18754 EGLEW_NV_stream_cross_system = _glewSearchExtension("EGL_NV_stream_cross_system", extStart, extEnd);

18755 #endif /* EGL_NV_stream_cross_system */

18756 #ifdef EGL_NV_stream_fifo_next

18757 EGLEW_NV_stream_fifo_next = _glewSearchExtension("EGL_NV_stream_fifo_next", extStart, extEnd);

18758 #endif /* EGL_NV_stream_fifo_next */

18759 #ifdef EGL_NV_stream_fifo_synchronous

18760 EGLEW_NV_stream_fifo_synchronous = _glewSearchExtension("EGL_NV_stream_fifo_synchronous", extStart, extEnd);

18761 #endif /* EGL_NV_stream_fifo_synchronous */

18762 #ifdef EGL_NV_stream_frame_limits

18763 EGLEW_NV_stream_frame_limits = _glewSearchExtension("EGL_NV_stream_frame_limits", extStart, extEnd);

18764 #endif /* EGL_NV_stream_frame_limits */

18765 #ifdef EGL_NV_stream_metadata

18766 EGLEW_NV_stream_metadata = _glewSearchExtension("EGL_NV_stream_metadata", extStart, extEnd);

18767 if (glewExperimental || EGLEW_NV_stream_metadata) EGLEW_NV_stream_metadata = !_glewInit_EGL_NV_stream_metadata();

18768 #endif /* EGL_NV_stream_metadata */

18769 #ifdef EGL_NV_stream_remote

18770 EGLEW_NV_stream_remote = _glewSearchExtension("EGL_NV_stream_remote", extStart, extEnd);

18771 #endif /* EGL_NV_stream_remote */

18772 #ifdef EGL_NV_stream_reset

18773 EGLEW_NV_stream_reset = _glewSearchExtension("EGL_NV_stream_reset", extStart, extEnd);

18774 if (glewExperimental || EGLEW_NV_stream_reset) EGLEW_NV_stream_reset = !_glewInit_EGL_NV_stream_reset();

18775 #endif /* EGL_NV_stream_reset */

18776 #ifdef EGL_NV_stream_socket

18777 EGLEW_NV_stream_socket = _glewSearchExtension("EGL_NV_stream_socket", extStart, extEnd);

18778 #endif /* EGL_NV_stream_socket */

18779 #ifdef EGL_NV_stream_socket_inet

18780 EGLEW_NV_stream_socket_inet = _glewSearchExtension("EGL_NV_stream_socket_inet", extStart, extEnd);

18781 #endif /* EGL_NV_stream_socket_inet */

18782 #ifdef EGL_NV_stream_socket_unix

18783 EGLEW_NV_stream_socket_unix = _glewSearchExtension("EGL_NV_stream_socket_unix", extStart, extEnd);

18784 #endif /* EGL_NV_stream_socket_unix */

18785 #ifdef EGL_NV_stream_sync

18786 EGLEW_NV_stream_sync = _glewSearchExtension("EGL_NV_stream_sync", extStart, extEnd);

18787 if (glewExperimental || EGLEW_NV_stream_sync) EGLEW_NV_stream_sync = !_glewInit_EGL_NV_stream_sync();

18788 #endif /* EGL_NV_stream_sync */

18789 #ifdef EGL_NV_sync

18790 EGLEW_NV_sync = _glewSearchExtension("EGL_NV_sync", extStart, extEnd);

18791 if (glewExperimental || EGLEW_NV_sync) EGLEW_NV_sync = !_glewInit_EGL_NV_sync();

18792 #endif /* EGL_NV_sync */

18793 #ifdef EGL_NV_system_time

18794 EGLEW_NV_system_time = _glewSearchExtension("EGL_NV_system_time", extStart, extEnd);

18795 if (glewExperimental || EGLEW_NV_system_time) EGLEW_NV_system_time = !_glewInit_EGL_NV_system_time();

18796 #endif /* EGL_NV_system_time */

18797 #ifdef EGL_TIZEN_image_native_buffer

18798 EGLEW_TIZEN_image_native_buffer = _glewSearchExtension("EGL_TIZEN_image_native_buffer", extStart, extEnd);

18799 #endif /* EGL_TIZEN_image_native_buffer */

18800 #ifdef EGL_TIZEN_image_native_surface

18801 EGLEW_TIZEN_image_native_surface = _glewSearchExtension("EGL_TIZEN_image_native_surface", extStart, extEnd);

18802 #endif /* EGL_TIZEN_image_native_surface */

18803

18804 return GLEW_OK;

18805 }

18806

18807 #elif defined(_WIN32)

18808

18809 PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;

18810

18811 PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL;

18812 PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL;

18813 PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL;

18814 PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL;

18815 PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL;

18816 PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL;

18817 PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL;

18818 PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL;

18819 PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL;

18820

18821 PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;

18822 PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;

18823 PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;

18824 PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;

18825

18826 PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL;

18827

18828 PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;

18829

18830 PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;

18831 PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;

18832

18833 PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;

18834 PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;

18835 PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;

18836 PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;

18837 PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;

18838

18839 PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;

18840 PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;

18841 PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;

18842

18843 PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;

18844 PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;

18845 PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;

18846

18847 PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;

18848 PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;

18849 PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;

18850 PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;

18851

18852 PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;

18853

18854 PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;

18855 PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;

18856

18857 PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;

18858 PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;

18859 PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;

18860 PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;

18861 PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;

18862

18863 PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;

18864 PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;

18865 PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;

18866

18867 PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;

18868 PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;

18869

18870 PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;

18871 PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;

18872

18873 PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;

18874 PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;

18875 PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;

18876 PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;

18877

18878 PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;

18879 PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;

18880 PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;

18881 PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;

18882 PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;

18883 PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;

18884 PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;

18885 PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;

18886 PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;

18887 PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;

18888 PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;

18889 PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;

18890

18891 PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;

18892 PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;

18893 PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;

18894 PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;

18895

18896 PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;

18897 PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;

18898 PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;

18899 PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;

18900

18901 PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;

18902 PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;

18903 PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;

18904 PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;

18905

18906 PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV = NULL;

18907 PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV = NULL;

18908 PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV = NULL;

18909 PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV = NULL;

18910 PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV = NULL;

18911 PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV = NULL;

18912 PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV = NULL;

18913 PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV = NULL;

18914

18915 PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL;

18916

18917 PFNWGLDELAYBEFORESWAPNVPROC __wglewDelayBeforeSwapNV = NULL;

18918

18919 PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;

18920 PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;

18921 PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;

18922 PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL;

18923 PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL;

18924

18925 PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL;

18926 PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL;

18927 PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL;

18928

18929 PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL;

18930 PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL;

18931 PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL;

18932 PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL;

18933 PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL;

18934 PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL;

18935

18936 PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;

18937 PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;

18938

18939 PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV = NULL;

18940 PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV = NULL;

18941 PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV = NULL;

18942 PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV = NULL;

18943 PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV = NULL;

18944

18945 PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL;

18946 PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL;

18947 PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL;

18948 PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL;

18949 PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL;

18950 PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL;

18951

18952 PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;

18953 PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;

18954 PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;

18955 PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;

18956 PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;

18957 PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;

18958 GLboolean __WGLEW_3DFX_multisample = GL_FALSE;

18959 GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;

18960 GLboolean __WGLEW_AMD_gpu_association = GL_FALSE;

18961 GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;

18962 GLboolean __WGLEW_ARB_context_flush_control = GL_FALSE;

18963 GLboolean __WGLEW_ARB_create_context = GL_FALSE;

18964 GLboolean __WGLEW_ARB_create_context_no_error = GL_FALSE;

18965 GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE;

18966 GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE;

18967 GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;

18968 GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE;

18969 GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;

18970 GLboolean __WGLEW_ARB_multisample = GL_FALSE;

18971 GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;

18972 GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;

18973 GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;

18974 GLboolean __WGLEW_ARB_render_texture = GL_FALSE;

18975 GLboolean __WGLEW_ARB_robustness_application_isolation = GL_FALSE;

18976 GLboolean __WGLEW_ARB_robustness_share_group_isolation = GL_FALSE;

18977 GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;

18978 GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;

18979 GLboolean __WGLEW_EXT_colorspace = GL_FALSE;

18980 GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE;

18981 GLboolean __WGLEW_EXT_create_context_es_profile = GL_FALSE;

18982 GLboolean __WGLEW_EXT_depth_float = GL_FALSE;

18983 GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;

18984 GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;

18985 GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE;

18986 GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;

18987 GLboolean __WGLEW_EXT_multisample = GL_FALSE;

18988 GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;

18989 GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;

18990 GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE;

18991 GLboolean __WGLEW_EXT_swap_control = GL_FALSE;

18992 GLboolean __WGLEW_EXT_swap_control_tear = GL_FALSE;

18993 GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;

18994 GLboolean __WGLEW_I3D_gamma = GL_FALSE;

18995 GLboolean __WGLEW_I3D_genlock = GL_FALSE;

18996 GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;

18997 GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;

18998 GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;

18999 GLboolean __WGLEW_NV_DX_interop = GL_FALSE;

19000 GLboolean __WGLEW_NV_DX_interop2 = GL_FALSE;

19001 GLboolean __WGLEW_NV_copy_image = GL_FALSE;

19002 GLboolean __WGLEW_NV_delay_before_swap = GL_FALSE;

19003 GLboolean __WGLEW_NV_float_buffer = GL_FALSE;

19004 GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;

19005 GLboolean __WGLEW_NV_multisample_coverage = GL_FALSE;

19006 GLboolean __WGLEW_NV_present_video = GL_FALSE;

19007 GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;

19008 GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;

19009 GLboolean __WGLEW_NV_swap_group = GL_FALSE;

19010 GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;

19011 GLboolean __WGLEW_NV_video_capture = GL_FALSE;

19012 GLboolean __WGLEW_NV_video_output = GL_FALSE;

19013 GLboolean __WGLEW_OML_sync_control = GL_FALSE;

19014 #ifdef WGL_3DL_stereo_control

19015

19016 static GLboolean _glewInit_WGL_3DL_stereo_control ()

19017 {

19018 GLboolean r = GL_FALSE;

19019

19020 r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r;

19021

19022 return r;

19023 }

19024

19025 #endif /* WGL_3DL_stereo_control */

19026

19027 #ifdef WGL_AMD_gpu_association

19028

19029 static GLboolean _glewInit_WGL_AMD_gpu_association ()

19030 {

19031 GLboolean r = GL_FALSE;

19032

19033 r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r;

19034 r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r;

19035 r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r;

19036 r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r;

19037 r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r;

19038 r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r;

19039 r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r;

19040 r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r;

19041 r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r;

19042

19043 return r;

19044 }

19045

19046 #endif /* WGL_AMD_gpu_association */

19047

19048 #ifdef WGL_ARB_buffer_region

19049

19050 static GLboolean _glewInit_WGL_ARB_buffer_region ()

19051 {

19052 GLboolean r = GL_FALSE;

19053

19054 r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;

19055 r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;

19056 r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;

19057 r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;

19058

19059 return r;

19060 }

19061

19062 #endif /* WGL_ARB_buffer_region */

19063

19064 #ifdef WGL_ARB_create_context

19065

19066 static GLboolean _glewInit_WGL_ARB_create_context ()

19067 {

19068 GLboolean r = GL_FALSE;

19069

19070 r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r;

19071

19072 return r;

19073 }

19074

19075 #endif /* WGL_ARB_create_context */

19076

19077 #ifdef WGL_ARB_extensions_string

19078

19079 static GLboolean _glewInit_WGL_ARB_extensions_string ()

19080 {

19081 GLboolean r = GL_FALSE;

19082

19083 r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;

19084

19085 return r;

19086 }

19087

19088 #endif /* WGL_ARB_extensions_string */

19089

19090 #ifdef WGL_ARB_make_current_read

19091

19092 static GLboolean _glewInit_WGL_ARB_make_current_read ()

19093 {

19094 GLboolean r = GL_FALSE;

19095

19096 r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;

19097 r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;

19098

19099 return r;

19100 }

19101

19102 #endif /* WGL_ARB_make_current_read */

19103

19104 #ifdef WGL_ARB_pbuffer

19105

19106 static GLboolean _glewInit_WGL_ARB_pbuffer ()

19107 {

19108 GLboolean r = GL_FALSE;

19109

19110 r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;

19111 r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;

19112 r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;

19113 r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;

19114 r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;

19115

19116 return r;

19117 }

19118

19119 #endif /* WGL_ARB_pbuffer */

19120

19121 #ifdef WGL_ARB_pixel_format

19122

19123 static GLboolean _glewInit_WGL_ARB_pixel_format ()

19124 {

19125 GLboolean r = GL_FALSE;

19126

19127 r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;

19128 r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;

19129 r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;

19130

19131 return r;

19132 }

19133

19134 #endif /* WGL_ARB_pixel_format */

19135

19136 #ifdef WGL_ARB_render_texture

19137

19138 static GLboolean _glewInit_WGL_ARB_render_texture ()

19139 {

19140 GLboolean r = GL_FALSE;

19141

19142 r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;

19143 r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;

19144 r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;

19145

19146 return r;

19147 }

19148

19149 #endif /* WGL_ARB_render_texture */

19150

19151 #ifdef WGL_EXT_display_color_table

19152

19153 static GLboolean _glewInit_WGL_EXT_display_color_table ()

19154 {

19155 GLboolean r = GL_FALSE;

19156

19157 r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;

19158 r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;

19159 r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;

19160 r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;

19161

19162 return r;

19163 }

19164

19165 #endif /* WGL_EXT_display_color_table */

19166

19167 #ifdef WGL_EXT_extensions_string

19168

19169 static GLboolean _glewInit_WGL_EXT_extensions_string ()

19170 {

19171 GLboolean r = GL_FALSE;

19172

19173 r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;

19174

19175 return r;

19176 }

19177

19178 #endif /* WGL_EXT_extensions_string */

19179

19180 #ifdef WGL_EXT_make_current_read

19181

19182 static GLboolean _glewInit_WGL_EXT_make_current_read ()

19183 {

19184 GLboolean r = GL_FALSE;

19185

19186 r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;

19187 r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;

19188

19189 return r;

19190 }

19191

19192 #endif /* WGL_EXT_make_current_read */

19193

19194 #ifdef WGL_EXT_pbuffer

19195

19196 static GLboolean _glewInit_WGL_EXT_pbuffer ()

19197 {

19198 GLboolean r = GL_FALSE;

19199

19200 r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;

19201 r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;

19202 r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;

19203 r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;

19204 r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;

19205

19206 return r;

19207 }

19208

19209 #endif /* WGL_EXT_pbuffer */

19210

19211 #ifdef WGL_EXT_pixel_format

19212

19213 static GLboolean _glewInit_WGL_EXT_pixel_format ()

19214 {

19215 GLboolean r = GL_FALSE;

19216

19217 r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;

19218 r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;

19219 r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;

19220

19221 return r;

19222 }

19223

19224 #endif /* WGL_EXT_pixel_format */

19225

19226 #ifdef WGL_EXT_swap_control

19227

19228 static GLboolean _glewInit_WGL_EXT_swap_control ()

19229 {

19230 GLboolean r = GL_FALSE;

19231

19232 r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;

19233 r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;

19234

19235 return r;

19236 }

19237

19238 #endif /* WGL_EXT_swap_control */

19239

19240 #ifdef WGL_I3D_digital_video_control

19241

19242 static GLboolean _glewInit_WGL_I3D_digital_video_control ()

19243 {

19244 GLboolean r = GL_FALSE;

19245

19246 r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;

19247 r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;

19248

19249 return r;

19250 }

19251

19252 #endif /* WGL_I3D_digital_video_control */

19253

19254 #ifdef WGL_I3D_gamma

19255

19256 static GLboolean _glewInit_WGL_I3D_gamma ()

19257 {

19258 GLboolean r = GL_FALSE;

19259

19260 r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;

19261 r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;

19262 r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;

19263 r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;

19264

19265 return r;

19266 }

19267

19268 #endif /* WGL_I3D_gamma */

19269

19270 #ifdef WGL_I3D_genlock

19271

19272 static GLboolean _glewInit_WGL_I3D_genlock ()

19273 {

19274 GLboolean r = GL_FALSE;

19275

19276 r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;

19277 r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;

19278 r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;

19279 r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;

19280 r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;

19281 r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;

19282 r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;

19283 r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;

19284 r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;

19285 r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;

19286 r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;

19287 r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;

19288

19289 return r;

19290 }

19291

19292 #endif /* WGL_I3D_genlock */

19293

19294 #ifdef WGL_I3D_image_buffer

19295

19296 static GLboolean _glewInit_WGL_I3D_image_buffer ()

19297 {

19298 GLboolean r = GL_FALSE;

19299

19300 r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;

19301 r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;

19302 r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;

19303 r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;

19304

19305 return r;

19306 }

19307

19308 #endif /* WGL_I3D_image_buffer */

19309

19310 #ifdef WGL_I3D_swap_frame_lock

19311

19312 static GLboolean _glewInit_WGL_I3D_swap_frame_lock ()

19313 {

19314 GLboolean r = GL_FALSE;

19315

19316 r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;

19317 r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;

19318 r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;

19319 r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;

19320

19321 return r;

19322 }

19323

19324 #endif /* WGL_I3D_swap_frame_lock */

19325

19326 #ifdef WGL_I3D_swap_frame_usage

19327

19328 static GLboolean _glewInit_WGL_I3D_swap_frame_usage ()

19329 {

19330 GLboolean r = GL_FALSE;

19331

19332 r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;

19333 r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;

19334 r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;

19335 r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;

19336

19337 return r;

19338 }

19339

19340 #endif /* WGL_I3D_swap_frame_usage */

19341

19342 #ifdef WGL_NV_DX_interop

19343

19344 static GLboolean _glewInit_WGL_NV_DX_interop ()

19345 {

19346 GLboolean r = GL_FALSE;

19347

19348 r = ((wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXCloseDeviceNV")) == NULL) || r;

19349 r = ((wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXLockObjectsNV")) == NULL) || r;

19350 r = ((wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXObjectAccessNV")) == NULL) || r;

19351 r = ((wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXOpenDeviceNV")) == NULL) || r;

19352 r = ((wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXRegisterObjectNV")) == NULL) || r;

19353 r = ((wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"wglDXSetResourceShareHandleNV")) == NULL) || r;

19354 r = ((wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnlockObjectsNV")) == NULL) || r;

19355 r = ((wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnregisterObjectNV")) == NULL) || r;

19356

19357 return r;

19358 }

19359

19360 #endif /* WGL_NV_DX_interop */

19361

19362 #ifdef WGL_NV_copy_image

19363

19364 static GLboolean _glewInit_WGL_NV_copy_image ()

19365 {

19366 GLboolean r = GL_FALSE;

19367

19368 r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r;

19369

19370 return r;

19371 }

19372

19373 #endif /* WGL_NV_copy_image */

19374

19375 #ifdef WGL_NV_delay_before_swap

19376

19377 static GLboolean _glewInit_WGL_NV_delay_before_swap ()

19378 {

19379 GLboolean r = GL_FALSE;

19380

19381 r = ((wglDelayBeforeSwapNV = (PFNWGLDELAYBEFORESWAPNVPROC)glewGetProcAddress((const GLubyte*)"wglDelayBeforeSwapNV")) == NULL) || r;

19382

19383 return r;

19384 }

19385

19386 #endif /* WGL_NV_delay_before_swap */

19387

19388 #ifdef WGL_NV_gpu_affinity

19389

19390 static GLboolean _glewInit_WGL_NV_gpu_affinity ()

19391 {

19392 GLboolean r = GL_FALSE;

19393

19394 r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r;

19395 r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r;

19396 r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r;

19397 r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r;

19398 r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r;

19399

19400 return r;

19401 }

19402

19403 #endif /* WGL_NV_gpu_affinity */

19404

19405 #ifdef WGL_NV_present_video

19406

19407 static GLboolean _glewInit_WGL_NV_present_video ()

19408 {

19409 GLboolean r = GL_FALSE;

19410

19411 r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r;

19412 r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r;

19413 r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r;

19414

19415 return r;

19416 }

19417

19418 #endif /* WGL_NV_present_video */

19419

19420 #ifdef WGL_NV_swap_group

19421

19422 static GLboolean _glewInit_WGL_NV_swap_group ()

19423 {

19424 GLboolean r = GL_FALSE;

19425

19426 r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r;

19427 r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r;

19428 r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r;

19429 r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r;

19430 r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r;

19431 r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r;

19432

19433 return r;

19434 }

19435

19436 #endif /* WGL_NV_swap_group */

19437

19438 #ifdef WGL_NV_vertex_array_range

19439

19440 static GLboolean _glewInit_WGL_NV_vertex_array_range ()

19441 {

19442 GLboolean r = GL_FALSE;

19443

19444 r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;

19445 r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;

19446

19447 return r;

19448 }

19449

19450 #endif /* WGL_NV_vertex_array_range */

19451

19452 #ifdef WGL_NV_video_capture

19453

19454 static GLboolean _glewInit_WGL_NV_video_capture ()

19455 {

19456 GLboolean r = GL_FALSE;

19457

19458 r = ((wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoCaptureDeviceNV")) == NULL) || r;

19459 r = ((wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoCaptureDevicesNV")) == NULL) || r;

19460 r = ((wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglLockVideoCaptureDeviceNV")) == NULL) || r;

19461 r = ((wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglQueryVideoCaptureDeviceNV")) == NULL) || r;

19462 r = ((wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoCaptureDeviceNV")) == NULL) || r;

19463

19464 return r;

19465 }

19466

19467 #endif /* WGL_NV_video_capture */

19468

19469 #ifdef WGL_NV_video_output

19470

19471 static GLboolean _glewInit_WGL_NV_video_output ()

19472 {

19473 GLboolean r = GL_FALSE;

19474

19475 r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r;

19476 r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r;

19477 r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r;

19478 r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r;

19479 r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r;

19480 r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r;

19481

19482 return r;

19483 }

19484

19485 #endif /* WGL_NV_video_output */

19486

19487 #ifdef WGL_OML_sync_control

19488

19489 static GLboolean _glewInit_WGL_OML_sync_control ()

19490 {

19491 GLboolean r = GL_FALSE;

19492

19493 r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;

19494 r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;

19495 r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;

19496 r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;

19497 r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;

19498 r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;

19499

19500 return r;

19501 }

19502

19503 #endif /* WGL_OML_sync_control */

19504

19505 /* ------------------------------------------------------------------------- */

19506

19507 static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;

19508 static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;

19509

19510 GLboolean GLEWAPIENTRY wglewGetExtension (const char* name)

19511 {

19512 const GLubyte* start;

19513 const GLubyte* end;

19514 if (_wglewGetExtensionsStringARB == NULL)

19515 if (_wglewGetExtensionsStringEXT == NULL)

19516 return GL_FALSE;

19517 else

19518 start = (const GLubyte*)_wglewGetExtensionsStringEXT();

19519 else

19520 start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());

19521 if (start == 0)

19522 return GL_FALSE;

19523 end = start + _glewStrLen(start);

19524 return _glewSearchExtension(name, start, end);

19525 }

19526

19527 GLenum GLEWAPIENTRY wglewInit ()

19528 {

19529 GLboolean crippled;

19530 const GLubyte* extStart;

19531 const GLubyte* extEnd;

19532 /* find wgl extension string query functions */

19533 _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");

19534 _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");

19535 /* query wgl extension string */

19536 if (_wglewGetExtensionsStringARB == NULL)

19537 if (_wglewGetExtensionsStringEXT == NULL)

19538 extStart = (const GLubyte*)"";

19539 else

19540 extStart = (const GLubyte*)_wglewGetExtensionsStringEXT();

19541 else

19542 extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());

19543 extEnd = extStart + _glewStrLen(extStart);

19544 /* initialize extensions */

19545 crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;

19546 #ifdef WGL_3DFX_multisample

19547 WGLEW_3DFX_multisample = _glewSearchExtension("WGL_3DFX_multisample", extStart, extEnd);

19548 #endif /* WGL_3DFX_multisample */

19549 #ifdef WGL_3DL_stereo_control

19550 WGLEW_3DL_stereo_control = _glewSearchExtension("WGL_3DL_stereo_control", extStart, extEnd);

19551 if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) WGLEW_3DL_stereo_control= !_glewInit_WGL_3DL_stereo_control();

19552 #endif /* WGL_3DL_stereo_control */

19553 #ifdef WGL_AMD_gpu_association

19554 WGLEW_AMD_gpu_association = _glewSearchExtension("WGL_AMD_gpu_association", extStart, extEnd);

19555 if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) WGLEW_AMD_gpu_association= !_glewInit_WGL_AMD_gpu_association();

19556 #endif /* WGL_AMD_gpu_association */

19557 #ifdef WGL_ARB_buffer_region

19558 WGLEW_ARB_buffer_region = _glewSearchExtension("WGL_ARB_buffer_region", extStart, extEnd);

19559 if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) WGLEW_ARB_buffer_region= !_glewInit_WGL_ARB_buffer_region();

19560 #endif /* WGL_ARB_buffer_region */

19561 #ifdef WGL_ARB_context_flush_control

19562 WGLEW_ARB_context_flush_control = _glewSearchExtension("WGL_ARB_context_flush_control", extStart, extEnd);

19563 #endif /* WGL_ARB_context_flush_control */

19564 #ifdef WGL_ARB_create_context

19565 WGLEW_ARB_create_context = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd);

19566 if (glewExperimental || WGLEW_ARB_create_context|| crippled) WGLEW_ARB_create_context= !_glewInit_WGL_ARB_create_context();

19567 #endif /* WGL_ARB_create_context */

19568 #ifdef WGL_ARB_create_context_no_error

19569 WGLEW_ARB_create_context_no_error = _glewSearchExtension("WGL_ARB_create_context_no_error", extStart, extEnd);

19570 #endif /* WGL_ARB_create_context_no_error */

19571 #ifdef WGL_ARB_create_context_profile

19572 WGLEW_ARB_create_context_profile = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd);

19573 #endif /* WGL_ARB_create_context_profile */

19574 #ifdef WGL_ARB_create_context_robustness

19575 WGLEW_ARB_create_context_robustness = _glewSearchExtension("WGL_ARB_create_context_robustness", extStart, extEnd);

19576 #endif /* WGL_ARB_create_context_robustness */

19577 #ifdef WGL_ARB_extensions_string

19578 WGLEW_ARB_extensions_string = _glewSearchExtension("WGL_ARB_extensions_string", extStart, extEnd);

19579 if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) WGLEW_ARB_extensions_string= !_glewInit_WGL_ARB_extensions_string();

19580 #endif /* WGL_ARB_extensions_string */

19581 #ifdef WGL_ARB_framebuffer_sRGB

19582 WGLEW_ARB_framebuffer_sRGB = _glewSearchExtension("WGL_ARB_framebuffer_sRGB", extStart, extEnd);

19583 #endif /* WGL_ARB_framebuffer_sRGB */

19584 #ifdef WGL_ARB_make_current_read

19585 WGLEW_ARB_make_current_read = _glewSearchExtension("WGL_ARB_make_current_read", extStart, extEnd);

19586 if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) WGLEW_ARB_make_current_read= !_glewInit_WGL_ARB_make_current_read();

19587 #endif /* WGL_ARB_make_current_read */

19588 #ifdef WGL_ARB_multisample

19589 WGLEW_ARB_multisample = _glewSearchExtension("WGL_ARB_multisample", extStart, extEnd);

19590 #endif /* WGL_ARB_multisample */

19591 #ifdef WGL_ARB_pbuffer

19592 WGLEW_ARB_pbuffer = _glewSearchExtension("WGL_ARB_pbuffer", extStart, extEnd);

19593 if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) WGLEW_ARB_pbuffer= !_glewInit_WGL_ARB_pbuffer();

19594 #endif /* WGL_ARB_pbuffer */

19595 #ifdef WGL_ARB_pixel_format

19596 WGLEW_ARB_pixel_format = _glewSearchExtension("WGL_ARB_pixel_format", extStart, extEnd);

19597 if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) WGLEW_ARB_pixel_format= !_glewInit_WGL_ARB_pixel_format();

19598 #endif /* WGL_ARB_pixel_format */

19599 #ifdef WGL_ARB_pixel_format_float

19600 WGLEW_ARB_pixel_format_float = _glewSearchExtension("WGL_ARB_pixel_format_float", extStart, extEnd);

19601 #endif /* WGL_ARB_pixel_format_float */

19602 #ifdef WGL_ARB_render_texture

19603 WGLEW_ARB_render_texture = _glewSearchExtension("WGL_ARB_render_texture", extStart, extEnd);

19604 if (glewExperimental || WGLEW_ARB_render_texture|| crippled) WGLEW_ARB_render_texture= !_glewInit_WGL_ARB_render_texture();

19605 #endif /* WGL_ARB_render_texture */

19606 #ifdef WGL_ARB_robustness_application_isolation

19607 WGLEW_ARB_robustness_application_isolation = _glewSearchExtension("WGL_ARB_robustness_application_isolation", extStart, extEnd);

19608 #endif /* WGL_ARB_robustness_application_isolation */

19609 #ifdef WGL_ARB_robustness_share_group_isolation

19610 WGLEW_ARB_robustness_share_group_isolation = _glewSearchExtension("WGL_ARB_robustness_share_group_isolation", extStart, extEnd);

19611 #endif /* WGL_ARB_robustness_share_group_isolation */

19612 #ifdef WGL_ATI_pixel_format_float

19613 WGLEW_ATI_pixel_format_float = _glewSearchExtension("WGL_ATI_pixel_format_float", extStart, extEnd);

19614 #endif /* WGL_ATI_pixel_format_float */

19615 #ifdef WGL_ATI_render_texture_rectangle

19616 WGLEW_ATI_render_texture_rectangle = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd);

19617 #endif /* WGL_ATI_render_texture_rectangle */

19618 #ifdef WGL_EXT_colorspace

19619 WGLEW_EXT_colorspace = _glewSearchExtension("WGL_EXT_colorspace", extStart, extEnd);

19620 #endif /* WGL_EXT_colorspace */

19621 #ifdef WGL_EXT_create_context_es2_profile

19622 WGLEW_EXT_create_context_es2_profile = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd);

19623 #endif /* WGL_EXT_create_context_es2_profile */

19624 #ifdef WGL_EXT_create_context_es_profile

19625 WGLEW_EXT_create_context_es_profile = _glewSearchExtension("WGL_EXT_create_context_es_profile", extStart, extEnd);

19626 #endif /* WGL_EXT_create_context_es_profile */

19627 #ifdef WGL_EXT_depth_float

19628 WGLEW_EXT_depth_float = _glewSearchExtension("WGL_EXT_depth_float", extStart, extEnd);

19629 #endif /* WGL_EXT_depth_float */

19630 #ifdef WGL_EXT_display_color_table

19631 WGLEW_EXT_display_color_table = _glewSearchExtension("WGL_EXT_display_color_table", extStart, extEnd);

19632 if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) WGLEW_EXT_display_color_table= !_glewInit_WGL_EXT_display_color_table();

19633 #endif /* WGL_EXT_display_color_table */

19634 #ifdef WGL_EXT_extensions_string

19635 WGLEW_EXT_extensions_string = _glewSearchExtension("WGL_EXT_extensions_string", extStart, extEnd);

19636 if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) WGLEW_EXT_extensions_string= !_glewInit_WGL_EXT_extensions_string();

19637 #endif /* WGL_EXT_extensions_string */

19638 #ifdef WGL_EXT_framebuffer_sRGB

19639 WGLEW_EXT_framebuffer_sRGB = _glewSearchExtension("WGL_EXT_framebuffer_sRGB", extStart, extEnd);

19640 #endif /* WGL_EXT_framebuffer_sRGB */

19641 #ifdef WGL_EXT_make_current_read

19642 WGLEW_EXT_make_current_read = _glewSearchExtension("WGL_EXT_make_current_read", extStart, extEnd);

19643 if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) WGLEW_EXT_make_current_read= !_glewInit_WGL_EXT_make_current_read();

19644 #endif /* WGL_EXT_make_current_read */

19645 #ifdef WGL_EXT_multisample

19646 WGLEW_EXT_multisample = _glewSearchExtension("WGL_EXT_multisample", extStart, extEnd);

19647 #endif /* WGL_EXT_multisample */

19648 #ifdef WGL_EXT_pbuffer

19649 WGLEW_EXT_pbuffer = _glewSearchExtension("WGL_EXT_pbuffer", extStart, extEnd);

19650 if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) WGLEW_EXT_pbuffer= !_glewInit_WGL_EXT_pbuffer();

19651 #endif /* WGL_EXT_pbuffer */

19652 #ifdef WGL_EXT_pixel_format

19653 WGLEW_EXT_pixel_format = _glewSearchExtension("WGL_EXT_pixel_format", extStart, extEnd);

19654 if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) WGLEW_EXT_pixel_format= !_glewInit_WGL_EXT_pixel_format();

19655 #endif /* WGL_EXT_pixel_format */

19656 #ifdef WGL_EXT_pixel_format_packed_float

19657 WGLEW_EXT_pixel_format_packed_float = _glewSearchExtension("WGL_EXT_pixel_format_packed_float", extStart, extEnd);

19658 #endif /* WGL_EXT_pixel_format_packed_float */

19659 #ifdef WGL_EXT_swap_control

19660 WGLEW_EXT_swap_control = _glewSearchExtension("WGL_EXT_swap_control", extStart, extEnd);

19661 if (glewExperimental || WGLEW_EXT_swap_control|| crippled) WGLEW_EXT_swap_control= !_glewInit_WGL_EXT_swap_control();

19662 #endif /* WGL_EXT_swap_control */

19663 #ifdef WGL_EXT_swap_control_tear

19664 WGLEW_EXT_swap_control_tear = _glewSearchExtension("WGL_EXT_swap_control_tear", extStart, extEnd);

19665 #endif /* WGL_EXT_swap_control_tear */

19666 #ifdef WGL_I3D_digital_video_control

19667 WGLEW_I3D_digital_video_control = _glewSearchExtension("WGL_I3D_digital_video_control", extStart, extEnd);

19668 if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) WGLEW_I3D_digital_video_control= !_glewInit_WGL_I3D_digital_video_control();

19669 #endif /* WGL_I3D_digital_video_control */

19670 #ifdef WGL_I3D_gamma

19671 WGLEW_I3D_gamma = _glewSearchExtension("WGL_I3D_gamma", extStart, extEnd);

19672 if (glewExperimental || WGLEW_I3D_gamma|| crippled) WGLEW_I3D_gamma= !_glewInit_WGL_I3D_gamma();

19673 #endif /* WGL_I3D_gamma */

19674 #ifdef WGL_I3D_genlock

19675 WGLEW_I3D_genlock = _glewSearchExtension("WGL_I3D_genlock", extStart, extEnd);

19676 if (glewExperimental || WGLEW_I3D_genlock|| crippled) WGLEW_I3D_genlock= !_glewInit_WGL_I3D_genlock();

19677 #endif /* WGL_I3D_genlock */

19678 #ifdef WGL_I3D_image_buffer

19679 WGLEW_I3D_image_buffer = _glewSearchExtension("WGL_I3D_image_buffer", extStart, extEnd);

19680 if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) WGLEW_I3D_image_buffer= !_glewInit_WGL_I3D_image_buffer();

19681 #endif /* WGL_I3D_image_buffer */

19682 #ifdef WGL_I3D_swap_frame_lock

19683 WGLEW_I3D_swap_frame_lock = _glewSearchExtension("WGL_I3D_swap_frame_lock", extStart, extEnd);

19684 if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) WGLEW_I3D_swap_frame_lock= !_glewInit_WGL_I3D_swap_frame_lock();

19685 #endif /* WGL_I3D_swap_frame_lock */

19686 #ifdef WGL_I3D_swap_frame_usage

19687 WGLEW_I3D_swap_frame_usage = _glewSearchExtension("WGL_I3D_swap_frame_usage", extStart, extEnd);

19688 if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) WGLEW_I3D_swap_frame_usage= !_glewInit_WGL_I3D_swap_frame_usage();

19689 #endif /* WGL_I3D_swap_frame_usage */

19690 #ifdef WGL_NV_DX_interop

19691 WGLEW_NV_DX_interop = _glewSearchExtension("WGL_NV_DX_interop", extStart, extEnd);

19692 if (glewExperimental || WGLEW_NV_DX_interop|| crippled) WGLEW_NV_DX_interop= !_glewInit_WGL_NV_DX_interop();

19693 #endif /* WGL_NV_DX_interop */

19694 #ifdef WGL_NV_DX_interop2

19695 WGLEW_NV_DX_interop2 = _glewSearchExtension("WGL_NV_DX_interop2", extStart, extEnd);

19696 #endif /* WGL_NV_DX_interop2 */

19697 #ifdef WGL_NV_copy_image

19698 WGLEW_NV_copy_image = _glewSearchExtension("WGL_NV_copy_image", extStart, extEnd);

19699 if (glewExperimental || WGLEW_NV_copy_image|| crippled) WGLEW_NV_copy_image= !_glewInit_WGL_NV_copy_image();

19700 #endif /* WGL_NV_copy_image */

19701 #ifdef WGL_NV_delay_before_swap

19702 WGLEW_NV_delay_before_swap = _glewSearchExtension("WGL_NV_delay_before_swap", extStart, extEnd);

19703 if (glewExperimental || WGLEW_NV_delay_before_swap|| crippled) WGLEW_NV_delay_before_swap= !_glewInit_WGL_NV_delay_before_swap();

19704 #endif /* WGL_NV_delay_before_swap */

19705 #ifdef WGL_NV_float_buffer

19706 WGLEW_NV_float_buffer = _glewSearchExtension("WGL_NV_float_buffer", extStart, extEnd);

19707 #endif /* WGL_NV_float_buffer */

19708 #ifdef WGL_NV_gpu_affinity

19709 WGLEW_NV_gpu_affinity = _glewSearchExtension("WGL_NV_gpu_affinity", extStart, extEnd);

19710 if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) WGLEW_NV_gpu_affinity= !_glewInit_WGL_NV_gpu_affinity();

19711 #endif /* WGL_NV_gpu_affinity */

19712 #ifdef WGL_NV_multisample_coverage

19713 WGLEW_NV_multisample_coverage = _glewSearchExtension("WGL_NV_multisample_coverage", extStart, extEnd);

19714 #endif /* WGL_NV_multisample_coverage */

19715 #ifdef WGL_NV_present_video

19716 WGLEW_NV_present_video = _glewSearchExtension("WGL_NV_present_video", extStart, extEnd);

19717 if (glewExperimental || WGLEW_NV_present_video|| crippled) WGLEW_NV_present_video= !_glewInit_WGL_NV_present_video();

19718 #endif /* WGL_NV_present_video */

19719 #ifdef WGL_NV_render_depth_texture

19720 WGLEW_NV_render_depth_texture = _glewSearchExtension("WGL_NV_render_depth_texture", extStart, extEnd);

19721 #endif /* WGL_NV_render_depth_texture */

19722 #ifdef WGL_NV_render_texture_rectangle

19723 WGLEW_NV_render_texture_rectangle = _glewSearchExtension("WGL_NV_render_texture_rectangle", extStart, extEnd);

19724 #endif /* WGL_NV_render_texture_rectangle */

19725 #ifdef WGL_NV_swap_group

19726 WGLEW_NV_swap_group = _glewSearchExtension("WGL_NV_swap_group", extStart, extEnd);

19727 if (glewExperimental || WGLEW_NV_swap_group|| crippled) WGLEW_NV_swap_group= !_glewInit_WGL_NV_swap_group();

19728 #endif /* WGL_NV_swap_group */

19729 #ifdef WGL_NV_vertex_array_range

19730 WGLEW_NV_vertex_array_range = _glewSearchExtension("WGL_NV_vertex_array_range", extStart, extEnd);

19731 if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) WGLEW_NV_vertex_array_range= !_glewInit_WGL_NV_vertex_array_range();

19732 #endif /* WGL_NV_vertex_array_range */

19733 #ifdef WGL_NV_video_capture

19734 WGLEW_NV_video_capture = _glewSearchExtension("WGL_NV_video_capture", extStart, extEnd);

19735 if (glewExperimental || WGLEW_NV_video_capture|| crippled) WGLEW_NV_video_capture= !_glewInit_WGL_NV_video_capture();

19736 #endif /* WGL_NV_video_capture */

19737 #ifdef WGL_NV_video_output

19738 WGLEW_NV_video_output = _glewSearchExtension("WGL_NV_video_output", extStart, extEnd);

19739 if (glewExperimental || WGLEW_NV_video_output|| crippled) WGLEW_NV_video_output= !_glewInit_WGL_NV_video_output();

19740 #endif /* WGL_NV_video_output */

19741 #ifdef WGL_OML_sync_control

19742 WGLEW_OML_sync_control = _glewSearchExtension("WGL_OML_sync_control", extStart, extEnd);

19743 if (glewExperimental || WGLEW_OML_sync_control|| crippled) WGLEW_OML_sync_control= !_glewInit_WGL_OML_sync_control();

19744 #endif /* WGL_OML_sync_control */

19745

19746 return GLEW_OK;

19747 }

19748

19749 #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))

19750

19751 PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;

19752

19753 PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;

19754 PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;

19755 PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;

19756 PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;

19757 PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;

19758 PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;

19759 PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;

19760 PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;

19761 PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;

19762 PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;

19763 PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;

19764 PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;

19765 PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;

19766 PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;

19767 PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;

19768 PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;

19769 PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;

19770

19771 PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC __glewXBlitContextFramebufferAMD = NULL;

19772 PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC __glewXCreateAssociatedContextAMD = NULL;

19773 PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __glewXCreateAssociatedContextAttribsAMD = NULL;

19774 PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC __glewXDeleteAssociatedContextAMD = NULL;

19775 PFNGLXGETCONTEXTGPUIDAMDPROC __glewXGetContextGPUIDAMD = NULL;

19776 PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC __glewXGetCurrentAssociatedContextAMD = NULL;

19777 PFNGLXGETGPUIDSAMDPROC __glewXGetGPUIDsAMD = NULL;

19778 PFNGLXGETGPUINFOAMDPROC __glewXGetGPUInfoAMD = NULL;

19779 PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __glewXMakeAssociatedContextCurrentAMD = NULL;

19780

19781 PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL;

19782

19783 PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;

19784 PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;

19785 PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;

19786

19787 PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;

19788 PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;

19789 PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;

19790 PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;

19791

19792 PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL;

19793

19794 PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;

19795 PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;

19796

19797 PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;

19798

19799 PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;

19800

19801 PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;

19802

19803 PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC __glewXQueryCurrentRendererIntegerMESA = NULL;

19804 PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC __glewXQueryCurrentRendererStringMESA = NULL;

19805 PFNGLXQUERYRENDERERINTEGERMESAPROC __glewXQueryRendererIntegerMESA = NULL;

19806 PFNGLXQUERYRENDERERSTRINGMESAPROC __glewXQueryRendererStringMESA = NULL;

19807

19808 PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;

19809

19810 PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;

19811

19812 PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA = NULL;

19813 PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA = NULL;

19814

19815 PFNGLXCOPYBUFFERSUBDATANVPROC __glewXCopyBufferSubDataNV = NULL;

19816 PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC __glewXNamedCopyBufferSubDataNV = NULL;

19817

19818 PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL;

19819

19820 PFNGLXDELAYBEFORESWAPNVPROC __glewXDelayBeforeSwapNV = NULL;

19821

19822 PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL;

19823 PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL;

19824

19825 PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL;

19826 PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL;

19827 PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL;

19828 PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL;

19829 PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL;

19830 PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL;

19831

19832 PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;

19833 PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;

19834

19835 PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV = NULL;

19836 PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV = NULL;

19837 PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV = NULL;

19838 PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV = NULL;

19839 PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV = NULL;

19840

19841 PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL;

19842 PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL;

19843 PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL;

19844 PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL;

19845 PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL;

19846 PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL;

19847

19848 PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;

19849 PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;

19850 PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;

19851 PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;

19852 PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;

19853

19854 PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;

19855 PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;

19856 PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;

19857 PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;

19858 PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;

19859 PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;

19860

19861 PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL;

19862 PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL;

19863 PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL;

19864 PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL;

19865 PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL;

19866 PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL;

19867 PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL;

19868 PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL;

19869

19870 PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;

19871 PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;

19872 PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;

19873 PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;

19874 PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;

19875

19876 PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;

19877 PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;

19878

19879 PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;

19880

19881 PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;

19882 PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;

19883 PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;

19884 PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;

19885 PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;

19886

19887 PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;

19888

19889 PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;

19890 PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;

19891

19892 PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;

19893

19894 PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;

19895 PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;

19896

19897 PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;

19898

19899 PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;

19900 PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;

19901

19902 GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;

19903 GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;

19904 GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;

19905 GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;

19906 GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;

19907 GLboolean __GLXEW_3DFX_multisample = GL_FALSE;

19908 GLboolean __GLXEW_AMD_gpu_association = GL_FALSE;

19909 GLboolean __GLXEW_ARB_context_flush_control = GL_FALSE;

19910 GLboolean __GLXEW_ARB_create_context = GL_FALSE;

19911 GLboolean __GLXEW_ARB_create_context_no_error = GL_FALSE;

19912 GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE;

19913 GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE;

19914 GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;

19915 GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE;

19916 GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;

19917 GLboolean __GLXEW_ARB_multisample = GL_FALSE;

19918 GLboolean __GLXEW_ARB_robustness_application_isolation = GL_FALSE;

19919 GLboolean __GLXEW_ARB_robustness_share_group_isolation = GL_FALSE;

19920 GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE;

19921 GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;

19922 GLboolean __GLXEW_ATI_render_texture = GL_FALSE;

19923 GLboolean __GLXEW_EXT_buffer_age = GL_FALSE;

19924 GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE;

19925 GLboolean __GLXEW_EXT_create_context_es_profile = GL_FALSE;

19926 GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;

19927 GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;

19928 GLboolean __GLXEW_EXT_import_context = GL_FALSE;

19929 GLboolean __GLXEW_EXT_libglvnd = GL_FALSE;

19930 GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;

19931 GLboolean __GLXEW_EXT_stereo_tree = GL_FALSE;

19932 GLboolean __GLXEW_EXT_swap_control = GL_FALSE;

19933 GLboolean __GLXEW_EXT_swap_control_tear = GL_FALSE;

19934 GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;

19935 GLboolean __GLXEW_EXT_visual_info = GL_FALSE;

19936 GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;

19937 GLboolean __GLXEW_INTEL_swap_event = GL_FALSE;

19938 GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;

19939 GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;

19940 GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;

19941 GLboolean __GLXEW_MESA_query_renderer = GL_FALSE;

19942 GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;

19943 GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;

19944 GLboolean __GLXEW_MESA_swap_control = GL_FALSE;

19945 GLboolean __GLXEW_NV_copy_buffer = GL_FALSE;

19946 GLboolean __GLXEW_NV_copy_image = GL_FALSE;

19947 GLboolean __GLXEW_NV_delay_before_swap = GL_FALSE;

19948 GLboolean __GLXEW_NV_float_buffer = GL_FALSE;

19949 GLboolean __GLXEW_NV_multisample_coverage = GL_FALSE;

19950 GLboolean __GLXEW_NV_present_video = GL_FALSE;

19951 GLboolean __GLXEW_NV_robustness_video_memory_purge = GL_FALSE;

19952 GLboolean __GLXEW_NV_swap_group = GL_FALSE;

19953 GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;

19954 GLboolean __GLXEW_NV_video_capture = GL_FALSE;

19955 GLboolean __GLXEW_NV_video_out = GL_FALSE;

19956 GLboolean __GLXEW_OML_swap_method = GL_FALSE;

19957 GLboolean __GLXEW_OML_sync_control = GL_FALSE;

19958 GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;

19959 GLboolean __GLXEW_SGIS_color_range = GL_FALSE;

19960 GLboolean __GLXEW_SGIS_multisample = GL_FALSE;

19961 GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;

19962 GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;

19963 GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE;

19964 GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;

19965 GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;

19966 GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;

19967 GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;

19968 GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;

19969 GLboolean __GLXEW_SGI_cushion = GL_FALSE;

19970 GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;

19971 GLboolean __GLXEW_SGI_swap_control = GL_FALSE;

19972 GLboolean __GLXEW_SGI_video_sync = GL_FALSE;

19973 GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;

19974 GLboolean __GLXEW_SUN_video_resize = GL_FALSE;

19975 #ifdef GLX_VERSION_1_2

19976

19977 static GLboolean _glewInit_GLX_VERSION_1_2 ()

19978 {

19979 GLboolean r = GL_FALSE;

19980

19981 r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;

19982

19983 return r;

19984 }

19985

19986 #endif /* GLX_VERSION_1_2 */

19987

19988 #ifdef GLX_VERSION_1_3

19989

19990 static GLboolean _glewInit_GLX_VERSION_1_3 ()

19991 {

19992 GLboolean r = GL_FALSE;

19993

19994 r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;

19995 r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;

19996 r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;

19997 r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;

19998 r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;

19999 r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;

20000 r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;

20001 r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;

20002 r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;

20003 r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;

20004 r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;

20005 r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;

20006 r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;

20007 r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;

20008 r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;

20009 r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;

20010 r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;

20011

20012 return r;

20013 }

20014

20015 #endif /* GLX_VERSION_1_3 */

20016

20017 #ifdef GLX_AMD_gpu_association

20018

20019 static GLboolean _glewInit_GLX_AMD_gpu_association ()

20020 {

20021 GLboolean r = GL_FALSE;

20022

20023 r = ((glXBlitContextFramebufferAMD = (PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"glXBlitContextFramebufferAMD")) == NULL) || r;

20024 r = ((glXCreateAssociatedContextAMD = (PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXCreateAssociatedContextAMD")) == NULL) || r;

20025 r = ((glXCreateAssociatedContextAttribsAMD = (PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"glXCreateAssociatedContextAttribsAMD")) == NULL) || r;

20026 r = ((glXDeleteAssociatedContextAMD = (PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXDeleteAssociatedContextAMD")) == NULL) || r;

20027 r = ((glXGetContextGPUIDAMD = (PFNGLXGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetContextGPUIDAMD")) == NULL) || r;

20028 r = ((glXGetCurrentAssociatedContextAMD = (PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentAssociatedContextAMD")) == NULL) || r;

20029 r = ((glXGetGPUIDsAMD = (PFNGLXGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetGPUIDsAMD")) == NULL) || r;

20030 r = ((glXGetGPUInfoAMD = (PFNGLXGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetGPUInfoAMD")) == NULL) || r;

20031 r = ((glXMakeAssociatedContextCurrentAMD = (PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"glXMakeAssociatedContextCurrentAMD")) == NULL) || r;

20032

20033 return r;

20034 }

20035

20036 #endif /* GLX_AMD_gpu_association */

20037

20038 #ifdef GLX_ARB_create_context

20039

20040 static GLboolean _glewInit_GLX_ARB_create_context ()

20041 {

20042 GLboolean r = GL_FALSE;

20043

20044 r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r;

20045

20046 return r;

20047 }

20048

20049 #endif /* GLX_ARB_create_context */

20050

20051 #ifdef GLX_ATI_render_texture

20052

20053 static GLboolean _glewInit_GLX_ATI_render_texture ()

20054 {

20055 GLboolean r = GL_FALSE;

20056

20057 r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;

20058 r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;

20059 r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;

20060

20061 return r;

20062 }

20063

20064 #endif /* GLX_ATI_render_texture */

20065

20066 #ifdef GLX_EXT_import_context

20067

20068 static GLboolean _glewInit_GLX_EXT_import_context ()

20069 {

20070 GLboolean r = GL_FALSE;

20071

20072 r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;

20073 r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;

20074 r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;

20075 r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;

20076

20077 return r;

20078 }

20079

20080 #endif /* GLX_EXT_import_context */

20081

20082 #ifdef GLX_EXT_swap_control

20083

20084 static GLboolean _glewInit_GLX_EXT_swap_control ()

20085 {

20086 GLboolean r = GL_FALSE;

20087

20088 r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r;

20089

20090 return r;

20091 }

20092

20093 #endif /* GLX_EXT_swap_control */

20094

20095 #ifdef GLX_EXT_texture_from_pixmap

20096

20097 static GLboolean _glewInit_GLX_EXT_texture_from_pixmap ()

20098 {

20099 GLboolean r = GL_FALSE;

20100

20101 r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r;

20102 r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r;

20103

20104 return r;

20105 }

20106

20107 #endif /* GLX_EXT_texture_from_pixmap */

20108

20109 #ifdef GLX_MESA_agp_offset

20110

20111 static GLboolean _glewInit_GLX_MESA_agp_offset ()

20112 {

20113 GLboolean r = GL_FALSE;

20114

20115 r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;

20116

20117 return r;

20118 }

20119

20120 #endif /* GLX_MESA_agp_offset */

20121

20122 #ifdef GLX_MESA_copy_sub_buffer

20123

20124 static GLboolean _glewInit_GLX_MESA_copy_sub_buffer ()

20125 {

20126 GLboolean r = GL_FALSE;

20127

20128 r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;

20129

20130 return r;

20131 }

20132

20133 #endif /* GLX_MESA_copy_sub_buffer */

20134

20135 #ifdef GLX_MESA_pixmap_colormap

20136

20137 static GLboolean _glewInit_GLX_MESA_pixmap_colormap ()

20138 {

20139 GLboolean r = GL_FALSE;

20140

20141 r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;

20142

20143 return r;

20144 }

20145

20146 #endif /* GLX_MESA_pixmap_colormap */

20147

20148 #ifdef GLX_MESA_query_renderer

20149

20150 static GLboolean _glewInit_GLX_MESA_query_renderer ()

20151 {

20152 GLboolean r = GL_FALSE;

20153

20154 r = ((glXQueryCurrentRendererIntegerMESA = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryCurrentRendererIntegerMESA")) == NULL) || r;

20155 r = ((glXQueryCurrentRendererStringMESA = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryCurrentRendererStringMESA")) == NULL) || r;

20156 r = ((glXQueryRendererIntegerMESA = (PFNGLXQUERYRENDERERINTEGERMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryRendererIntegerMESA")) == NULL) || r;

20157 r = ((glXQueryRendererStringMESA = (PFNGLXQUERYRENDERERSTRINGMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryRendererStringMESA")) == NULL) || r;

20158

20159 return r;

20160 }

20161

20162 #endif /* GLX_MESA_query_renderer */

20163

20164 #ifdef GLX_MESA_release_buffers

20165

20166 static GLboolean _glewInit_GLX_MESA_release_buffers ()

20167 {

20168 GLboolean r = GL_FALSE;

20169

20170 r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;

20171

20172 return r;

20173 }

20174

20175 #endif /* GLX_MESA_release_buffers */

20176

20177 #ifdef GLX_MESA_set_3dfx_mode

20178

20179 static GLboolean _glewInit_GLX_MESA_set_3dfx_mode ()

20180 {

20181 GLboolean r = GL_FALSE;

20182

20183 r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;

20184

20185 return r;

20186 }

20187

20188 #endif /* GLX_MESA_set_3dfx_mode */

20189

20190 #ifdef GLX_MESA_swap_control

20191

20192 static GLboolean _glewInit_GLX_MESA_swap_control ()

20193 {

20194 GLboolean r = GL_FALSE;

20195

20196 r = ((glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetSwapIntervalMESA")) == NULL) || r;

20197 r = ((glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalMESA")) == NULL) || r;

20198

20199 return r;

20200 }

20201

20202 #endif /* GLX_MESA_swap_control */

20203

20204 #ifdef GLX_NV_copy_buffer

20205

20206 static GLboolean _glewInit_GLX_NV_copy_buffer ()

20207 {

20208 GLboolean r = GL_FALSE;

20209

20210 r = ((glXCopyBufferSubDataNV = (PFNGLXCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyBufferSubDataNV")) == NULL) || r;

20211 r = ((glXNamedCopyBufferSubDataNV = (PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXNamedCopyBufferSubDataNV")) == NULL) || r;

20212

20213 return r;

20214 }

20215

20216 #endif /* GLX_NV_copy_buffer */

20217

20218 #ifdef GLX_NV_copy_image

20219

20220 static GLboolean _glewInit_GLX_NV_copy_image ()

20221 {

20222 GLboolean r = GL_FALSE;

20223

20224 r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r;

20225

20226 return r;

20227 }

20228

20229 #endif /* GLX_NV_copy_image */

20230

20231 #ifdef GLX_NV_delay_before_swap

20232

20233 static GLboolean _glewInit_GLX_NV_delay_before_swap ()

20234 {

20235 GLboolean r = GL_FALSE;

20236

20237 r = ((glXDelayBeforeSwapNV = (PFNGLXDELAYBEFORESWAPNVPROC)glewGetProcAddress((const GLubyte*)"glXDelayBeforeSwapNV")) == NULL) || r;

20238

20239 return r;

20240 }

20241

20242 #endif /* GLX_NV_delay_before_swap */

20243

20244 #ifdef GLX_NV_present_video

20245

20246 static GLboolean _glewInit_GLX_NV_present_video ()

20247 {

20248 GLboolean r = GL_FALSE;

20249

20250 r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;

20251 r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r;

20252

20253 return r;

20254 }

20255

20256 #endif /* GLX_NV_present_video */

20257

20258 #ifdef GLX_NV_swap_group

20259

20260 static GLboolean _glewInit_GLX_NV_swap_group ()

20261 {

20262 GLboolean r = GL_FALSE;

20263

20264 r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r;

20265 r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r;

20266 r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r;

20267 r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r;

20268 r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r;

20269 r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r;

20270

20271 return r;

20272 }

20273

20274 #endif /* GLX_NV_swap_group */

20275

20276 #ifdef GLX_NV_vertex_array_range

20277

20278 static GLboolean _glewInit_GLX_NV_vertex_array_range ()

20279 {

20280 GLboolean r = GL_FALSE;

20281

20282 r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;

20283 r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;

20284

20285 return r;

20286 }

20287

20288 #endif /* GLX_NV_vertex_array_range */

20289

20290 #ifdef GLX_NV_video_capture

20291

20292 static GLboolean _glewInit_GLX_NV_video_capture ()

20293 {

20294 GLboolean r = GL_FALSE;

20295

20296 r = ((glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoCaptureDeviceNV")) == NULL) || r;

20297 r = ((glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoCaptureDevicesNV")) == NULL) || r;

20298 r = ((glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXLockVideoCaptureDeviceNV")) == NULL) || r;

20299 r = ((glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXQueryVideoCaptureDeviceNV")) == NULL) || r;

20300 r = ((glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoCaptureDeviceNV")) == NULL) || r;

20301

20302 return r;

20303 }

20304

20305 #endif /* GLX_NV_video_capture */

20306

20307 #ifdef GLX_NV_video_out

20308

20309 static GLboolean _glewInit_GLX_NV_video_out ()

20310 {

20311 GLboolean r = GL_FALSE;

20312

20313 r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r;

20314 r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r;

20315 r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r;

20316 r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r;

20317 r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r;

20318 r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r;

20319

20320 return r;

20321 }

20322

20323 #endif /* GLX_NV_video_out */

20324

20325 #ifdef GLX_OML_sync_control

20326

20327 static GLboolean _glewInit_GLX_OML_sync_control ()

20328 {

20329 GLboolean r = GL_FALSE;

20330

20331 r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;

20332 r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;

20333 r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;

20334 r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;

20335 r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;

20336

20337 return r;

20338 }

20339

20340 #endif /* GLX_OML_sync_control */

20341

20342 #ifdef GLX_SGIX_fbconfig

20343

20344 static GLboolean _glewInit_GLX_SGIX_fbconfig ()

20345 {

20346 GLboolean r = GL_FALSE;

20347

20348 r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;

20349 r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;

20350 r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;

20351 r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;

20352 r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;

20353 r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;

20354

20355 return r;

20356 }

20357

20358 #endif /* GLX_SGIX_fbconfig */

20359

20360 #ifdef GLX_SGIX_hyperpipe

20361

20362 static GLboolean _glewInit_GLX_SGIX_hyperpipe ()

20363 {

20364 GLboolean r = GL_FALSE;

20365

20366 r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r;

20367 r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r;

20368 r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r;

20369 r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r;

20370 r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r;

20371 r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r;

20372 r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r;

20373 r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r;

20374

20375 return r;

20376 }

20377

20378 #endif /* GLX_SGIX_hyperpipe */

20379

20380 #ifdef GLX_SGIX_pbuffer

20381

20382 static GLboolean _glewInit_GLX_SGIX_pbuffer ()

20383 {

20384 GLboolean r = GL_FALSE;

20385

20386 r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;

20387 r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;

20388 r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;

20389 r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;

20390 r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;

20391

20392 return r;

20393 }

20394

20395 #endif /* GLX_SGIX_pbuffer */

20396

20397 #ifdef GLX_SGIX_swap_barrier

20398

20399 static GLboolean _glewInit_GLX_SGIX_swap_barrier ()

20400 {

20401 GLboolean r = GL_FALSE;

20402

20403 r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;

20404 r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;

20405

20406 return r;

20407 }

20408

20409 #endif /* GLX_SGIX_swap_barrier */

20410

20411 #ifdef GLX_SGIX_swap_group

20412

20413 static GLboolean _glewInit_GLX_SGIX_swap_group ()

20414 {

20415 GLboolean r = GL_FALSE;

20416

20417 r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;

20418

20419 return r;

20420 }

20421

20422 #endif /* GLX_SGIX_swap_group */

20423

20424 #ifdef GLX_SGIX_video_resize

20425

20426 static GLboolean _glewInit_GLX_SGIX_video_resize ()

20427 {

20428 GLboolean r = GL_FALSE;

20429

20430 r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;

20431 r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;

20432 r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;

20433 r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;

20434 r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;

20435

20436 return r;

20437 }

20438

20439 #endif /* GLX_SGIX_video_resize */

20440

20441 #ifdef GLX_SGI_cushion

20442

20443 static GLboolean _glewInit_GLX_SGI_cushion ()

20444 {

20445 GLboolean r = GL_FALSE;

20446

20447 r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;

20448

20449 return r;

20450 }

20451

20452 #endif /* GLX_SGI_cushion */

20453

20454 #ifdef GLX_SGI_make_current_read

20455

20456 static GLboolean _glewInit_GLX_SGI_make_current_read ()

20457 {

20458 GLboolean r = GL_FALSE;

20459

20460 r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;

20461 r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;

20462

20463 return r;

20464 }

20465

20466 #endif /* GLX_SGI_make_current_read */

20467

20468 #ifdef GLX_SGI_swap_control

20469

20470 static GLboolean _glewInit_GLX_SGI_swap_control ()

20471 {

20472 GLboolean r = GL_FALSE;

20473

20474 r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;

20475

20476 return r;

20477 }

20478

20479 #endif /* GLX_SGI_swap_control */

20480

20481 #ifdef GLX_SGI_video_sync

20482

20483 static GLboolean _glewInit_GLX_SGI_video_sync ()

20484 {

20485 GLboolean r = GL_FALSE;

20486

20487 r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;

20488 r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;

20489

20490 return r;

20491 }

20492

20493 #endif /* GLX_SGI_video_sync */

20494

20495 #ifdef GLX_SUN_get_transparent_index

20496

20497 static GLboolean _glewInit_GLX_SUN_get_transparent_index ()

20498 {

20499 GLboolean r = GL_FALSE;

20500

20501 r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;

20502

20503 return r;

20504 }

20505

20506 #endif /* GLX_SUN_get_transparent_index */

20507

20508 #ifdef GLX_SUN_video_resize

20509

20510 static GLboolean _glewInit_GLX_SUN_video_resize ()

20511 {

20512 GLboolean r = GL_FALSE;

20513

20514 r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;

20515 r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;

20516

20517 return r;

20518 }

20519

20520 #endif /* GLX_SUN_video_resize */

20521

20522 /* ------------------------------------------------------------------------ */

20523

20524 GLboolean glxewGetExtension (const char* name)

20525 {

20526 const GLubyte* start;

20527 const GLubyte* end;

20528

20529 if (glXGetCurrentDisplay == NULL) return GL_FALSE;

20530 start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);

20531 if (0 == start) return GL_FALSE;

20532 end = start + _glewStrLen(start);

20533 return _glewSearchExtension(name, start, end);

20534 }

20535

20536 GLenum glxewInit ()

20537 {

20538 Display* display;

20539 int major, minor;

20540 const GLubyte* extStart;

20541 const GLubyte* extEnd;

20542 /* initialize core GLX 1.2 */

20543 if (_glewInit_GLX_VERSION_1_2()) return GLEW_ERROR_GLX_VERSION_11_ONLY;

20544 /* check for a display */

20545 display = glXGetCurrentDisplay();

20546 if (display == NULL) return GLEW_ERROR_NO_GLX_DISPLAY;

20547 /* initialize flags */

20548 GLXEW_VERSION_1_0 = GL_TRUE;

20549 GLXEW_VERSION_1_1 = GL_TRUE;

20550 GLXEW_VERSION_1_2 = GL_TRUE;

20551 GLXEW_VERSION_1_3 = GL_TRUE;

20552 GLXEW_VERSION_1_4 = GL_TRUE;

20553 /* query GLX version */

20554 glXQueryVersion(display, &major, &minor);

20555 if (major == 1 && minor <= 3)

20556 {

20557 switch (minor)

20558 {

20559 case 3:

20560 GLXEW_VERSION_1_4 = GL_FALSE;

20561 break;

20562 case 2:

20563 GLXEW_VERSION_1_4 = GL_FALSE;

20564 GLXEW_VERSION_1_3 = GL_FALSE;

20565 break;

20566 default:

20567 return GLEW_ERROR_GLX_VERSION_11_ONLY;

20568 break;

20569 }

20570 }

20571 /* query GLX extension string */

20572 extStart = 0;

20573 if (glXGetCurrentDisplay != NULL)

20574 extStart = (const GLubyte*)glXGetClientString(display, GLX_EXTENSIONS);

20575 if (extStart == 0)

20576 extStart = (const GLubyte *)"";

20577 extEnd = extStart + _glewStrLen(extStart);

20578 /* initialize extensions */

20579 #ifdef GLX_VERSION_1_3

20580 if (glewExperimental || GLXEW_VERSION_1_3) GLXEW_VERSION_1_3 = !_glewInit_GLX_VERSION_1_3();

20581 #endif /* GLX_VERSION_1_3 */

20582 #ifdef GLX_3DFX_multisample

20583 GLXEW_3DFX_multisample = _glewSearchExtension("GLX_3DFX_multisample", extStart, extEnd);

20584 #endif /* GLX_3DFX_multisample */

20585 #ifdef GLX_AMD_gpu_association

20586 GLXEW_AMD_gpu_association = _glewSearchExtension("GLX_AMD_gpu_association", extStart, extEnd);

20587 if (glewExperimental || GLXEW_AMD_gpu_association) GLXEW_AMD_gpu_association = !_glewInit_GLX_AMD_gpu_association();

20588 #endif /* GLX_AMD_gpu_association */

20589 #ifdef GLX_ARB_context_flush_control

20590 GLXEW_ARB_context_flush_control = _glewSearchExtension("GLX_ARB_context_flush_control", extStart, extEnd);

20591 #endif /* GLX_ARB_context_flush_control */

20592 #ifdef GLX_ARB_create_context

20593 GLXEW_ARB_create_context = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd);

20594 if (glewExperimental || GLXEW_ARB_create_context) GLXEW_ARB_create_context = !_glewInit_GLX_ARB_create_context();

20595 #endif /* GLX_ARB_create_context */

20596 #ifdef GLX_ARB_create_context_no_error

20597 GLXEW_ARB_create_context_no_error = _glewSearchExtension("GLX_ARB_create_context_no_error", extStart, extEnd);

20598 #endif /* GLX_ARB_create_context_no_error */

20599 #ifdef GLX_ARB_create_context_profile

20600 GLXEW_ARB_create_context_profile = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd);

20601 #endif /* GLX_ARB_create_context_profile */

20602 #ifdef GLX_ARB_create_context_robustness

20603 GLXEW_ARB_create_context_robustness = _glewSearchExtension("GLX_ARB_create_context_robustness", extStart, extEnd);

20604 #endif /* GLX_ARB_create_context_robustness */

20605 #ifdef GLX_ARB_fbconfig_float

20606 GLXEW_ARB_fbconfig_float = _glewSearchExtension("GLX_ARB_fbconfig_float", extStart, extEnd);

20607 #endif /* GLX_ARB_fbconfig_float */

20608 #ifdef GLX_ARB_framebuffer_sRGB

20609 GLXEW_ARB_framebuffer_sRGB = _glewSearchExtension("GLX_ARB_framebuffer_sRGB", extStart, extEnd);

20610 #endif /* GLX_ARB_framebuffer_sRGB */

20611 #ifdef GLX_ARB_get_proc_address

20612 GLXEW_ARB_get_proc_address = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd);

20613 #endif /* GLX_ARB_get_proc_address */

20614 #ifdef GLX_ARB_multisample

20615 GLXEW_ARB_multisample = _glewSearchExtension("GLX_ARB_multisample", extStart, extEnd);

20616 #endif /* GLX_ARB_multisample */

20617 #ifdef GLX_ARB_robustness_application_isolation

20618 GLXEW_ARB_robustness_application_isolation = _glewSearchExtension("GLX_ARB_robustness_application_isolation", extStart, extEnd);

20619 #endif /* GLX_ARB_robustness_application_isolation */

20620 #ifdef GLX_ARB_robustness_share_group_isolation

20621 GLXEW_ARB_robustness_share_group_isolation = _glewSearchExtension("GLX_ARB_robustness_share_group_isolation", extStart, extEnd);

20622 #endif /* GLX_ARB_robustness_share_group_isolation */

20623 #ifdef GLX_ARB_vertex_buffer_object

20624 GLXEW_ARB_vertex_buffer_object = _glewSearchExtension("GLX_ARB_vertex_buffer_object", extStart, extEnd);

20625 #endif /* GLX_ARB_vertex_buffer_object */

20626 #ifdef GLX_ATI_pixel_format_float

20627 GLXEW_ATI_pixel_format_float = _glewSearchExtension("GLX_ATI_pixel_format_float", extStart, extEnd);

20628 #endif /* GLX_ATI_pixel_format_float */

20629 #ifdef GLX_ATI_render_texture

20630 GLXEW_ATI_render_texture = _glewSearchExtension("GLX_ATI_render_texture", extStart, extEnd);

20631 if (glewExperimental || GLXEW_ATI_render_texture) GLXEW_ATI_render_texture = !_glewInit_GLX_ATI_render_texture();

20632 #endif /* GLX_ATI_render_texture */

20633 #ifdef GLX_EXT_buffer_age

20634 GLXEW_EXT_buffer_age = _glewSearchExtension("GLX_EXT_buffer_age", extStart, extEnd);

20635 #endif /* GLX_EXT_buffer_age */

20636 #ifdef GLX_EXT_create_context_es2_profile

20637 GLXEW_EXT_create_context_es2_profile = _glewSearchExtension("GLX_EXT_create_context_es2_profile", extStart, extEnd);

20638 #endif /* GLX_EXT_create_context_es2_profile */

20639 #ifdef GLX_EXT_create_context_es_profile

20640 GLXEW_EXT_create_context_es_profile = _glewSearchExtension("GLX_EXT_create_context_es_profile", extStart, extEnd);

20641 #endif /* GLX_EXT_create_context_es_profile */

20642 #ifdef GLX_EXT_fbconfig_packed_float

20643 GLXEW_EXT_fbconfig_packed_float = _glewSearchExtension("GLX_EXT_fbconfig_packed_float", extStart, extEnd);

20644 #endif /* GLX_EXT_fbconfig_packed_float */

20645 #ifdef GLX_EXT_framebuffer_sRGB

20646 GLXEW_EXT_framebuffer_sRGB = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd);

20647 #endif /* GLX_EXT_framebuffer_sRGB */

20648 #ifdef GLX_EXT_import_context

20649 GLXEW_EXT_import_context = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd);

20650 if (glewExperimental || GLXEW_EXT_import_context) GLXEW_EXT_import_context = !_glewInit_GLX_EXT_import_context();

20651 #endif /* GLX_EXT_import_context */

20652 #ifdef GLX_EXT_libglvnd

20653 GLXEW_EXT_libglvnd = _glewSearchExtension("GLX_EXT_libglvnd", extStart, extEnd);

20654 #endif /* GLX_EXT_libglvnd */

20655 #ifdef GLX_EXT_scene_marker

20656 GLXEW_EXT_scene_marker = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd);

20657 #endif /* GLX_EXT_scene_marker */

20658 #ifdef GLX_EXT_stereo_tree

20659 GLXEW_EXT_stereo_tree = _glewSearchExtension("GLX_EXT_stereo_tree", extStart, extEnd);

20660 #endif /* GLX_EXT_stereo_tree */

20661 #ifdef GLX_EXT_swap_control

20662 GLXEW_EXT_swap_control = _glewSearchExtension("GLX_EXT_swap_control", extStart, extEnd);

20663 if (glewExperimental || GLXEW_EXT_swap_control) GLXEW_EXT_swap_control = !_glewInit_GLX_EXT_swap_control();

20664 #endif /* GLX_EXT_swap_control */

20665 #ifdef GLX_EXT_swap_control_tear

20666 GLXEW_EXT_swap_control_tear = _glewSearchExtension("GLX_EXT_swap_control_tear", extStart, extEnd);

20667 #endif /* GLX_EXT_swap_control_tear */

20668 #ifdef GLX_EXT_texture_from_pixmap

20669 GLXEW_EXT_texture_from_pixmap = _glewSearchExtension("GLX_EXT_texture_from_pixmap", extStart, extEnd);

20670 if (glewExperimental || GLXEW_EXT_texture_from_pixmap) GLXEW_EXT_texture_from_pixmap = !_glewInit_GLX_EXT_texture_from_pixmap();

20671 #endif /* GLX_EXT_texture_from_pixmap */

20672 #ifdef GLX_EXT_visual_info

20673 GLXEW_EXT_visual_info = _glewSearchExtension("GLX_EXT_visual_info", extStart, extEnd);

20674 #endif /* GLX_EXT_visual_info */

20675 #ifdef GLX_EXT_visual_rating

20676 GLXEW_EXT_visual_rating = _glewSearchExtension("GLX_EXT_visual_rating", extStart, extEnd);

20677 #endif /* GLX_EXT_visual_rating */

20678 #ifdef GLX_INTEL_swap_event

20679 GLXEW_INTEL_swap_event = _glewSearchExtension("GLX_INTEL_swap_event", extStart, extEnd);

20680 #endif /* GLX_INTEL_swap_event */

20681 #ifdef GLX_MESA_agp_offset

20682 GLXEW_MESA_agp_offset = _glewSearchExtension("GLX_MESA_agp_offset", extStart, extEnd);

20683 if (glewExperimental || GLXEW_MESA_agp_offset) GLXEW_MESA_agp_offset = !_glewInit_GLX_MESA_agp_offset();

20684 #endif /* GLX_MESA_agp_offset */

20685 #ifdef GLX_MESA_copy_sub_buffer

20686 GLXEW_MESA_copy_sub_buffer = _glewSearchExtension("GLX_MESA_copy_sub_buffer", extStart, extEnd);

20687 if (glewExperimental || GLXEW_MESA_copy_sub_buffer) GLXEW_MESA_copy_sub_buffer = !_glewInit_GLX_MESA_copy_sub_buffer();

20688 #endif /* GLX_MESA_copy_sub_buffer */

20689 #ifdef GLX_MESA_pixmap_colormap

20690 GLXEW_MESA_pixmap_colormap = _glewSearchExtension("GLX_MESA_pixmap_colormap", extStart, extEnd);

20691 if (glewExperimental || GLXEW_MESA_pixmap_colormap) GLXEW_MESA_pixmap_colormap = !_glewInit_GLX_MESA_pixmap_colormap();

20692 #endif /* GLX_MESA_pixmap_colormap */

20693 #ifdef GLX_MESA_query_renderer

20694 GLXEW_MESA_query_renderer = _glewSearchExtension("GLX_MESA_query_renderer", extStart, extEnd);

20695 if (glewExperimental || GLXEW_MESA_query_renderer) GLXEW_MESA_query_renderer = !_glewInit_GLX_MESA_query_renderer();

20696 #endif /* GLX_MESA_query_renderer */

20697 #ifdef GLX_MESA_release_buffers

20698 GLXEW_MESA_release_buffers = _glewSearchExtension("GLX_MESA_release_buffers", extStart, extEnd);

20699 if (glewExperimental || GLXEW_MESA_release_buffers) GLXEW_MESA_release_buffers = !_glewInit_GLX_MESA_release_buffers();

20700 #endif /* GLX_MESA_release_buffers */

20701 #ifdef GLX_MESA_set_3dfx_mode

20702 GLXEW_MESA_set_3dfx_mode = _glewSearchExtension("GLX_MESA_set_3dfx_mode", extStart, extEnd);

20703 if (glewExperimental || GLXEW_MESA_set_3dfx_mode) GLXEW_MESA_set_3dfx_mode = !_glewInit_GLX_MESA_set_3dfx_mode();

20704 #endif /* GLX_MESA_set_3dfx_mode */

20705 #ifdef GLX_MESA_swap_control

20706 GLXEW_MESA_swap_control = _glewSearchExtension("GLX_MESA_swap_control", extStart, extEnd);

20707 if (glewExperimental || GLXEW_MESA_swap_control) GLXEW_MESA_swap_control = !_glewInit_GLX_MESA_swap_control();

20708 #endif /* GLX_MESA_swap_control */

20709 #ifdef GLX_NV_copy_buffer

20710 GLXEW_NV_copy_buffer = _glewSearchExtension("GLX_NV_copy_buffer", extStart, extEnd);

20711 if (glewExperimental || GLXEW_NV_copy_buffer) GLXEW_NV_copy_buffer = !_glewInit_GLX_NV_copy_buffer();

20712 #endif /* GLX_NV_copy_buffer */

20713 #ifdef GLX_NV_copy_image

20714 GLXEW_NV_copy_image = _glewSearchExtension("GLX_NV_copy_image", extStart, extEnd);

20715 if (glewExperimental || GLXEW_NV_copy_image) GLXEW_NV_copy_image = !_glewInit_GLX_NV_copy_image();

20716 #endif /* GLX_NV_copy_image */

20717 #ifdef GLX_NV_delay_before_swap

20718 GLXEW_NV_delay_before_swap = _glewSearchExtension("GLX_NV_delay_before_swap", extStart, extEnd);

20719 if (glewExperimental || GLXEW_NV_delay_before_swap) GLXEW_NV_delay_before_swap = !_glewInit_GLX_NV_delay_before_swap();

20720 #endif /* GLX_NV_delay_before_swap */

20721 #ifdef GLX_NV_float_buffer

20722 GLXEW_NV_float_buffer = _glewSearchExtension("GLX_NV_float_buffer", extStart, extEnd);

20723 #endif /* GLX_NV_float_buffer */

20724 #ifdef GLX_NV_multisample_coverage

20725 GLXEW_NV_multisample_coverage = _glewSearchExtension("GLX_NV_multisample_coverage", extStart, extEnd);

20726 #endif /* GLX_NV_multisample_coverage */

20727 #ifdef GLX_NV_present_video

20728 GLXEW_NV_present_video = _glewSearchExtension("GLX_NV_present_video", extStart, extEnd);

20729 if (glewExperimental || GLXEW_NV_present_video) GLXEW_NV_present_video = !_glewInit_GLX_NV_present_video();

20730 #endif /* GLX_NV_present_video */

20731 #ifdef GLX_NV_robustness_video_memory_purge

20732 GLXEW_NV_robustness_video_memory_purge = _glewSearchExtension("GLX_NV_robustness_video_memory_purge", extStart, extEnd);

20733 #endif /* GLX_NV_robustness_video_memory_purge */

20734 #ifdef GLX_NV_swap_group

20735 GLXEW_NV_swap_group = _glewSearchExtension("GLX_NV_swap_group", extStart, extEnd);

20736 if (glewExperimental || GLXEW_NV_swap_group) GLXEW_NV_swap_group = !_glewInit_GLX_NV_swap_group();

20737 #endif /* GLX_NV_swap_group */

20738 #ifdef GLX_NV_vertex_array_range

20739 GLXEW_NV_vertex_array_range = _glewSearchExtension("GLX_NV_vertex_array_range", extStart, extEnd);

20740 if (glewExperimental || GLXEW_NV_vertex_array_range) GLXEW_NV_vertex_array_range = !_glewInit_GLX_NV_vertex_array_range();

20741 #endif /* GLX_NV_vertex_array_range */

20742 #ifdef GLX_NV_video_capture

20743 GLXEW_NV_video_capture = _glewSearchExtension("GLX_NV_video_capture", extStart, extEnd);

20744 if (glewExperimental || GLXEW_NV_video_capture) GLXEW_NV_video_capture = !_glewInit_GLX_NV_video_capture();

20745 #endif /* GLX_NV_video_capture */

20746 #ifdef GLX_NV_video_out

20747 GLXEW_NV_video_out = _glewSearchExtension("GLX_NV_video_out", extStart, extEnd);

20748 if (glewExperimental || GLXEW_NV_video_out) GLXEW_NV_video_out = !_glewInit_GLX_NV_video_out();

20749 #endif /* GLX_NV_video_out */

20750 #ifdef GLX_OML_swap_method

20751 GLXEW_OML_swap_method = _glewSearchExtension("GLX_OML_swap_method", extStart, extEnd);

20752 #endif /* GLX_OML_swap_method */

20753 #ifdef GLX_OML_sync_control

20754 GLXEW_OML_sync_control = _glewSearchExtension("GLX_OML_sync_control", extStart, extEnd);

20755 if (glewExperimental || GLXEW_OML_sync_control) GLXEW_OML_sync_control = !_glewInit_GLX_OML_sync_control();

20756 #endif /* GLX_OML_sync_control */

20757 #ifdef GLX_SGIS_blended_overlay

20758 GLXEW_SGIS_blended_overlay = _glewSearchExtension("GLX_SGIS_blended_overlay", extStart, extEnd);

20759 #endif /* GLX_SGIS_blended_overlay */

20760 #ifdef GLX_SGIS_color_range

20761 GLXEW_SGIS_color_range = _glewSearchExtension("GLX_SGIS_color_range", extStart, extEnd);

20762 #endif /* GLX_SGIS_color_range */

20763 #ifdef GLX_SGIS_multisample

20764 GLXEW_SGIS_multisample = _glewSearchExtension("GLX_SGIS_multisample", extStart, extEnd);

20765 #endif /* GLX_SGIS_multisample */

20766 #ifdef GLX_SGIS_shared_multisample

20767 GLXEW_SGIS_shared_multisample = _glewSearchExtension("GLX_SGIS_shared_multisample", extStart, extEnd);

20768 #endif /* GLX_SGIS_shared_multisample */

20769 #ifdef GLX_SGIX_fbconfig

20770 GLXEW_SGIX_fbconfig = _glewSearchExtension("GLX_SGIX_fbconfig", extStart, extEnd);

20771 if (glewExperimental || GLXEW_SGIX_fbconfig) GLXEW_SGIX_fbconfig = !_glewInit_GLX_SGIX_fbconfig();

20772 #endif /* GLX_SGIX_fbconfig */

20773 #ifdef GLX_SGIX_hyperpipe

20774 GLXEW_SGIX_hyperpipe = _glewSearchExtension("GLX_SGIX_hyperpipe", extStart, extEnd);

20775 if (glewExperimental || GLXEW_SGIX_hyperpipe) GLXEW_SGIX_hyperpipe = !_glewInit_GLX_SGIX_hyperpipe();

20776 #endif /* GLX_SGIX_hyperpipe */

20777 #ifdef GLX_SGIX_pbuffer

20778 GLXEW_SGIX_pbuffer = _glewSearchExtension("GLX_SGIX_pbuffer", extStart, extEnd);

20779 if (glewExperimental || GLXEW_SGIX_pbuffer) GLXEW_SGIX_pbuffer = !_glewInit_GLX_SGIX_pbuffer();

20780 #endif /* GLX_SGIX_pbuffer */

20781 #ifdef GLX_SGIX_swap_barrier

20782 GLXEW_SGIX_swap_barrier = _glewSearchExtension("GLX_SGIX_swap_barrier", extStart, extEnd);

20783 if (glewExperimental || GLXEW_SGIX_swap_barrier) GLXEW_SGIX_swap_barrier = !_glewInit_GLX_SGIX_swap_barrier();

20784 #endif /* GLX_SGIX_swap_barrier */

20785 #ifdef GLX_SGIX_swap_group

20786 GLXEW_SGIX_swap_group = _glewSearchExtension("GLX_SGIX_swap_group", extStart, extEnd);

20787 if (glewExperimental || GLXEW_SGIX_swap_group) GLXEW_SGIX_swap_group = !_glewInit_GLX_SGIX_swap_group();

20788 #endif /* GLX_SGIX_swap_group */

20789 #ifdef GLX_SGIX_video_resize

20790 GLXEW_SGIX_video_resize = _glewSearchExtension("GLX_SGIX_video_resize", extStart, extEnd);

20791 if (glewExperimental || GLXEW_SGIX_video_resize) GLXEW_SGIX_video_resize = !_glewInit_GLX_SGIX_video_resize();

20792 #endif /* GLX_SGIX_video_resize */

20793 #ifdef GLX_SGIX_visual_select_group

20794 GLXEW_SGIX_visual_select_group = _glewSearchExtension("GLX_SGIX_visual_select_group", extStart, extEnd);

20795 #endif /* GLX_SGIX_visual_select_group */

20796 #ifdef GLX_SGI_cushion

20797 GLXEW_SGI_cushion = _glewSearchExtension("GLX_SGI_cushion", extStart, extEnd);

20798 if (glewExperimental || GLXEW_SGI_cushion) GLXEW_SGI_cushion = !_glewInit_GLX_SGI_cushion();

20799 #endif /* GLX_SGI_cushion */

20800 #ifdef GLX_SGI_make_current_read

20801 GLXEW_SGI_make_current_read = _glewSearchExtension("GLX_SGI_make_current_read", extStart, extEnd);

20802 if (glewExperimental || GLXEW_SGI_make_current_read) GLXEW_SGI_make_current_read = !_glewInit_GLX_SGI_make_current_read();

20803 #endif /* GLX_SGI_make_current_read */

20804 #ifdef GLX_SGI_swap_control

20805 GLXEW_SGI_swap_control = _glewSearchExtension("GLX_SGI_swap_control", extStart, extEnd);

20806 if (glewExperimental || GLXEW_SGI_swap_control) GLXEW_SGI_swap_control = !_glewInit_GLX_SGI_swap_control();

20807 #endif /* GLX_SGI_swap_control */

20808 #ifdef GLX_SGI_video_sync

20809 GLXEW_SGI_video_sync = _glewSearchExtension("GLX_SGI_video_sync", extStart, extEnd);

20810 if (glewExperimental || GLXEW_SGI_video_sync) GLXEW_SGI_video_sync = !_glewInit_GLX_SGI_video_sync();

20811 #endif /* GLX_SGI_video_sync */

20812 #ifdef GLX_SUN_get_transparent_index

20813 GLXEW_SUN_get_transparent_index = _glewSearchExtension("GLX_SUN_get_transparent_index", extStart, extEnd);

20814 if (glewExperimental || GLXEW_SUN_get_transparent_index) GLXEW_SUN_get_transparent_index = !_glewInit_GLX_SUN_get_transparent_index();

20815 #endif /* GLX_SUN_get_transparent_index */

20816 #ifdef GLX_SUN_video_resize

20817 GLXEW_SUN_video_resize = _glewSearchExtension("GLX_SUN_video_resize", extStart, extEnd);

20818 if (glewExperimental || GLXEW_SUN_video_resize) GLXEW_SUN_video_resize = !_glewInit_GLX_SUN_video_resize();

20819 #endif /* GLX_SUN_video_resize */

20820

20821 return GLEW_OK;

20822 }

20823

20824 #endif /* !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) */

20825

20826 /* ------------------------------------------------------------------------ */

20827

20828 const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error)

20829 {

20830 static const GLubyte* _glewErrorString[] =

20831 {

20832 (const GLubyte*)"No error",

20833 (const GLubyte*)"Missing GL version",

20834 (const GLubyte*)"GL 1.1 and up are not supported",

20835 (const GLubyte*)"GLX 1.2 and up are not supported",

20836 (const GLubyte*)"Unknown error"

20837 };

20838 const size_t max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;

20839 return _glewErrorString[(size_t)error > max_error ? max_error : (size_t)error];

20840 }

20841

20842 const GLubyte * GLEWAPIENTRY glewGetString (GLenum name)

20843 {

20844 static const GLubyte* _glewString[] =

20845 {

20846 (const GLubyte*)NULL,

20847 (const GLubyte*)"2.1.0",

20848 (const GLubyte*)"2",

20849 (const GLubyte*)"1",

20850 (const GLubyte*)"0"

20851 };

20852 const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;

20853 return _glewString[(size_t)name > max_string ? 0 : (size_t)name];

20854 }

20855

20856 /* ------------------------------------------------------------------------ */

20857

20858 GLboolean glewExperimental = GL_FALSE;

20859

20860 GLenum GLEWAPIENTRY glewInit (void)

20861 {

20862 GLenum r;

20863 #if defined(GLEW_EGL)

20864 PFNEGLGETCURRENTDISPLAYPROC getCurrentDisplay = NULL;

20865 #endif

20866 r = glewContextInit();

20867 if ( r != 0 ) return r;

20868 #if defined(GLEW_EGL)

20869 getCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) glewGetProcAddress("eglGetCurrentDisplay");

20870 return eglewInit(getCurrentDisplay());

20871 #elif defined(GLEW_OSMESA) || defined(__ANDROID__) || defined(__native_client__) || defined(__HAIKU__)

20872 return r;

20873 #elif defined(_WIN32)

20874 return wglewInit();

20875 #elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

20876 return glxewInit();

20877 #else

20878 return r;

20879 #endif /* _WIN32 */

20880 }

20881

20882 #if defined(_WIN32) && defined(GLEW_BUILD) && defined(__GNUC__)

20883 /* GCC requires a DLL entry point even without any standard library included. */

20884 /* Types extracted from windows.h to avoid polluting the rest of the file. */

20885 int __stdcall DllMainCRTStartup(void* instance, unsigned reason, void* reserved)

20886 {

20887 (void) instance;

20888 (void) reason;

20889 (void) reserved;

20890 return 1;

20891 }

20892 #endif

20893 GLboolean GLEWAPIENTRY glewIsSupported (const char* name)

20894 {

20895 const GLubyte* pos = (const GLubyte*)name;

20896 GLuint len = _glewStrLen(pos);

20897 GLboolean ret = GL_TRUE;

20898 while (ret && len > 0)

20899 {

20900 if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))

20901 {

20902 if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

20903 {

20904 #ifdef GL_VERSION_1_2

20905 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

20906 {

20907 ret = GLEW_VERSION_1_2;

20908 continue;

20909 }

20910 #endif

20911 #ifdef GL_VERSION_1_2_1

20912 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5))

20913 {

20914 ret = GLEW_VERSION_1_2_1;

20915 continue;

20916 }

20917 #endif

20918 #ifdef GL_VERSION_1_3

20919 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

20920 {

20921 ret = GLEW_VERSION_1_3;

20922 continue;

20923 }

20924 #endif

20925 #ifdef GL_VERSION_1_4

20926 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

20927 {

20928 ret = GLEW_VERSION_1_4;

20929 continue;

20930 }

20931 #endif

20932 #ifdef GL_VERSION_1_5

20933 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))

20934 {

20935 ret = GLEW_VERSION_1_5;

20936 continue;

20937 }

20938 #endif

20939 #ifdef GL_VERSION_2_0

20940 if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))

20941 {

20942 ret = GLEW_VERSION_2_0;

20943 continue;

20944 }

20945 #endif

20946 #ifdef GL_VERSION_2_1

20947 if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3))

20948 {

20949 ret = GLEW_VERSION_2_1;

20950 continue;

20951 }

20952 #endif

20953 #ifdef GL_VERSION_3_0

20954 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3))

20955 {

20956 ret = GLEW_VERSION_3_0;

20957 continue;

20958 }

20959 #endif

20960 #ifdef GL_VERSION_3_1

20961 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3))

20962 {

20963 ret = GLEW_VERSION_3_1;

20964 continue;

20965 }

20966 #endif

20967 #ifdef GL_VERSION_3_2

20968 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3))

20969 {

20970 ret = GLEW_VERSION_3_2;

20971 continue;

20972 }

20973 #endif

20974 #ifdef GL_VERSION_3_3

20975 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3))

20976 {

20977 ret = GLEW_VERSION_3_3;

20978 continue;

20979 }

20980 #endif

20981 #ifdef GL_VERSION_4_0

20982 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3))

20983 {

20984 ret = GLEW_VERSION_4_0;

20985 continue;

20986 }

20987 #endif

20988 #ifdef GL_VERSION_4_1

20989 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3))

20990 {

20991 ret = GLEW_VERSION_4_1;

20992 continue;

20993 }

20994 #endif

20995 #ifdef GL_VERSION_4_2

20996 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3))

20997 {

20998 ret = GLEW_VERSION_4_2;

20999 continue;

21000 }

21001 #endif

21002 #ifdef GL_VERSION_4_3

21003 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_3", 3))

21004 {

21005 ret = GLEW_VERSION_4_3;

21006 continue;

21007 }

21008 #endif

21009 #ifdef GL_VERSION_4_4

21010 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_4", 3))

21011 {

21012 ret = GLEW_VERSION_4_4;

21013 continue;

21014 }

21015 #endif

21016 #ifdef GL_VERSION_4_5

21017 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_5", 3))

21018 {

21019 ret = GLEW_VERSION_4_5;

21020 continue;

21021 }

21022 #endif

21023 #ifdef GL_VERSION_4_6

21024 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_6", 3))

21025 {

21026 ret = GLEW_VERSION_4_6;

21027 continue;

21028 }

21029 #endif

21030 }

21031 if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

21032 {

21033 #ifdef GL_3DFX_multisample

21034 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

21035 {

21036 ret = GLEW_3DFX_multisample;

21037 continue;

21038 }

21039 #endif

21040 #ifdef GL_3DFX_tbuffer

21041 if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))

21042 {

21043 ret = GLEW_3DFX_tbuffer;

21044 continue;

21045 }

21046 #endif

21047 #ifdef GL_3DFX_texture_compression_FXT1

21048 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))

21049 {

21050 ret = GLEW_3DFX_texture_compression_FXT1;

21051 continue;

21052 }

21053 #endif

21054 }

21055 if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))

21056 {

21057 #ifdef GL_AMD_blend_minmax_factor

21058 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19))

21059 {

21060 ret = GLEW_AMD_blend_minmax_factor;

21061 continue;

21062 }

21063 #endif

21064 #ifdef GL_AMD_compressed_3DC_texture

21065 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_3DC_texture", 22))

21066 {

21067 ret = GLEW_AMD_compressed_3DC_texture;

21068 continue;

21069 }

21070 #endif

21071 #ifdef GL_AMD_compressed_ATC_texture

21072 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_ATC_texture", 22))

21073 {

21074 ret = GLEW_AMD_compressed_ATC_texture;

21075 continue;

21076 }

21077 #endif

21078 #ifdef GL_AMD_conservative_depth

21079 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))

21080 {

21081 ret = GLEW_AMD_conservative_depth;

21082 continue;

21083 }

21084 #endif

21085 #ifdef GL_AMD_debug_output

21086 if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))

21087 {

21088 ret = GLEW_AMD_debug_output;

21089 continue;

21090 }

21091 #endif

21092 #ifdef GL_AMD_depth_clamp_separate

21093 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp_separate", 20))

21094 {

21095 ret = GLEW_AMD_depth_clamp_separate;

21096 continue;

21097 }

21098 #endif

21099 #ifdef GL_AMD_draw_buffers_blend

21100 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))

21101 {

21102 ret = GLEW_AMD_draw_buffers_blend;

21103 continue;

21104 }

21105 #endif

21106 #ifdef GL_AMD_framebuffer_sample_positions

21107 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sample_positions", 28))

21108 {

21109 ret = GLEW_AMD_framebuffer_sample_positions;

21110 continue;

21111 }

21112 #endif

21113 #ifdef GL_AMD_gcn_shader

21114 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gcn_shader", 10))

21115 {

21116 ret = GLEW_AMD_gcn_shader;

21117 continue;

21118 }

21119 #endif

21120 #ifdef GL_AMD_gpu_shader_half_float

21121 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_half_float", 21))

21122 {

21123 ret = GLEW_AMD_gpu_shader_half_float;

21124 continue;

21125 }

21126 #endif

21127 #ifdef GL_AMD_gpu_shader_int16

21128 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int16", 16))

21129 {

21130 ret = GLEW_AMD_gpu_shader_int16;

21131 continue;

21132 }

21133 #endif

21134 #ifdef GL_AMD_gpu_shader_int64

21135 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int64", 16))

21136 {

21137 ret = GLEW_AMD_gpu_shader_int64;

21138 continue;

21139 }

21140 #endif

21141 #ifdef GL_AMD_interleaved_elements

21142 if (_glewStrSame3(&pos, &len, (const GLubyte*)"interleaved_elements", 20))

21143 {

21144 ret = GLEW_AMD_interleaved_elements;

21145 continue;

21146 }

21147 #endif

21148 #ifdef GL_AMD_multi_draw_indirect

21149 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))

21150 {

21151 ret = GLEW_AMD_multi_draw_indirect;

21152 continue;

21153 }

21154 #endif

21155 #ifdef GL_AMD_name_gen_delete

21156 if (_glewStrSame3(&pos, &len, (const GLubyte*)"name_gen_delete", 15))

21157 {

21158 ret = GLEW_AMD_name_gen_delete;

21159 continue;

21160 }

21161 #endif

21162 #ifdef GL_AMD_occlusion_query_event

21163 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query_event", 21))

21164 {

21165 ret = GLEW_AMD_occlusion_query_event;

21166 continue;

21167 }

21168 #endif

21169 #ifdef GL_AMD_performance_monitor

21170 if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19))

21171 {

21172 ret = GLEW_AMD_performance_monitor;

21173 continue;

21174 }

21175 #endif

21176 #ifdef GL_AMD_pinned_memory

21177 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pinned_memory", 13))

21178 {

21179 ret = GLEW_AMD_pinned_memory;

21180 continue;

21181 }

21182 #endif

21183 #ifdef GL_AMD_program_binary_Z400

21184 if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary_Z400", 19))

21185 {

21186 ret = GLEW_AMD_program_binary_Z400;

21187 continue;

21188 }

21189 #endif

21190 #ifdef GL_AMD_query_buffer_object

21191 if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19))

21192 {

21193 ret = GLEW_AMD_query_buffer_object;

21194 continue;

21195 }

21196 #endif

21197 #ifdef GL_AMD_sample_positions

21198 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_positions", 16))

21199 {

21200 ret = GLEW_AMD_sample_positions;

21201 continue;

21202 }

21203 #endif

21204 #ifdef GL_AMD_seamless_cubemap_per_texture

21205 if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))

21206 {

21207 ret = GLEW_AMD_seamless_cubemap_per_texture;

21208 continue;

21209 }

21210 #endif

21211 #ifdef GL_AMD_shader_atomic_counter_ops

21212 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counter_ops", 25))

21213 {

21214 ret = GLEW_AMD_shader_atomic_counter_ops;

21215 continue;

21216 }

21217 #endif

21218 #ifdef GL_AMD_shader_ballot

21219 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_ballot", 13))

21220 {

21221 ret = GLEW_AMD_shader_ballot;

21222 continue;

21223 }

21224 #endif

21225 #ifdef GL_AMD_shader_explicit_vertex_parameter

21226 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_explicit_vertex_parameter", 32))

21227 {

21228 ret = GLEW_AMD_shader_explicit_vertex_parameter;

21229 continue;

21230 }

21231 #endif

21232 #ifdef GL_AMD_shader_stencil_export

21233 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))

21234 {

21235 ret = GLEW_AMD_shader_stencil_export;

21236 continue;

21237 }

21238 #endif

21239 #ifdef GL_AMD_shader_stencil_value_export

21240 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_value_export", 27))

21241 {

21242 ret = GLEW_AMD_shader_stencil_value_export;

21243 continue;

21244 }

21245 #endif

21246 #ifdef GL_AMD_shader_trinary_minmax

21247 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_trinary_minmax", 21))

21248 {

21249 ret = GLEW_AMD_shader_trinary_minmax;

21250 continue;

21251 }

21252 #endif

21253 #ifdef GL_AMD_sparse_texture

21254 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14))

21255 {

21256 ret = GLEW_AMD_sparse_texture;

21257 continue;

21258 }

21259 #endif

21260 #ifdef GL_AMD_stencil_operation_extended

21261 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_operation_extended", 26))

21262 {

21263 ret = GLEW_AMD_stencil_operation_extended;

21264 continue;

21265 }

21266 #endif

21267 #ifdef GL_AMD_texture_gather_bias_lod

21268 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather_bias_lod", 23))

21269 {

21270 ret = GLEW_AMD_texture_gather_bias_lod;

21271 continue;

21272 }

21273 #endif

21274 #ifdef GL_AMD_texture_texture4

21275 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16))

21276 {

21277 ret = GLEW_AMD_texture_texture4;

21278 continue;

21279 }

21280 #endif

21281 #ifdef GL_AMD_transform_feedback3_lines_triangles

21282 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3_lines_triangles", 35))

21283 {

21284 ret = GLEW_AMD_transform_feedback3_lines_triangles;

21285 continue;

21286 }

21287 #endif

21288 #ifdef GL_AMD_transform_feedback4

21289 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback4", 19))

21290 {

21291 ret = GLEW_AMD_transform_feedback4;

21292 continue;

21293 }

21294 #endif

21295 #ifdef GL_AMD_vertex_shader_layer

21296 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_layer", 19))

21297 {

21298 ret = GLEW_AMD_vertex_shader_layer;

21299 continue;

21300 }

21301 #endif

21302 #ifdef GL_AMD_vertex_shader_tessellator

21303 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25))

21304 {

21305 ret = GLEW_AMD_vertex_shader_tessellator;

21306 continue;

21307 }

21308 #endif

21309 #ifdef GL_AMD_vertex_shader_viewport_index

21310 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_viewport_index", 28))

21311 {

21312 ret = GLEW_AMD_vertex_shader_viewport_index;

21313 continue;

21314 }

21315 #endif

21316 }

21317 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANDROID_", 8))

21318 {

21319 #ifdef GL_ANDROID_extension_pack_es31a

21320 if (_glewStrSame3(&pos, &len, (const GLubyte*)"extension_pack_es31a", 20))

21321 {

21322 ret = GLEW_ANDROID_extension_pack_es31a;

21323 continue;

21324 }

21325 #endif

21326 }

21327 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6))

21328 {

21329 #ifdef GL_ANGLE_depth_texture

21330 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

21331 {

21332 ret = GLEW_ANGLE_depth_texture;

21333 continue;

21334 }

21335 #endif

21336 #ifdef GL_ANGLE_framebuffer_blit

21337 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))

21338 {

21339 ret = GLEW_ANGLE_framebuffer_blit;

21340 continue;

21341 }

21342 #endif

21343 #ifdef GL_ANGLE_framebuffer_multisample

21344 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))

21345 {

21346 ret = GLEW_ANGLE_framebuffer_multisample;

21347 continue;

21348 }

21349 #endif

21350 #ifdef GL_ANGLE_instanced_arrays

21351 if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))

21352 {

21353 ret = GLEW_ANGLE_instanced_arrays;

21354 continue;

21355 }

21356 #endif

21357 #ifdef GL_ANGLE_pack_reverse_row_order

21358 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_reverse_row_order", 22))

21359 {

21360 ret = GLEW_ANGLE_pack_reverse_row_order;

21361 continue;

21362 }

21363 #endif

21364 #ifdef GL_ANGLE_program_binary

21365 if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14))

21366 {

21367 ret = GLEW_ANGLE_program_binary;

21368 continue;

21369 }

21370 #endif

21371 #ifdef GL_ANGLE_texture_compression_dxt1

21372 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))

21373 {

21374 ret = GLEW_ANGLE_texture_compression_dxt1;

21375 continue;

21376 }

21377 #endif

21378 #ifdef GL_ANGLE_texture_compression_dxt3

21379 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt3", 24))

21380 {

21381 ret = GLEW_ANGLE_texture_compression_dxt3;

21382 continue;

21383 }

21384 #endif

21385 #ifdef GL_ANGLE_texture_compression_dxt5

21386 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt5", 24))

21387 {

21388 ret = GLEW_ANGLE_texture_compression_dxt5;

21389 continue;

21390 }

21391 #endif

21392 #ifdef GL_ANGLE_texture_usage

21393 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_usage", 13))

21394 {

21395 ret = GLEW_ANGLE_texture_usage;

21396 continue;

21397 }

21398 #endif

21399 #ifdef GL_ANGLE_timer_query

21400 if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))

21401 {

21402 ret = GLEW_ANGLE_timer_query;

21403 continue;

21404 }

21405 #endif

21406 #ifdef GL_ANGLE_translated_shader_source

21407 if (_glewStrSame3(&pos, &len, (const GLubyte*)"translated_shader_source", 24))

21408 {

21409 ret = GLEW_ANGLE_translated_shader_source;

21410 continue;

21411 }

21412 #endif

21413 }

21414 if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))

21415 {

21416 #ifdef GL_APPLE_aux_depth_stencil

21417 if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17))

21418 {

21419 ret = GLEW_APPLE_aux_depth_stencil;

21420 continue;

21421 }

21422 #endif

21423 #ifdef GL_APPLE_client_storage

21424 if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))

21425 {

21426 ret = GLEW_APPLE_client_storage;

21427 continue;

21428 }

21429 #endif

21430 #ifdef GL_APPLE_clip_distance

21431 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_distance", 13))

21432 {

21433 ret = GLEW_APPLE_clip_distance;

21434 continue;

21435 }

21436 #endif

21437 #ifdef GL_APPLE_color_buffer_packed_float

21438 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_packed_float", 25))

21439 {

21440 ret = GLEW_APPLE_color_buffer_packed_float;

21441 continue;

21442 }

21443 #endif

21444 #ifdef GL_APPLE_copy_texture_levels

21445 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture_levels", 19))

21446 {

21447 ret = GLEW_APPLE_copy_texture_levels;

21448 continue;

21449 }

21450 #endif

21451 #ifdef GL_APPLE_element_array

21452 if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

21453 {

21454 ret = GLEW_APPLE_element_array;

21455 continue;

21456 }

21457 #endif

21458 #ifdef GL_APPLE_fence

21459 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

21460 {

21461 ret = GLEW_APPLE_fence;

21462 continue;

21463 }

21464 #endif

21465 #ifdef GL_APPLE_float_pixels

21466 if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))

21467 {

21468 ret = GLEW_APPLE_float_pixels;

21469 continue;

21470 }

21471 #endif

21472 #ifdef GL_APPLE_flush_buffer_range

21473 if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18))

21474 {

21475 ret = GLEW_APPLE_flush_buffer_range;

21476 continue;

21477 }

21478 #endif

21479 #ifdef GL_APPLE_framebuffer_multisample

21480 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))

21481 {

21482 ret = GLEW_APPLE_framebuffer_multisample;

21483 continue;

21484 }

21485 #endif

21486 #ifdef GL_APPLE_object_purgeable

21487 if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16))

21488 {

21489 ret = GLEW_APPLE_object_purgeable;

21490 continue;

21491 }

21492 #endif

21493 #ifdef GL_APPLE_pixel_buffer

21494 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))

21495 {

21496 ret = GLEW_APPLE_pixel_buffer;

21497 continue;

21498 }

21499 #endif

21500 #ifdef GL_APPLE_rgb_422

21501 if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7))

21502 {

21503 ret = GLEW_APPLE_rgb_422;

21504 continue;

21505 }

21506 #endif

21507 #ifdef GL_APPLE_row_bytes

21508 if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9))

21509 {

21510 ret = GLEW_APPLE_row_bytes;

21511 continue;

21512 }

21513 #endif

21514 #ifdef GL_APPLE_specular_vector

21515 if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))

21516 {

21517 ret = GLEW_APPLE_specular_vector;

21518 continue;

21519 }

21520 #endif

21521 #ifdef GL_APPLE_sync

21522 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))

21523 {

21524 ret = GLEW_APPLE_sync;

21525 continue;

21526 }

21527 #endif

21528 #ifdef GL_APPLE_texture_2D_limited_npot

21529 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_2D_limited_npot", 23))

21530 {

21531 ret = GLEW_APPLE_texture_2D_limited_npot;

21532 continue;

21533 }

21534 #endif

21535 #ifdef GL_APPLE_texture_format_BGRA8888

21536 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_format_BGRA8888", 23))

21537 {

21538 ret = GLEW_APPLE_texture_format_BGRA8888;

21539 continue;

21540 }

21541 #endif

21542 #ifdef GL_APPLE_texture_max_level

21543 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_max_level", 17))

21544 {

21545 ret = GLEW_APPLE_texture_max_level;

21546 continue;

21547 }

21548 #endif

21549 #ifdef GL_APPLE_texture_packed_float

21550 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_packed_float", 20))

21551 {

21552 ret = GLEW_APPLE_texture_packed_float;

21553 continue;

21554 }

21555 #endif

21556 #ifdef GL_APPLE_texture_range

21557 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

21558 {

21559 ret = GLEW_APPLE_texture_range;

21560 continue;

21561 }

21562 #endif

21563 #ifdef GL_APPLE_transform_hint

21564 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))

21565 {

21566 ret = GLEW_APPLE_transform_hint;

21567 continue;

21568 }

21569 #endif

21570 #ifdef GL_APPLE_vertex_array_object

21571 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

21572 {

21573 ret = GLEW_APPLE_vertex_array_object;

21574 continue;

21575 }

21576 #endif

21577 #ifdef GL_APPLE_vertex_array_range

21578 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

21579 {

21580 ret = GLEW_APPLE_vertex_array_range;

21581 continue;

21582 }

21583 #endif

21584 #ifdef GL_APPLE_vertex_program_evaluators

21585 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25))

21586 {

21587 ret = GLEW_APPLE_vertex_program_evaluators;

21588 continue;

21589 }

21590 #endif

21591 #ifdef GL_APPLE_ycbcr_422

21592 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))

21593 {

21594 ret = GLEW_APPLE_ycbcr_422;

21595 continue;

21596 }

21597 #endif

21598 }

21599 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

21600 {

21601 #ifdef GL_ARB_ES2_compatibility

21602 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES2_compatibility", 17))

21603 {

21604 ret = GLEW_ARB_ES2_compatibility;

21605 continue;

21606 }

21607 #endif

21608 #ifdef GL_ARB_ES3_1_compatibility

21609 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_1_compatibility", 19))

21610 {

21611 ret = GLEW_ARB_ES3_1_compatibility;

21612 continue;

21613 }

21614 #endif

21615 #ifdef GL_ARB_ES3_2_compatibility

21616 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_2_compatibility", 19))

21617 {

21618 ret = GLEW_ARB_ES3_2_compatibility;

21619 continue;

21620 }

21621 #endif

21622 #ifdef GL_ARB_ES3_compatibility

21623 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_compatibility", 17))

21624 {

21625 ret = GLEW_ARB_ES3_compatibility;

21626 continue;

21627 }

21628 #endif

21629 #ifdef GL_ARB_arrays_of_arrays

21630 if (_glewStrSame3(&pos, &len, (const GLubyte*)"arrays_of_arrays", 16))

21631 {

21632 ret = GLEW_ARB_arrays_of_arrays;

21633 continue;

21634 }

21635 #endif

21636 #ifdef GL_ARB_base_instance

21637 if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13))

21638 {

21639 ret = GLEW_ARB_base_instance;

21640 continue;

21641 }

21642 #endif

21643 #ifdef GL_ARB_bindless_texture

21644 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16))

21645 {

21646 ret = GLEW_ARB_bindless_texture;

21647 continue;

21648 }

21649 #endif

21650 #ifdef GL_ARB_blend_func_extended

21651 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19))

21652 {

21653 ret = GLEW_ARB_blend_func_extended;

21654 continue;

21655 }

21656 #endif

21657 #ifdef GL_ARB_buffer_storage

21658 if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_storage", 14))

21659 {

21660 ret = GLEW_ARB_buffer_storage;

21661 continue;

21662 }

21663 #endif

21664 #ifdef GL_ARB_cl_event

21665 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8))

21666 {

21667 ret = GLEW_ARB_cl_event;

21668 continue;

21669 }

21670 #endif

21671 #ifdef GL_ARB_clear_buffer_object

21672 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_buffer_object", 19))

21673 {

21674 ret = GLEW_ARB_clear_buffer_object;

21675 continue;

21676 }

21677 #endif

21678 #ifdef GL_ARB_clear_texture

21679 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_texture", 13))

21680 {

21681 ret = GLEW_ARB_clear_texture;

21682 continue;

21683 }

21684 #endif

21685 #ifdef GL_ARB_clip_control

21686 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_control", 12))

21687 {

21688 ret = GLEW_ARB_clip_control;

21689 continue;

21690 }

21691 #endif

21692 #ifdef GL_ARB_color_buffer_float

21693 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))

21694 {

21695 ret = GLEW_ARB_color_buffer_float;

21696 continue;

21697 }

21698 #endif

21699 #ifdef GL_ARB_compatibility

21700 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13))

21701 {

21702 ret = GLEW_ARB_compatibility;

21703 continue;

21704 }

21705 #endif

21706 #ifdef GL_ARB_compressed_texture_pixel_storage

21707 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_texture_pixel_storage", 32))

21708 {

21709 ret = GLEW_ARB_compressed_texture_pixel_storage;

21710 continue;

21711 }

21712 #endif

21713 #ifdef GL_ARB_compute_shader

21714 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_shader", 14))

21715 {

21716 ret = GLEW_ARB_compute_shader;

21717 continue;

21718 }

21719 #endif

21720 #ifdef GL_ARB_compute_variable_group_size

21721 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_variable_group_size", 27))

21722 {

21723 ret = GLEW_ARB_compute_variable_group_size;

21724 continue;

21725 }

21726 #endif

21727 #ifdef GL_ARB_conditional_render_inverted

21728 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render_inverted", 27))

21729 {

21730 ret = GLEW_ARB_conditional_render_inverted;

21731 continue;

21732 }

21733 #endif

21734 #ifdef GL_ARB_conservative_depth

21735 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))

21736 {

21737 ret = GLEW_ARB_conservative_depth;

21738 continue;

21739 }

21740 #endif

21741 #ifdef GL_ARB_copy_buffer

21742 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))

21743 {

21744 ret = GLEW_ARB_copy_buffer;

21745 continue;

21746 }

21747 #endif

21748 #ifdef GL_ARB_copy_image

21749 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))

21750 {

21751 ret = GLEW_ARB_copy_image;

21752 continue;

21753 }

21754 #endif

21755 #ifdef GL_ARB_cull_distance

21756 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_distance", 13))

21757 {

21758 ret = GLEW_ARB_cull_distance;

21759 continue;

21760 }

21761 #endif

21762 #ifdef GL_ARB_debug_output

21763 if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))

21764 {

21765 ret = GLEW_ARB_debug_output;

21766 continue;

21767 }

21768 #endif

21769 #ifdef GL_ARB_depth_buffer_float

21770 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))

21771 {

21772 ret = GLEW_ARB_depth_buffer_float;

21773 continue;

21774 }

21775 #endif

21776 #ifdef GL_ARB_depth_clamp

21777 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))

21778 {

21779 ret = GLEW_ARB_depth_clamp;

21780 continue;

21781 }

21782 #endif

21783 #ifdef GL_ARB_depth_texture

21784 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

21785 {

21786 ret = GLEW_ARB_depth_texture;

21787 continue;

21788 }

21789 #endif

21790 #ifdef GL_ARB_derivative_control

21791 if (_glewStrSame3(&pos, &len, (const GLubyte*)"derivative_control", 18))

21792 {

21793 ret = GLEW_ARB_derivative_control;

21794 continue;

21795 }

21796 #endif

21797 #ifdef GL_ARB_direct_state_access

21798 if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19))

21799 {

21800 ret = GLEW_ARB_direct_state_access;

21801 continue;

21802 }

21803 #endif

21804 #ifdef GL_ARB_draw_buffers

21805 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

21806 {

21807 ret = GLEW_ARB_draw_buffers;

21808 continue;

21809 }

21810 #endif

21811 #ifdef GL_ARB_draw_buffers_blend

21812 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))

21813 {

21814 ret = GLEW_ARB_draw_buffers_blend;

21815 continue;

21816 }

21817 #endif

21818 #ifdef GL_ARB_draw_elements_base_vertex

21819 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25))

21820 {

21821 ret = GLEW_ARB_draw_elements_base_vertex;

21822 continue;

21823 }

21824 #endif

21825 #ifdef GL_ARB_draw_indirect

21826 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13))

21827 {

21828 ret = GLEW_ARB_draw_indirect;

21829 continue;

21830 }

21831 #endif

21832 #ifdef GL_ARB_draw_instanced

21833 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))

21834 {

21835 ret = GLEW_ARB_draw_instanced;

21836 continue;

21837 }

21838 #endif

21839 #ifdef GL_ARB_enhanced_layouts

21840 if (_glewStrSame3(&pos, &len, (const GLubyte*)"enhanced_layouts", 16))

21841 {

21842 ret = GLEW_ARB_enhanced_layouts;

21843 continue;

21844 }

21845 #endif

21846 #ifdef GL_ARB_explicit_attrib_location

21847 if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24))

21848 {

21849 ret = GLEW_ARB_explicit_attrib_location;

21850 continue;

21851 }

21852 #endif

21853 #ifdef GL_ARB_explicit_uniform_location

21854 if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_uniform_location", 25))

21855 {

21856 ret = GLEW_ARB_explicit_uniform_location;

21857 continue;

21858 }

21859 #endif

21860 #ifdef GL_ARB_fragment_coord_conventions

21861 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26))

21862 {

21863 ret = GLEW_ARB_fragment_coord_conventions;

21864 continue;

21865 }

21866 #endif

21867 #ifdef GL_ARB_fragment_layer_viewport

21868 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_layer_viewport", 23))

21869 {

21870 ret = GLEW_ARB_fragment_layer_viewport;

21871 continue;

21872 }

21873 #endif

21874 #ifdef GL_ARB_fragment_program

21875 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

21876 {

21877 ret = GLEW_ARB_fragment_program;

21878 continue;

21879 }

21880 #endif

21881 #ifdef GL_ARB_fragment_program_shadow

21882 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))

21883 {

21884 ret = GLEW_ARB_fragment_program_shadow;

21885 continue;

21886 }

21887 #endif

21888 #ifdef GL_ARB_fragment_shader

21889 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

21890 {

21891 ret = GLEW_ARB_fragment_shader;

21892 continue;

21893 }

21894 #endif

21895 #ifdef GL_ARB_fragment_shader_interlock

21896 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_interlock", 25))

21897 {

21898 ret = GLEW_ARB_fragment_shader_interlock;

21899 continue;

21900 }

21901 #endif

21902 #ifdef GL_ARB_framebuffer_no_attachments

21903 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_no_attachments", 26))

21904 {

21905 ret = GLEW_ARB_framebuffer_no_attachments;

21906 continue;

21907 }

21908 #endif

21909 #ifdef GL_ARB_framebuffer_object

21910 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))

21911 {

21912 ret = GLEW_ARB_framebuffer_object;

21913 continue;

21914 }

21915 #endif

21916 #ifdef GL_ARB_framebuffer_sRGB

21917 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

21918 {

21919 ret = GLEW_ARB_framebuffer_sRGB;

21920 continue;

21921 }

21922 #endif

21923 #ifdef GL_ARB_geometry_shader4

21924 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

21925 {

21926 ret = GLEW_ARB_geometry_shader4;

21927 continue;

21928 }

21929 #endif

21930 #ifdef GL_ARB_get_program_binary

21931 if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18))

21932 {

21933 ret = GLEW_ARB_get_program_binary;

21934 continue;

21935 }

21936 #endif

21937 #ifdef GL_ARB_get_texture_sub_image

21938 if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_texture_sub_image", 21))

21939 {

21940 ret = GLEW_ARB_get_texture_sub_image;

21941 continue;

21942 }

21943 #endif

21944 #ifdef GL_ARB_gl_spirv

21945 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_spirv", 8))

21946 {

21947 ret = GLEW_ARB_gl_spirv;

21948 continue;

21949 }

21950 #endif

21951 #ifdef GL_ARB_gpu_shader5

21952 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))

21953 {

21954 ret = GLEW_ARB_gpu_shader5;

21955 continue;

21956 }

21957 #endif

21958 #ifdef GL_ARB_gpu_shader_fp64

21959 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15))

21960 {

21961 ret = GLEW_ARB_gpu_shader_fp64;

21962 continue;

21963 }

21964 #endif

21965 #ifdef GL_ARB_gpu_shader_int64

21966 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int64", 16))

21967 {

21968 ret = GLEW_ARB_gpu_shader_int64;

21969 continue;

21970 }

21971 #endif

21972 #ifdef GL_ARB_half_float_pixel

21973 if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))

21974 {

21975 ret = GLEW_ARB_half_float_pixel;

21976 continue;

21977 }

21978 #endif

21979 #ifdef GL_ARB_half_float_vertex

21980 if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17))

21981 {

21982 ret = GLEW_ARB_half_float_vertex;

21983 continue;

21984 }

21985 #endif

21986 #ifdef GL_ARB_imaging

21987 if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))

21988 {

21989 ret = GLEW_ARB_imaging;

21990 continue;

21991 }

21992 #endif

21993 #ifdef GL_ARB_indirect_parameters

21994 if (_glewStrSame3(&pos, &len, (const GLubyte*)"indirect_parameters", 19))

21995 {

21996 ret = GLEW_ARB_indirect_parameters;

21997 continue;

21998 }

21999 #endif

22000 #ifdef GL_ARB_instanced_arrays

22001 if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))

22002 {

22003 ret = GLEW_ARB_instanced_arrays;

22004 continue;

22005 }

22006 #endif

22007 #ifdef GL_ARB_internalformat_query

22008 if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query", 20))

22009 {

22010 ret = GLEW_ARB_internalformat_query;

22011 continue;

22012 }

22013 #endif

22014 #ifdef GL_ARB_internalformat_query2

22015 if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query2", 21))

22016 {

22017 ret = GLEW_ARB_internalformat_query2;

22018 continue;

22019 }

22020 #endif

22021 #ifdef GL_ARB_invalidate_subdata

22022 if (_glewStrSame3(&pos, &len, (const GLubyte*)"invalidate_subdata", 18))

22023 {

22024 ret = GLEW_ARB_invalidate_subdata;

22025 continue;

22026 }

22027 #endif

22028 #ifdef GL_ARB_map_buffer_alignment

22029 if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_alignment", 20))

22030 {

22031 ret = GLEW_ARB_map_buffer_alignment;

22032 continue;

22033 }

22034 #endif

22035 #ifdef GL_ARB_map_buffer_range

22036 if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16))

22037 {

22038 ret = GLEW_ARB_map_buffer_range;

22039 continue;

22040 }

22041 #endif

22042 #ifdef GL_ARB_matrix_palette

22043 if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))

22044 {

22045 ret = GLEW_ARB_matrix_palette;

22046 continue;

22047 }

22048 #endif

22049 #ifdef GL_ARB_multi_bind

22050 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_bind", 10))

22051 {

22052 ret = GLEW_ARB_multi_bind;

22053 continue;

22054 }

22055 #endif

22056 #ifdef GL_ARB_multi_draw_indirect

22057 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))

22058 {

22059 ret = GLEW_ARB_multi_draw_indirect;

22060 continue;

22061 }

22062 #endif

22063 #ifdef GL_ARB_multisample

22064 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

22065 {

22066 ret = GLEW_ARB_multisample;

22067 continue;

22068 }

22069 #endif

22070 #ifdef GL_ARB_multitexture

22071 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))

22072 {

22073 ret = GLEW_ARB_multitexture;

22074 continue;

22075 }

22076 #endif

22077 #ifdef GL_ARB_occlusion_query

22078 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

22079 {

22080 ret = GLEW_ARB_occlusion_query;

22081 continue;

22082 }

22083 #endif

22084 #ifdef GL_ARB_occlusion_query2

22085 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16))

22086 {

22087 ret = GLEW_ARB_occlusion_query2;

22088 continue;

22089 }

22090 #endif

22091 #ifdef GL_ARB_parallel_shader_compile

22092 if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_shader_compile", 23))

22093 {

22094 ret = GLEW_ARB_parallel_shader_compile;

22095 continue;

22096 }

22097 #endif

22098 #ifdef GL_ARB_pipeline_statistics_query

22099 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pipeline_statistics_query", 25))

22100 {

22101 ret = GLEW_ARB_pipeline_statistics_query;

22102 continue;

22103 }

22104 #endif

22105 #ifdef GL_ARB_pixel_buffer_object

22106 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

22107 {

22108 ret = GLEW_ARB_pixel_buffer_object;

22109 continue;

22110 }

22111 #endif

22112 #ifdef GL_ARB_point_parameters

22113 if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

22114 {

22115 ret = GLEW_ARB_point_parameters;

22116 continue;

22117 }

22118 #endif

22119 #ifdef GL_ARB_point_sprite

22120 if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

22121 {

22122 ret = GLEW_ARB_point_sprite;

22123 continue;

22124 }

22125 #endif

22126 #ifdef GL_ARB_polygon_offset_clamp

22127 if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset_clamp", 20))

22128 {

22129 ret = GLEW_ARB_polygon_offset_clamp;

22130 continue;

22131 }

22132 #endif

22133 #ifdef GL_ARB_post_depth_coverage

22134 if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_depth_coverage", 19))

22135 {

22136 ret = GLEW_ARB_post_depth_coverage;

22137 continue;

22138 }

22139 #endif

22140 #ifdef GL_ARB_program_interface_query

22141 if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_interface_query", 23))

22142 {

22143 ret = GLEW_ARB_program_interface_query;

22144 continue;

22145 }

22146 #endif

22147 #ifdef GL_ARB_provoking_vertex

22148 if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))

22149 {

22150 ret = GLEW_ARB_provoking_vertex;

22151 continue;

22152 }

22153 #endif

22154 #ifdef GL_ARB_query_buffer_object

22155 if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19))

22156 {

22157 ret = GLEW_ARB_query_buffer_object;

22158 continue;

22159 }

22160 #endif

22161 #ifdef GL_ARB_robust_buffer_access_behavior

22162 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29))

22163 {

22164 ret = GLEW_ARB_robust_buffer_access_behavior;

22165 continue;

22166 }

22167 #endif

22168 #ifdef GL_ARB_robustness

22169 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10))

22170 {

22171 ret = GLEW_ARB_robustness;

22172 continue;

22173 }

22174 #endif

22175 #ifdef GL_ARB_robustness_application_isolation

22176 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))

22177 {

22178 ret = GLEW_ARB_robustness_application_isolation;

22179 continue;

22180 }

22181 #endif

22182 #ifdef GL_ARB_robustness_share_group_isolation

22183 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))

22184 {

22185 ret = GLEW_ARB_robustness_share_group_isolation;

22186 continue;

22187 }

22188 #endif

22189 #ifdef GL_ARB_sample_locations

22190 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_locations", 16))

22191 {

22192 ret = GLEW_ARB_sample_locations;

22193 continue;

22194 }

22195 #endif

22196 #ifdef GL_ARB_sample_shading

22197 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14))

22198 {

22199 ret = GLEW_ARB_sample_shading;

22200 continue;

22201 }

22202 #endif

22203 #ifdef GL_ARB_sampler_objects

22204 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15))

22205 {

22206 ret = GLEW_ARB_sampler_objects;

22207 continue;

22208 }

22209 #endif

22210 #ifdef GL_ARB_seamless_cube_map

22211 if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17))

22212 {

22213 ret = GLEW_ARB_seamless_cube_map;

22214 continue;

22215 }

22216 #endif

22217 #ifdef GL_ARB_seamless_cubemap_per_texture

22218 if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))

22219 {

22220 ret = GLEW_ARB_seamless_cubemap_per_texture;

22221 continue;

22222 }

22223 #endif

22224 #ifdef GL_ARB_separate_shader_objects

22225 if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))

22226 {

22227 ret = GLEW_ARB_separate_shader_objects;

22228 continue;

22229 }

22230 #endif

22231 #ifdef GL_ARB_shader_atomic_counter_ops

22232 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counter_ops", 25))

22233 {

22234 ret = GLEW_ARB_shader_atomic_counter_ops;

22235 continue;

22236 }

22237 #endif

22238 #ifdef GL_ARB_shader_atomic_counters

22239 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22))

22240 {

22241 ret = GLEW_ARB_shader_atomic_counters;

22242 continue;

22243 }

22244 #endif

22245 #ifdef GL_ARB_shader_ballot

22246 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_ballot", 13))

22247 {

22248 ret = GLEW_ARB_shader_ballot;

22249 continue;

22250 }

22251 #endif

22252 #ifdef GL_ARB_shader_bit_encoding

22253 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19))

22254 {

22255 ret = GLEW_ARB_shader_bit_encoding;

22256 continue;

22257 }

22258 #endif

22259 #ifdef GL_ARB_shader_clock

22260 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_clock", 12))

22261 {

22262 ret = GLEW_ARB_shader_clock;

22263 continue;

22264 }

22265 #endif

22266 #ifdef GL_ARB_shader_draw_parameters

22267 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_draw_parameters", 22))

22268 {

22269 ret = GLEW_ARB_shader_draw_parameters;

22270 continue;

22271 }

22272 #endif

22273 #ifdef GL_ARB_shader_group_vote

22274 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_group_vote", 17))

22275 {

22276 ret = GLEW_ARB_shader_group_vote;

22277 continue;

22278 }

22279 #endif

22280 #ifdef GL_ARB_shader_image_load_store

22281 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))

22282 {

22283 ret = GLEW_ARB_shader_image_load_store;

22284 continue;

22285 }

22286 #endif

22287 #ifdef GL_ARB_shader_image_size

22288 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_size", 17))

22289 {

22290 ret = GLEW_ARB_shader_image_size;

22291 continue;

22292 }

22293 #endif

22294 #ifdef GL_ARB_shader_objects

22295 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))

22296 {

22297 ret = GLEW_ARB_shader_objects;

22298 continue;

22299 }

22300 #endif

22301 #ifdef GL_ARB_shader_precision

22302 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_precision", 16))

22303 {

22304 ret = GLEW_ARB_shader_precision;

22305 continue;

22306 }

22307 #endif

22308 #ifdef GL_ARB_shader_stencil_export

22309 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))

22310 {

22311 ret = GLEW_ARB_shader_stencil_export;

22312 continue;

22313 }

22314 #endif

22315 #ifdef GL_ARB_shader_storage_buffer_object

22316 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28))

22317 {

22318 ret = GLEW_ARB_shader_storage_buffer_object;

22319 continue;

22320 }

22321 #endif

22322 #ifdef GL_ARB_shader_subroutine

22323 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17))

22324 {

22325 ret = GLEW_ARB_shader_subroutine;

22326 continue;

22327 }

22328 #endif

22329 #ifdef GL_ARB_shader_texture_image_samples

22330 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_image_samples", 28))

22331 {

22332 ret = GLEW_ARB_shader_texture_image_samples;

22333 continue;

22334 }

22335 #endif

22336 #ifdef GL_ARB_shader_texture_lod

22337 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))

22338 {

22339 ret = GLEW_ARB_shader_texture_lod;

22340 continue;

22341 }

22342 #endif

22343 #ifdef GL_ARB_shader_viewport_layer_array

22344 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_viewport_layer_array", 27))

22345 {

22346 ret = GLEW_ARB_shader_viewport_layer_array;

22347 continue;

22348 }

22349 #endif

22350 #ifdef GL_ARB_shading_language_100

22351 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))

22352 {

22353 ret = GLEW_ARB_shading_language_100;

22354 continue;

22355 }

22356 #endif

22357 #ifdef GL_ARB_shading_language_420pack

22358 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_420pack", 24))

22359 {

22360 ret = GLEW_ARB_shading_language_420pack;

22361 continue;

22362 }

22363 #endif

22364 #ifdef GL_ARB_shading_language_include

22365 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24))

22366 {

22367 ret = GLEW_ARB_shading_language_include;

22368 continue;

22369 }

22370 #endif

22371 #ifdef GL_ARB_shading_language_packing

22372 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_packing", 24))

22373 {

22374 ret = GLEW_ARB_shading_language_packing;

22375 continue;

22376 }

22377 #endif

22378 #ifdef GL_ARB_shadow

22379 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

22380 {

22381 ret = GLEW_ARB_shadow;

22382 continue;

22383 }

22384 #endif

22385 #ifdef GL_ARB_shadow_ambient

22386 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

22387 {

22388 ret = GLEW_ARB_shadow_ambient;

22389 continue;

22390 }

22391 #endif

22392 #ifdef GL_ARB_sparse_buffer

22393 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_buffer", 13))

22394 {

22395 ret = GLEW_ARB_sparse_buffer;

22396 continue;

22397 }

22398 #endif

22399 #ifdef GL_ARB_sparse_texture

22400 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14))

22401 {

22402 ret = GLEW_ARB_sparse_texture;

22403 continue;

22404 }

22405 #endif

22406 #ifdef GL_ARB_sparse_texture2

22407 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture2", 15))

22408 {

22409 ret = GLEW_ARB_sparse_texture2;

22410 continue;

22411 }

22412 #endif

22413 #ifdef GL_ARB_sparse_texture_clamp

22414 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture_clamp", 20))

22415 {

22416 ret = GLEW_ARB_sparse_texture_clamp;

22417 continue;

22418 }

22419 #endif

22420 #ifdef GL_ARB_spirv_extensions

22421 if (_glewStrSame3(&pos, &len, (const GLubyte*)"spirv_extensions", 16))

22422 {

22423 ret = GLEW_ARB_spirv_extensions;

22424 continue;

22425 }

22426 #endif

22427 #ifdef GL_ARB_stencil_texturing

22428 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_texturing", 17))

22429 {

22430 ret = GLEW_ARB_stencil_texturing;

22431 continue;

22432 }

22433 #endif

22434 #ifdef GL_ARB_sync

22435 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))

22436 {

22437 ret = GLEW_ARB_sync;

22438 continue;

22439 }

22440 #endif

22441 #ifdef GL_ARB_tessellation_shader

22442 if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19))

22443 {

22444 ret = GLEW_ARB_tessellation_shader;

22445 continue;

22446 }

22447 #endif

22448 #ifdef GL_ARB_texture_barrier

22449 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15))

22450 {

22451 ret = GLEW_ARB_texture_barrier;

22452 continue;

22453 }

22454 #endif

22455 #ifdef GL_ARB_texture_border_clamp

22456 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

22457 {

22458 ret = GLEW_ARB_texture_border_clamp;

22459 continue;

22460 }

22461 #endif

22462 #ifdef GL_ARB_texture_buffer_object

22463 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))

22464 {

22465 ret = GLEW_ARB_texture_buffer_object;

22466 continue;

22467 }

22468 #endif

22469 #ifdef GL_ARB_texture_buffer_object_rgb32

22470 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27))

22471 {

22472 ret = GLEW_ARB_texture_buffer_object_rgb32;

22473 continue;

22474 }

22475 #endif

22476 #ifdef GL_ARB_texture_buffer_range

22477 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_range", 20))

22478 {

22479 ret = GLEW_ARB_texture_buffer_range;

22480 continue;

22481 }

22482 #endif

22483 #ifdef GL_ARB_texture_compression

22484 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))

22485 {

22486 ret = GLEW_ARB_texture_compression;

22487 continue;

22488 }

22489 #endif

22490 #ifdef GL_ARB_texture_compression_bptc

22491 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24))

22492 {

22493 ret = GLEW_ARB_texture_compression_bptc;

22494 continue;

22495 }

22496 #endif

22497 #ifdef GL_ARB_texture_compression_rgtc

22498 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))

22499 {

22500 ret = GLEW_ARB_texture_compression_rgtc;

22501 continue;

22502 }

22503 #endif

22504 #ifdef GL_ARB_texture_cube_map

22505 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

22506 {

22507 ret = GLEW_ARB_texture_cube_map;

22508 continue;

22509 }

22510 #endif

22511 #ifdef GL_ARB_texture_cube_map_array

22512 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22))

22513 {

22514 ret = GLEW_ARB_texture_cube_map_array;

22515 continue;

22516 }

22517 #endif

22518 #ifdef GL_ARB_texture_env_add

22519 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

22520 {

22521 ret = GLEW_ARB_texture_env_add;

22522 continue;

22523 }

22524 #endif

22525 #ifdef GL_ARB_texture_env_combine

22526 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

22527 {

22528 ret = GLEW_ARB_texture_env_combine;

22529 continue;

22530 }

22531 #endif

22532 #ifdef GL_ARB_texture_env_crossbar

22533 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))

22534 {

22535 ret = GLEW_ARB_texture_env_crossbar;

22536 continue;

22537 }

22538 #endif

22539 #ifdef GL_ARB_texture_env_dot3

22540 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

22541 {

22542 ret = GLEW_ARB_texture_env_dot3;

22543 continue;

22544 }

22545 #endif

22546 #ifdef GL_ARB_texture_filter_anisotropic

22547 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))

22548 {

22549 ret = GLEW_ARB_texture_filter_anisotropic;

22550 continue;

22551 }

22552 #endif

22553 #ifdef GL_ARB_texture_filter_minmax

22554 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_minmax", 21))

22555 {

22556 ret = GLEW_ARB_texture_filter_minmax;

22557 continue;

22558 }

22559 #endif

22560 #ifdef GL_ARB_texture_float

22561 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

22562 {

22563 ret = GLEW_ARB_texture_float;

22564 continue;

22565 }

22566 #endif

22567 #ifdef GL_ARB_texture_gather

22568 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14))

22569 {

22570 ret = GLEW_ARB_texture_gather;

22571 continue;

22572 }

22573 #endif

22574 #ifdef GL_ARB_texture_mirror_clamp_to_edge

22575 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp_to_edge", 28))

22576 {

22577 ret = GLEW_ARB_texture_mirror_clamp_to_edge;

22578 continue;

22579 }

22580 #endif

22581 #ifdef GL_ARB_texture_mirrored_repeat

22582 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

22583 {

22584 ret = GLEW_ARB_texture_mirrored_repeat;

22585 continue;

22586 }

22587 #endif

22588 #ifdef GL_ARB_texture_multisample

22589 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))

22590 {

22591 ret = GLEW_ARB_texture_multisample;

22592 continue;

22593 }

22594 #endif

22595 #ifdef GL_ARB_texture_non_power_of_two

22596 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))

22597 {

22598 ret = GLEW_ARB_texture_non_power_of_two;

22599 continue;

22600 }

22601 #endif

22602 #ifdef GL_ARB_texture_query_levels

22603 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_levels", 20))

22604 {

22605 ret = GLEW_ARB_texture_query_levels;

22606 continue;

22607 }

22608 #endif

22609 #ifdef GL_ARB_texture_query_lod

22610 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17))

22611 {

22612 ret = GLEW_ARB_texture_query_lod;

22613 continue;

22614 }

22615 #endif

22616 #ifdef GL_ARB_texture_rectangle

22617 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

22618 {

22619 ret = GLEW_ARB_texture_rectangle;

22620 continue;

22621 }

22622 #endif

22623 #ifdef GL_ARB_texture_rg

22624 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10))

22625 {

22626 ret = GLEW_ARB_texture_rg;

22627 continue;

22628 }

22629 #endif

22630 #ifdef GL_ARB_texture_rgb10_a2ui

22631 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18))

22632 {

22633 ret = GLEW_ARB_texture_rgb10_a2ui;

22634 continue;

22635 }

22636 #endif

22637 #ifdef GL_ARB_texture_stencil8

22638 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stencil8", 16))

22639 {

22640 ret = GLEW_ARB_texture_stencil8;

22641 continue;

22642 }

22643 #endif

22644 #ifdef GL_ARB_texture_storage

22645 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15))

22646 {

22647 ret = GLEW_ARB_texture_storage;

22648 continue;

22649 }

22650 #endif

22651 #ifdef GL_ARB_texture_storage_multisample

22652 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_multisample", 27))

22653 {

22654 ret = GLEW_ARB_texture_storage_multisample;

22655 continue;

22656 }

22657 #endif

22658 #ifdef GL_ARB_texture_swizzle

22659 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))

22660 {

22661 ret = GLEW_ARB_texture_swizzle;

22662 continue;

22663 }

22664 #endif

22665 #ifdef GL_ARB_texture_view

22666 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12))

22667 {

22668 ret = GLEW_ARB_texture_view;

22669 continue;

22670 }

22671 #endif

22672 #ifdef GL_ARB_timer_query

22673 if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))

22674 {

22675 ret = GLEW_ARB_timer_query;

22676 continue;

22677 }

22678 #endif

22679 #ifdef GL_ARB_transform_feedback2

22680 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))

22681 {

22682 ret = GLEW_ARB_transform_feedback2;

22683 continue;

22684 }

22685 #endif

22686 #ifdef GL_ARB_transform_feedback3

22687 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19))

22688 {

22689 ret = GLEW_ARB_transform_feedback3;

22690 continue;

22691 }

22692 #endif

22693 #ifdef GL_ARB_transform_feedback_instanced

22694 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_instanced", 28))

22695 {

22696 ret = GLEW_ARB_transform_feedback_instanced;

22697 continue;

22698 }

22699 #endif

22700 #ifdef GL_ARB_transform_feedback_overflow_query

22701 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_overflow_query", 33))

22702 {

22703 ret = GLEW_ARB_transform_feedback_overflow_query;

22704 continue;

22705 }

22706 #endif

22707 #ifdef GL_ARB_transpose_matrix

22708 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))

22709 {

22710 ret = GLEW_ARB_transpose_matrix;

22711 continue;

22712 }

22713 #endif

22714 #ifdef GL_ARB_uniform_buffer_object

22715 if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21))

22716 {

22717 ret = GLEW_ARB_uniform_buffer_object;

22718 continue;

22719 }

22720 #endif

22721 #ifdef GL_ARB_vertex_array_bgra

22722 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))

22723 {

22724 ret = GLEW_ARB_vertex_array_bgra;

22725 continue;

22726 }

22727 #endif

22728 #ifdef GL_ARB_vertex_array_object

22729 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

22730 {

22731 ret = GLEW_ARB_vertex_array_object;

22732 continue;

22733 }

22734 #endif

22735 #ifdef GL_ARB_vertex_attrib_64bit

22736 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))

22737 {

22738 ret = GLEW_ARB_vertex_attrib_64bit;

22739 continue;

22740 }

22741 #endif

22742 #ifdef GL_ARB_vertex_attrib_binding

22743 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_binding", 21))

22744 {

22745 ret = GLEW_ARB_vertex_attrib_binding;

22746 continue;

22747 }

22748 #endif

22749 #ifdef GL_ARB_vertex_blend

22750 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))

22751 {

22752 ret = GLEW_ARB_vertex_blend;

22753 continue;

22754 }

22755 #endif

22756 #ifdef GL_ARB_vertex_buffer_object

22757 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))

22758 {

22759 ret = GLEW_ARB_vertex_buffer_object;

22760 continue;

22761 }

22762 #endif

22763 #ifdef GL_ARB_vertex_program

22764 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

22765 {

22766 ret = GLEW_ARB_vertex_program;

22767 continue;

22768 }

22769 #endif

22770 #ifdef GL_ARB_vertex_shader

22771 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

22772 {

22773 ret = GLEW_ARB_vertex_shader;

22774 continue;

22775 }

22776 #endif

22777 #ifdef GL_ARB_vertex_type_10f_11f_11f_rev

22778 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_10f_11f_11f_rev", 27))

22779 {

22780 ret = GLEW_ARB_vertex_type_10f_11f_11f_rev;

22781 continue;

22782 }

22783 #endif

22784 #ifdef GL_ARB_vertex_type_2_10_10_10_rev

22785 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26))

22786 {

22787 ret = GLEW_ARB_vertex_type_2_10_10_10_rev;

22788 continue;

22789 }

22790 #endif

22791 #ifdef GL_ARB_viewport_array

22792 if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14))

22793 {

22794 ret = GLEW_ARB_viewport_array;

22795 continue;

22796 }

22797 #endif

22798 #ifdef GL_ARB_window_pos

22799 if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

22800 {

22801 ret = GLEW_ARB_window_pos;

22802 continue;

22803 }

22804 #endif

22805 }

22806 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARM_", 4))

22807 {

22808 #ifdef GL_ARM_mali_program_binary

22809 if (_glewStrSame3(&pos, &len, (const GLubyte*)"mali_program_binary", 19))

22810 {

22811 ret = GLEW_ARM_mali_program_binary;

22812 continue;

22813 }

22814 #endif

22815 #ifdef GL_ARM_mali_shader_binary

22816 if (_glewStrSame3(&pos, &len, (const GLubyte*)"mali_shader_binary", 18))

22817 {

22818 ret = GLEW_ARM_mali_shader_binary;

22819 continue;

22820 }

22821 #endif

22822 #ifdef GL_ARM_rgba8

22823 if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgba8", 5))

22824 {

22825 ret = GLEW_ARM_rgba8;

22826 continue;

22827 }

22828 #endif

22829 #ifdef GL_ARM_shader_framebuffer_fetch

22830 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24))

22831 {

22832 ret = GLEW_ARM_shader_framebuffer_fetch;

22833 continue;

22834 }

22835 #endif

22836 #ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil

22837 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_depth_stencil", 38))

22838 {

22839 ret = GLEW_ARM_shader_framebuffer_fetch_depth_stencil;

22840 continue;

22841 }

22842 #endif

22843 }

22844 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))

22845 {

22846 #ifdef GL_ATIX_point_sprites

22847 if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))

22848 {

22849 ret = GLEW_ATIX_point_sprites;

22850 continue;

22851 }

22852 #endif

22853 #ifdef GL_ATIX_texture_env_combine3

22854 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

22855 {

22856 ret = GLEW_ATIX_texture_env_combine3;

22857 continue;

22858 }

22859 #endif

22860 #ifdef GL_ATIX_texture_env_route

22861 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))

22862 {

22863 ret = GLEW_ATIX_texture_env_route;

22864 continue;

22865 }

22866 #endif

22867 #ifdef GL_ATIX_vertex_shader_output_point_size

22868 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))

22869 {

22870 ret = GLEW_ATIX_vertex_shader_output_point_size;

22871 continue;

22872 }

22873 #endif

22874 }

22875 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

22876 {

22877 #ifdef GL_ATI_draw_buffers

22878 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

22879 {

22880 ret = GLEW_ATI_draw_buffers;

22881 continue;

22882 }

22883 #endif

22884 #ifdef GL_ATI_element_array

22885 if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

22886 {

22887 ret = GLEW_ATI_element_array;

22888 continue;

22889 }

22890 #endif

22891 #ifdef GL_ATI_envmap_bumpmap

22892 if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))

22893 {

22894 ret = GLEW_ATI_envmap_bumpmap;

22895 continue;

22896 }

22897 #endif

22898 #ifdef GL_ATI_fragment_shader

22899 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

22900 {

22901 ret = GLEW_ATI_fragment_shader;

22902 continue;

22903 }

22904 #endif

22905 #ifdef GL_ATI_map_object_buffer

22906 if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))

22907 {

22908 ret = GLEW_ATI_map_object_buffer;

22909 continue;

22910 }

22911 #endif

22912 #ifdef GL_ATI_meminfo

22913 if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7))

22914 {

22915 ret = GLEW_ATI_meminfo;

22916 continue;

22917 }

22918 #endif

22919 #ifdef GL_ATI_pn_triangles

22920 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))

22921 {

22922 ret = GLEW_ATI_pn_triangles;

22923 continue;

22924 }

22925 #endif

22926 #ifdef GL_ATI_separate_stencil

22927 if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))

22928 {

22929 ret = GLEW_ATI_separate_stencil;

22930 continue;

22931 }

22932 #endif

22933 #ifdef GL_ATI_shader_texture_lod

22934 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))

22935 {

22936 ret = GLEW_ATI_shader_texture_lod;

22937 continue;

22938 }

22939 #endif

22940 #ifdef GL_ATI_text_fragment_shader

22941 if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))

22942 {

22943 ret = GLEW_ATI_text_fragment_shader;

22944 continue;

22945 }

22946 #endif

22947 #ifdef GL_ATI_texture_compression_3dc

22948 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))

22949 {

22950 ret = GLEW_ATI_texture_compression_3dc;

22951 continue;

22952 }

22953 #endif

22954 #ifdef GL_ATI_texture_env_combine3

22955 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

22956 {

22957 ret = GLEW_ATI_texture_env_combine3;

22958 continue;

22959 }

22960 #endif

22961 #ifdef GL_ATI_texture_float

22962 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

22963 {

22964 ret = GLEW_ATI_texture_float;

22965 continue;

22966 }

22967 #endif

22968 #ifdef GL_ATI_texture_mirror_once

22969 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))

22970 {

22971 ret = GLEW_ATI_texture_mirror_once;

22972 continue;

22973 }

22974 #endif

22975 #ifdef GL_ATI_vertex_array_object

22976 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

22977 {

22978 ret = GLEW_ATI_vertex_array_object;

22979 continue;

22980 }

22981 #endif

22982 #ifdef GL_ATI_vertex_attrib_array_object

22983 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))

22984 {

22985 ret = GLEW_ATI_vertex_attrib_array_object;

22986 continue;

22987 }

22988 #endif

22989 #ifdef GL_ATI_vertex_streams

22990 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))

22991 {

22992 ret = GLEW_ATI_vertex_streams;

22993 continue;

22994 }

22995 #endif

22996 }

22997 if (_glewStrSame2(&pos, &len, (const GLubyte*)"EGL_", 4))

22998 {

22999 #ifdef GL_EGL_KHR_context_flush_control

23000 if (_glewStrSame3(&pos, &len, (const GLubyte*)"KHR_context_flush_control", 25))

23001 {

23002 ret = GLEW_EGL_KHR_context_flush_control;

23003 continue;

23004 }

23005 #endif

23006 #ifdef GL_EGL_NV_robustness_video_memory_purge

23007 if (_glewStrSame3(&pos, &len, (const GLubyte*)"NV_robustness_video_memory_purge", 32))

23008 {

23009 ret = GLEW_EGL_NV_robustness_video_memory_purge;

23010 continue;

23011 }

23012 #endif

23013 }

23014 if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

23015 {

23016 #ifdef GL_EXT_422_pixels

23017 if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))

23018 {

23019 ret = GLEW_EXT_422_pixels;

23020 continue;

23021 }

23022 #endif

23023 #ifdef GL_EXT_Cg_shader

23024 if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))

23025 {

23026 ret = GLEW_EXT_Cg_shader;

23027 continue;

23028 }

23029 #endif

23030 #ifdef GL_EXT_EGL_image_array

23031 if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_array", 15))

23032 {

23033 ret = GLEW_EXT_EGL_image_array;

23034 continue;

23035 }

23036 #endif

23037 #ifdef GL_EXT_YUV_target

23038 if (_glewStrSame3(&pos, &len, (const GLubyte*)"YUV_target", 10))

23039 {

23040 ret = GLEW_EXT_YUV_target;

23041 continue;

23042 }

23043 #endif

23044 #ifdef GL_EXT_abgr

23045 if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))

23046 {

23047 ret = GLEW_EXT_abgr;

23048 continue;

23049 }

23050 #endif

23051 #ifdef GL_EXT_base_instance

23052 if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13))

23053 {

23054 ret = GLEW_EXT_base_instance;

23055 continue;

23056 }

23057 #endif

23058 #ifdef GL_EXT_bgra

23059 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))

23060 {

23061 ret = GLEW_EXT_bgra;

23062 continue;

23063 }

23064 #endif

23065 #ifdef GL_EXT_bindable_uniform

23066 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16))

23067 {

23068 ret = GLEW_EXT_bindable_uniform;

23069 continue;

23070 }

23071 #endif

23072 #ifdef GL_EXT_blend_color

23073 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))

23074 {

23075 ret = GLEW_EXT_blend_color;

23076 continue;

23077 }

23078 #endif

23079 #ifdef GL_EXT_blend_equation_separate

23080 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))

23081 {

23082 ret = GLEW_EXT_blend_equation_separate;

23083 continue;

23084 }

23085 #endif

23086 #ifdef GL_EXT_blend_func_extended

23087 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19))

23088 {

23089 ret = GLEW_EXT_blend_func_extended;

23090 continue;

23091 }

23092 #endif

23093 #ifdef GL_EXT_blend_func_separate

23094 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))

23095 {

23096 ret = GLEW_EXT_blend_func_separate;

23097 continue;

23098 }

23099 #endif

23100 #ifdef GL_EXT_blend_logic_op

23101 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))

23102 {

23103 ret = GLEW_EXT_blend_logic_op;

23104 continue;

23105 }

23106 #endif

23107 #ifdef GL_EXT_blend_minmax

23108 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))

23109 {

23110 ret = GLEW_EXT_blend_minmax;

23111 continue;

23112 }

23113 #endif

23114 #ifdef GL_EXT_blend_subtract

23115 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))

23116 {

23117 ret = GLEW_EXT_blend_subtract;

23118 continue;

23119 }

23120 #endif

23121 #ifdef GL_EXT_buffer_storage

23122 if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_storage", 14))

23123 {

23124 ret = GLEW_EXT_buffer_storage;

23125 continue;

23126 }

23127 #endif

23128 #ifdef GL_EXT_clear_texture

23129 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_texture", 13))

23130 {

23131 ret = GLEW_EXT_clear_texture;

23132 continue;

23133 }

23134 #endif

23135 #ifdef GL_EXT_clip_cull_distance

23136 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_cull_distance", 18))

23137 {

23138 ret = GLEW_EXT_clip_cull_distance;

23139 continue;

23140 }

23141 #endif

23142 #ifdef GL_EXT_clip_volume_hint

23143 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))

23144 {

23145 ret = GLEW_EXT_clip_volume_hint;

23146 continue;

23147 }

23148 #endif

23149 #ifdef GL_EXT_cmyka

23150 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))

23151 {

23152 ret = GLEW_EXT_cmyka;

23153 continue;

23154 }

23155 #endif

23156 #ifdef GL_EXT_color_buffer_float

23157 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))

23158 {

23159 ret = GLEW_EXT_color_buffer_float;

23160 continue;

23161 }

23162 #endif

23163 #ifdef GL_EXT_color_buffer_half_float

23164 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_half_float", 23))

23165 {

23166 ret = GLEW_EXT_color_buffer_half_float;

23167 continue;

23168 }

23169 #endif

23170 #ifdef GL_EXT_color_subtable

23171 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))

23172 {

23173 ret = GLEW_EXT_color_subtable;

23174 continue;

23175 }

23176 #endif

23177 #ifdef GL_EXT_compiled_vertex_array

23178 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))

23179 {

23180 ret = GLEW_EXT_compiled_vertex_array;

23181 continue;

23182 }

23183 #endif

23184 #ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture

23185 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_ETC1_RGB8_sub_texture", 32))

23186 {

23187 ret = GLEW_EXT_compressed_ETC1_RGB8_sub_texture;

23188 continue;

23189 }

23190 #endif

23191 #ifdef GL_EXT_conservative_depth

23192 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))

23193 {

23194 ret = GLEW_EXT_conservative_depth;

23195 continue;

23196 }

23197 #endif

23198 #ifdef GL_EXT_convolution

23199 if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))

23200 {

23201 ret = GLEW_EXT_convolution;

23202 continue;

23203 }

23204 #endif

23205 #ifdef GL_EXT_coordinate_frame

23206 if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))

23207 {

23208 ret = GLEW_EXT_coordinate_frame;

23209 continue;

23210 }

23211 #endif

23212 #ifdef GL_EXT_copy_image

23213 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))

23214 {

23215 ret = GLEW_EXT_copy_image;

23216 continue;

23217 }

23218 #endif

23219 #ifdef GL_EXT_copy_texture

23220 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))

23221 {

23222 ret = GLEW_EXT_copy_texture;

23223 continue;

23224 }

23225 #endif

23226 #ifdef GL_EXT_cull_vertex

23227 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

23228 {

23229 ret = GLEW_EXT_cull_vertex;

23230 continue;

23231 }

23232 #endif

23233 #ifdef GL_EXT_debug_label

23234 if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_label", 11))

23235 {

23236 ret = GLEW_EXT_debug_label;

23237 continue;

23238 }

23239 #endif

23240 #ifdef GL_EXT_debug_marker

23241 if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_marker", 12))

23242 {

23243 ret = GLEW_EXT_debug_marker;

23244 continue;

23245 }

23246 #endif

23247 #ifdef GL_EXT_depth_bounds_test

23248 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))

23249 {

23250 ret = GLEW_EXT_depth_bounds_test;

23251 continue;

23252 }

23253 #endif

23254 #ifdef GL_EXT_direct_state_access

23255 if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19))

23256 {

23257 ret = GLEW_EXT_direct_state_access;

23258 continue;

23259 }

23260 #endif

23261 #ifdef GL_EXT_discard_framebuffer

23262 if (_glewStrSame3(&pos, &len, (const GLubyte*)"discard_framebuffer", 19))

23263 {

23264 ret = GLEW_EXT_discard_framebuffer;

23265 continue;

23266 }

23267 #endif

23268 #ifdef GL_EXT_draw_buffers

23269 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

23270 {

23271 ret = GLEW_EXT_draw_buffers;

23272 continue;

23273 }

23274 #endif

23275 #ifdef GL_EXT_draw_buffers2

23276 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13))

23277 {

23278 ret = GLEW_EXT_draw_buffers2;

23279 continue;

23280 }

23281 #endif

23282 #ifdef GL_EXT_draw_buffers_indexed

23283 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_indexed", 20))

23284 {

23285 ret = GLEW_EXT_draw_buffers_indexed;

23286 continue;

23287 }

23288 #endif

23289 #ifdef GL_EXT_draw_elements_base_vertex

23290 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25))

23291 {

23292 ret = GLEW_EXT_draw_elements_base_vertex;

23293 continue;

23294 }

23295 #endif

23296 #ifdef GL_EXT_draw_instanced

23297 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))

23298 {

23299 ret = GLEW_EXT_draw_instanced;

23300 continue;

23301 }

23302 #endif

23303 #ifdef GL_EXT_draw_range_elements

23304 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))

23305 {

23306 ret = GLEW_EXT_draw_range_elements;

23307 continue;

23308 }

23309 #endif

23310 #ifdef GL_EXT_external_buffer

23311 if (_glewStrSame3(&pos, &len, (const GLubyte*)"external_buffer", 15))

23312 {

23313 ret = GLEW_EXT_external_buffer;

23314 continue;

23315 }

23316 #endif

23317 #ifdef GL_EXT_float_blend

23318 if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_blend", 11))

23319 {

23320 ret = GLEW_EXT_float_blend;

23321 continue;

23322 }

23323 #endif

23324 #ifdef GL_EXT_fog_coord

23325 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))

23326 {

23327 ret = GLEW_EXT_fog_coord;

23328 continue;

23329 }

23330 #endif

23331 #ifdef GL_EXT_frag_depth

23332 if (_glewStrSame3(&pos, &len, (const GLubyte*)"frag_depth", 10))

23333 {

23334 ret = GLEW_EXT_frag_depth;

23335 continue;

23336 }

23337 #endif

23338 #ifdef GL_EXT_fragment_lighting

23339 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))

23340 {

23341 ret = GLEW_EXT_fragment_lighting;

23342 continue;

23343 }

23344 #endif

23345 #ifdef GL_EXT_framebuffer_blit

23346 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))

23347 {

23348 ret = GLEW_EXT_framebuffer_blit;

23349 continue;

23350 }

23351 #endif

23352 #ifdef GL_EXT_framebuffer_multisample

23353 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))

23354 {

23355 ret = GLEW_EXT_framebuffer_multisample;

23356 continue;

23357 }

23358 #endif

23359 #ifdef GL_EXT_framebuffer_multisample_blit_scaled

23360 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_blit_scaled", 35))

23361 {

23362 ret = GLEW_EXT_framebuffer_multisample_blit_scaled;

23363 continue;

23364 }

23365 #endif

23366 #ifdef GL_EXT_framebuffer_object

23367 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))

23368 {

23369 ret = GLEW_EXT_framebuffer_object;

23370 continue;

23371 }

23372 #endif

23373 #ifdef GL_EXT_framebuffer_sRGB

23374 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

23375 {

23376 ret = GLEW_EXT_framebuffer_sRGB;

23377 continue;

23378 }

23379 #endif

23380 #ifdef GL_EXT_geometry_point_size

23381 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_point_size", 19))

23382 {

23383 ret = GLEW_EXT_geometry_point_size;

23384 continue;

23385 }

23386 #endif

23387 #ifdef GL_EXT_geometry_shader

23388 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader", 15))

23389 {

23390 ret = GLEW_EXT_geometry_shader;

23391 continue;

23392 }

23393 #endif

23394 #ifdef GL_EXT_geometry_shader4

23395 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

23396 {

23397 ret = GLEW_EXT_geometry_shader4;

23398 continue;

23399 }

23400 #endif

23401 #ifdef GL_EXT_gpu_program_parameters

23402 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22))

23403 {

23404 ret = GLEW_EXT_gpu_program_parameters;

23405 continue;

23406 }

23407 #endif

23408 #ifdef GL_EXT_gpu_shader4

23409 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11))

23410 {

23411 ret = GLEW_EXT_gpu_shader4;

23412 continue;

23413 }

23414 #endif

23415 #ifdef GL_EXT_gpu_shader5

23416 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))

23417 {

23418 ret = GLEW_EXT_gpu_shader5;

23419 continue;

23420 }

23421 #endif

23422 #ifdef GL_EXT_histogram

23423 if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))

23424 {

23425 ret = GLEW_EXT_histogram;

23426 continue;

23427 }

23428 #endif

23429 #ifdef GL_EXT_index_array_formats

23430 if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))

23431 {

23432 ret = GLEW_EXT_index_array_formats;

23433 continue;

23434 }

23435 #endif

23436 #ifdef GL_EXT_index_func

23437 if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))

23438 {

23439 ret = GLEW_EXT_index_func;

23440 continue;

23441 }

23442 #endif

23443 #ifdef GL_EXT_index_material

23444 if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))

23445 {

23446 ret = GLEW_EXT_index_material;

23447 continue;

23448 }

23449 #endif

23450 #ifdef GL_EXT_index_texture

23451 if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))

23452 {

23453 ret = GLEW_EXT_index_texture;

23454 continue;

23455 }

23456 #endif

23457 #ifdef GL_EXT_instanced_arrays

23458 if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))

23459 {

23460 ret = GLEW_EXT_instanced_arrays;

23461 continue;

23462 }

23463 #endif

23464 #ifdef GL_EXT_light_texture

23465 if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))

23466 {

23467 ret = GLEW_EXT_light_texture;

23468 continue;

23469 }

23470 #endif

23471 #ifdef GL_EXT_map_buffer_range

23472 if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16))

23473 {

23474 ret = GLEW_EXT_map_buffer_range;

23475 continue;

23476 }

23477 #endif

23478 #ifdef GL_EXT_memory_object

23479 if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object", 13))

23480 {

23481 ret = GLEW_EXT_memory_object;

23482 continue;

23483 }

23484 #endif

23485 #ifdef GL_EXT_memory_object_fd

23486 if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object_fd", 16))

23487 {

23488 ret = GLEW_EXT_memory_object_fd;

23489 continue;

23490 }

23491 #endif

23492 #ifdef GL_EXT_memory_object_win32

23493 if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object_win32", 19))

23494 {

23495 ret = GLEW_EXT_memory_object_win32;

23496 continue;

23497 }

23498 #endif

23499 #ifdef GL_EXT_misc_attribute

23500 if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))

23501 {

23502 ret = GLEW_EXT_misc_attribute;

23503 continue;

23504 }

23505 #endif

23506 #ifdef GL_EXT_multi_draw_arrays

23507 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))

23508 {

23509 ret = GLEW_EXT_multi_draw_arrays;

23510 continue;

23511 }

23512 #endif

23513 #ifdef GL_EXT_multi_draw_indirect

23514 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))

23515 {

23516 ret = GLEW_EXT_multi_draw_indirect;

23517 continue;

23518 }

23519 #endif

23520 #ifdef GL_EXT_multiple_textures

23521 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiple_textures", 17))

23522 {

23523 ret = GLEW_EXT_multiple_textures;

23524 continue;

23525 }

23526 #endif

23527 #ifdef GL_EXT_multisample

23528 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

23529 {

23530 ret = GLEW_EXT_multisample;

23531 continue;

23532 }

23533 #endif

23534 #ifdef GL_EXT_multisample_compatibility

23535 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_compatibility", 25))

23536 {

23537 ret = GLEW_EXT_multisample_compatibility;

23538 continue;

23539 }

23540 #endif

23541 #ifdef GL_EXT_multisampled_render_to_texture

23542 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisampled_render_to_texture", 30))

23543 {

23544 ret = GLEW_EXT_multisampled_render_to_texture;

23545 continue;

23546 }

23547 #endif

23548 #ifdef GL_EXT_multisampled_render_to_texture2

23549 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisampled_render_to_texture2", 31))

23550 {

23551 ret = GLEW_EXT_multisampled_render_to_texture2;

23552 continue;

23553 }

23554 #endif

23555 #ifdef GL_EXT_multiview_draw_buffers

23556 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_draw_buffers", 22))

23557 {

23558 ret = GLEW_EXT_multiview_draw_buffers;

23559 continue;

23560 }

23561 #endif

23562 #ifdef GL_EXT_packed_depth_stencil

23563 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

23564 {

23565 ret = GLEW_EXT_packed_depth_stencil;

23566 continue;

23567 }

23568 #endif

23569 #ifdef GL_EXT_packed_float

23570 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))

23571 {

23572 ret = GLEW_EXT_packed_float;

23573 continue;

23574 }

23575 #endif

23576 #ifdef GL_EXT_packed_pixels

23577 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))

23578 {

23579 ret = GLEW_EXT_packed_pixels;

23580 continue;

23581 }

23582 #endif

23583 #ifdef GL_EXT_paletted_texture

23584 if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))

23585 {

23586 ret = GLEW_EXT_paletted_texture;

23587 continue;

23588 }

23589 #endif

23590 #ifdef GL_EXT_pixel_buffer_object

23591 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

23592 {

23593 ret = GLEW_EXT_pixel_buffer_object;

23594 continue;

23595 }

23596 #endif

23597 #ifdef GL_EXT_pixel_transform

23598 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))

23599 {

23600 ret = GLEW_EXT_pixel_transform;

23601 continue;

23602 }

23603 #endif

23604 #ifdef GL_EXT_pixel_transform_color_table

23605 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))

23606 {

23607 ret = GLEW_EXT_pixel_transform_color_table;

23608 continue;

23609 }

23610 #endif

23611 #ifdef GL_EXT_point_parameters

23612 if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

23613 {

23614 ret = GLEW_EXT_point_parameters;

23615 continue;

23616 }

23617 #endif

23618 #ifdef GL_EXT_polygon_offset

23619 if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))

23620 {

23621 ret = GLEW_EXT_polygon_offset;

23622 continue;

23623 }

23624 #endif

23625 #ifdef GL_EXT_polygon_offset_clamp

23626 if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset_clamp", 20))

23627 {

23628 ret = GLEW_EXT_polygon_offset_clamp;

23629 continue;

23630 }

23631 #endif

23632 #ifdef GL_EXT_post_depth_coverage

23633 if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_depth_coverage", 19))

23634 {

23635 ret = GLEW_EXT_post_depth_coverage;

23636 continue;

23637 }

23638 #endif

23639 #ifdef GL_EXT_provoking_vertex

23640 if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))

23641 {

23642 ret = GLEW_EXT_provoking_vertex;

23643 continue;

23644 }

23645 #endif

23646 #ifdef GL_EXT_pvrtc_sRGB

23647 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pvrtc_sRGB", 10))

23648 {

23649 ret = GLEW_EXT_pvrtc_sRGB;

23650 continue;

23651 }

23652 #endif

23653 #ifdef GL_EXT_raster_multisample

23654 if (_glewStrSame3(&pos, &len, (const GLubyte*)"raster_multisample", 18))

23655 {

23656 ret = GLEW_EXT_raster_multisample;

23657 continue;

23658 }

23659 #endif

23660 #ifdef GL_EXT_read_format_bgra

23661 if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format_bgra", 16))

23662 {

23663 ret = GLEW_EXT_read_format_bgra;

23664 continue;

23665 }

23666 #endif

23667 #ifdef GL_EXT_render_snorm

23668 if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_snorm", 12))

23669 {

23670 ret = GLEW_EXT_render_snorm;

23671 continue;

23672 }

23673 #endif

23674 #ifdef GL_EXT_rescale_normal

23675 if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))

23676 {

23677 ret = GLEW_EXT_rescale_normal;

23678 continue;

23679 }

23680 #endif

23681 #ifdef GL_EXT_sRGB

23682 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB", 4))

23683 {

23684 ret = GLEW_EXT_sRGB;

23685 continue;

23686 }

23687 #endif

23688 #ifdef GL_EXT_sRGB_write_control

23689 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB_write_control", 18))

23690 {

23691 ret = GLEW_EXT_sRGB_write_control;

23692 continue;

23693 }

23694 #endif

23695 #ifdef GL_EXT_scene_marker

23696 if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

23697 {

23698 ret = GLEW_EXT_scene_marker;

23699 continue;

23700 }

23701 #endif

23702 #ifdef GL_EXT_secondary_color

23703 if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))

23704 {

23705 ret = GLEW_EXT_secondary_color;

23706 continue;

23707 }

23708 #endif

23709 #ifdef GL_EXT_semaphore

23710 if (_glewStrSame3(&pos, &len, (const GLubyte*)"semaphore", 9))

23711 {

23712 ret = GLEW_EXT_semaphore;

23713 continue;

23714 }

23715 #endif

23716 #ifdef GL_EXT_semaphore_fd

23717 if (_glewStrSame3(&pos, &len, (const GLubyte*)"semaphore_fd", 12))

23718 {

23719 ret = GLEW_EXT_semaphore_fd;

23720 continue;

23721 }

23722 #endif

23723 #ifdef GL_EXT_semaphore_win32

23724 if (_glewStrSame3(&pos, &len, (const GLubyte*)"semaphore_win32", 15))

23725 {

23726 ret = GLEW_EXT_semaphore_win32;

23727 continue;

23728 }

23729 #endif

23730 #ifdef GL_EXT_separate_shader_objects

23731 if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))

23732 {

23733 ret = GLEW_EXT_separate_shader_objects;

23734 continue;

23735 }

23736 #endif

23737 #ifdef GL_EXT_separate_specular_color

23738 if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))

23739 {

23740 ret = GLEW_EXT_separate_specular_color;

23741 continue;

23742 }

23743 #endif

23744 #ifdef GL_EXT_shader_framebuffer_fetch

23745 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24))

23746 {

23747 ret = GLEW_EXT_shader_framebuffer_fetch;

23748 continue;

23749 }

23750 #endif

23751 #ifdef GL_EXT_shader_group_vote

23752 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_group_vote", 17))

23753 {

23754 ret = GLEW_EXT_shader_group_vote;

23755 continue;

23756 }

23757 #endif

23758 #ifdef GL_EXT_shader_image_load_formatted

23759 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_formatted", 27))

23760 {

23761 ret = GLEW_EXT_shader_image_load_formatted;

23762 continue;

23763 }

23764 #endif

23765 #ifdef GL_EXT_shader_image_load_store

23766 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))

23767 {

23768 ret = GLEW_EXT_shader_image_load_store;

23769 continue;

23770 }

23771 #endif

23772 #ifdef GL_EXT_shader_implicit_conversions

23773 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_implicit_conversions", 27))

23774 {

23775 ret = GLEW_EXT_shader_implicit_conversions;

23776 continue;

23777 }

23778 #endif

23779 #ifdef GL_EXT_shader_integer_mix

23780 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_integer_mix", 18))

23781 {

23782 ret = GLEW_EXT_shader_integer_mix;

23783 continue;

23784 }

23785 #endif

23786 #ifdef GL_EXT_shader_io_blocks

23787 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_io_blocks", 16))

23788 {

23789 ret = GLEW_EXT_shader_io_blocks;

23790 continue;

23791 }

23792 #endif

23793 #ifdef GL_EXT_shader_non_constant_global_initializers

23794 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_non_constant_global_initializers", 39))

23795 {

23796 ret = GLEW_EXT_shader_non_constant_global_initializers;

23797 continue;

23798 }

23799 #endif

23800 #ifdef GL_EXT_shader_pixel_local_storage

23801 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_pixel_local_storage", 26))

23802 {

23803 ret = GLEW_EXT_shader_pixel_local_storage;

23804 continue;

23805 }

23806 #endif

23807 #ifdef GL_EXT_shader_pixel_local_storage2

23808 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_pixel_local_storage2", 27))

23809 {

23810 ret = GLEW_EXT_shader_pixel_local_storage2;

23811 continue;

23812 }

23813 #endif

23814 #ifdef GL_EXT_shader_texture_lod

23815 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))

23816 {

23817 ret = GLEW_EXT_shader_texture_lod;

23818 continue;

23819 }

23820 #endif

23821 #ifdef GL_EXT_shadow_funcs

23822 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))

23823 {

23824 ret = GLEW_EXT_shadow_funcs;

23825 continue;

23826 }

23827 #endif

23828 #ifdef GL_EXT_shadow_samplers

23829 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers", 15))

23830 {

23831 ret = GLEW_EXT_shadow_samplers;

23832 continue;

23833 }

23834 #endif

23835 #ifdef GL_EXT_shared_texture_palette

23836 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))

23837 {

23838 ret = GLEW_EXT_shared_texture_palette;

23839 continue;

23840 }

23841 #endif

23842 #ifdef GL_EXT_sparse_texture

23843 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14))

23844 {

23845 ret = GLEW_EXT_sparse_texture;

23846 continue;

23847 }

23848 #endif

23849 #ifdef GL_EXT_sparse_texture2

23850 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture2", 15))

23851 {

23852 ret = GLEW_EXT_sparse_texture2;

23853 continue;

23854 }

23855 #endif

23856 #ifdef GL_EXT_stencil_clear_tag

23857 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17))

23858 {

23859 ret = GLEW_EXT_stencil_clear_tag;

23860 continue;

23861 }

23862 #endif

23863 #ifdef GL_EXT_stencil_two_side

23864 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))

23865 {

23866 ret = GLEW_EXT_stencil_two_side;

23867 continue;

23868 }

23869 #endif

23870 #ifdef GL_EXT_stencil_wrap

23871 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))

23872 {

23873 ret = GLEW_EXT_stencil_wrap;

23874 continue;

23875 }

23876 #endif

23877 #ifdef GL_EXT_subtexture

23878 if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))

23879 {

23880 ret = GLEW_EXT_subtexture;

23881 continue;

23882 }

23883 #endif

23884 #ifdef GL_EXT_texture

23885 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))

23886 {

23887 ret = GLEW_EXT_texture;

23888 continue;

23889 }

23890 #endif

23891 #ifdef GL_EXT_texture3D

23892 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))

23893 {

23894 ret = GLEW_EXT_texture3D;

23895 continue;

23896 }

23897 #endif

23898 #ifdef GL_EXT_texture_array

23899 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))

23900 {

23901 ret = GLEW_EXT_texture_array;

23902 continue;

23903 }

23904 #endif

23905 #ifdef GL_EXT_texture_buffer_object

23906 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))

23907 {

23908 ret = GLEW_EXT_texture_buffer_object;

23909 continue;

23910 }

23911 #endif

23912 #ifdef GL_EXT_texture_compression_astc_decode_mode

23913 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_decode_mode", 36))

23914 {

23915 ret = GLEW_EXT_texture_compression_astc_decode_mode;

23916 continue;

23917 }

23918 #endif

23919 #ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5

23920 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_decode_mode_rgb9e5", 43))

23921 {

23922 ret = GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5;

23923 continue;

23924 }

23925 #endif

23926 #ifdef GL_EXT_texture_compression_bptc

23927 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24))

23928 {

23929 ret = GLEW_EXT_texture_compression_bptc;

23930 continue;

23931 }

23932 #endif

23933 #ifdef GL_EXT_texture_compression_dxt1

23934 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))

23935 {

23936 ret = GLEW_EXT_texture_compression_dxt1;

23937 continue;

23938 }

23939 #endif

23940 #ifdef GL_EXT_texture_compression_latc

23941 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))

23942 {

23943 ret = GLEW_EXT_texture_compression_latc;

23944 continue;

23945 }

23946 #endif

23947 #ifdef GL_EXT_texture_compression_rgtc

23948 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))

23949 {

23950 ret = GLEW_EXT_texture_compression_rgtc;

23951 continue;

23952 }

23953 #endif

23954 #ifdef GL_EXT_texture_compression_s3tc

23955 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))

23956 {

23957 ret = GLEW_EXT_texture_compression_s3tc;

23958 continue;

23959 }

23960 #endif

23961 #ifdef GL_EXT_texture_cube_map

23962 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

23963 {

23964 ret = GLEW_EXT_texture_cube_map;

23965 continue;

23966 }

23967 #endif

23968 #ifdef GL_EXT_texture_cube_map_array

23969 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22))

23970 {

23971 ret = GLEW_EXT_texture_cube_map_array;

23972 continue;

23973 }

23974 #endif

23975 #ifdef GL_EXT_texture_edge_clamp

23976 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

23977 {

23978 ret = GLEW_EXT_texture_edge_clamp;

23979 continue;

23980 }

23981 #endif

23982 #ifdef GL_EXT_texture_env

23983 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))

23984 {

23985 ret = GLEW_EXT_texture_env;

23986 continue;

23987 }

23988 #endif

23989 #ifdef GL_EXT_texture_env_add

23990 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

23991 {

23992 ret = GLEW_EXT_texture_env_add;

23993 continue;

23994 }

23995 #endif

23996 #ifdef GL_EXT_texture_env_combine

23997 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

23998 {

23999 ret = GLEW_EXT_texture_env_combine;

24000 continue;

24001 }

24002 #endif

24003 #ifdef GL_EXT_texture_env_dot3

24004 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

24005 {

24006 ret = GLEW_EXT_texture_env_dot3;

24007 continue;

24008 }

24009 #endif

24010 #ifdef GL_EXT_texture_filter_anisotropic

24011 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))

24012 {

24013 ret = GLEW_EXT_texture_filter_anisotropic;

24014 continue;

24015 }

24016 #endif

24017 #ifdef GL_EXT_texture_filter_minmax

24018 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_minmax", 21))

24019 {

24020 ret = GLEW_EXT_texture_filter_minmax;

24021 continue;

24022 }

24023 #endif

24024 #ifdef GL_EXT_texture_format_BGRA8888

24025 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_format_BGRA8888", 23))

24026 {

24027 ret = GLEW_EXT_texture_format_BGRA8888;

24028 continue;

24029 }

24030 #endif

24031 #ifdef GL_EXT_texture_integer

24032 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15))

24033 {

24034 ret = GLEW_EXT_texture_integer;

24035 continue;

24036 }

24037 #endif

24038 #ifdef GL_EXT_texture_lod_bias

24039 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

24040 {

24041 ret = GLEW_EXT_texture_lod_bias;

24042 continue;

24043 }

24044 #endif

24045 #ifdef GL_EXT_texture_mirror_clamp

24046 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))

24047 {

24048 ret = GLEW_EXT_texture_mirror_clamp;

24049 continue;

24050 }

24051 #endif

24052 #ifdef GL_EXT_texture_norm16

24053 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_norm16", 14))

24054 {

24055 ret = GLEW_EXT_texture_norm16;

24056 continue;

24057 }

24058 #endif

24059 #ifdef GL_EXT_texture_object

24060 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))

24061 {

24062 ret = GLEW_EXT_texture_object;

24063 continue;

24064 }

24065 #endif

24066 #ifdef GL_EXT_texture_perturb_normal

24067 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))

24068 {

24069 ret = GLEW_EXT_texture_perturb_normal;

24070 continue;

24071 }

24072 #endif

24073 #ifdef GL_EXT_texture_rectangle

24074 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

24075 {

24076 ret = GLEW_EXT_texture_rectangle;

24077 continue;

24078 }

24079 #endif

24080 #ifdef GL_EXT_texture_rg

24081 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10))

24082 {

24083 ret = GLEW_EXT_texture_rg;

24084 continue;

24085 }

24086 #endif

24087 #ifdef GL_EXT_texture_sRGB

24088 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12))

24089 {

24090 ret = GLEW_EXT_texture_sRGB;

24091 continue;

24092 }

24093 #endif

24094 #ifdef GL_EXT_texture_sRGB_R8

24095 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_R8", 15))

24096 {

24097 ret = GLEW_EXT_texture_sRGB_R8;

24098 continue;

24099 }

24100 #endif

24101 #ifdef GL_EXT_texture_sRGB_RG8

24102 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_RG8", 16))

24103 {

24104 ret = GLEW_EXT_texture_sRGB_RG8;

24105 continue;

24106 }

24107 #endif

24108 #ifdef GL_EXT_texture_sRGB_decode

24109 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19))

24110 {

24111 ret = GLEW_EXT_texture_sRGB_decode;

24112 continue;

24113 }

24114 #endif

24115 #ifdef GL_EXT_texture_shared_exponent

24116 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23))

24117 {

24118 ret = GLEW_EXT_texture_shared_exponent;

24119 continue;

24120 }

24121 #endif

24122 #ifdef GL_EXT_texture_snorm

24123 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13))

24124 {

24125 ret = GLEW_EXT_texture_snorm;

24126 continue;

24127 }

24128 #endif

24129 #ifdef GL_EXT_texture_storage

24130 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15))

24131 {

24132 ret = GLEW_EXT_texture_storage;

24133 continue;

24134 }

24135 #endif

24136 #ifdef GL_EXT_texture_swizzle

24137 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))

24138 {

24139 ret = GLEW_EXT_texture_swizzle;

24140 continue;

24141 }

24142 #endif

24143 #ifdef GL_EXT_texture_type_2_10_10_10_REV

24144 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_type_2_10_10_10_REV", 27))

24145 {

24146 ret = GLEW_EXT_texture_type_2_10_10_10_REV;

24147 continue;

24148 }

24149 #endif

24150 #ifdef GL_EXT_texture_view

24151 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12))

24152 {

24153 ret = GLEW_EXT_texture_view;

24154 continue;

24155 }

24156 #endif

24157 #ifdef GL_EXT_timer_query

24158 if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))

24159 {

24160 ret = GLEW_EXT_timer_query;

24161 continue;

24162 }

24163 #endif

24164 #ifdef GL_EXT_transform_feedback

24165 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))

24166 {

24167 ret = GLEW_EXT_transform_feedback;

24168 continue;

24169 }

24170 #endif

24171 #ifdef GL_EXT_unpack_subimage

24172 if (_glewStrSame3(&pos, &len, (const GLubyte*)"unpack_subimage", 15))

24173 {

24174 ret = GLEW_EXT_unpack_subimage;

24175 continue;

24176 }

24177 #endif

24178 #ifdef GL_EXT_vertex_array

24179 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))

24180 {

24181 ret = GLEW_EXT_vertex_array;

24182 continue;

24183 }

24184 #endif

24185 #ifdef GL_EXT_vertex_array_bgra

24186 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))

24187 {

24188 ret = GLEW_EXT_vertex_array_bgra;

24189 continue;

24190 }

24191 #endif

24192 #ifdef GL_EXT_vertex_array_setXXX

24193 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_setXXX", 19))

24194 {

24195 ret = GLEW_EXT_vertex_array_setXXX;

24196 continue;

24197 }

24198 #endif

24199 #ifdef GL_EXT_vertex_attrib_64bit

24200 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))

24201 {

24202 ret = GLEW_EXT_vertex_attrib_64bit;

24203 continue;

24204 }

24205 #endif

24206 #ifdef GL_EXT_vertex_shader

24207 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

24208 {

24209 ret = GLEW_EXT_vertex_shader;

24210 continue;

24211 }

24212 #endif

24213 #ifdef GL_EXT_vertex_weighting

24214 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))

24215 {

24216 ret = GLEW_EXT_vertex_weighting;

24217 continue;

24218 }

24219 #endif

24220 #ifdef GL_EXT_win32_keyed_mutex

24221 if (_glewStrSame3(&pos, &len, (const GLubyte*)"win32_keyed_mutex", 17))

24222 {

24223 ret = GLEW_EXT_win32_keyed_mutex;

24224 continue;

24225 }

24226 #endif

24227 #ifdef GL_EXT_window_rectangles

24228 if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_rectangles", 17))

24229 {

24230 ret = GLEW_EXT_window_rectangles;

24231 continue;

24232 }

24233 #endif

24234 #ifdef GL_EXT_x11_sync_object

24235 if (_glewStrSame3(&pos, &len, (const GLubyte*)"x11_sync_object", 15))

24236 {

24237 ret = GLEW_EXT_x11_sync_object;

24238 continue;

24239 }

24240 #endif

24241 }

24242 if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8))

24243 {

24244 #ifdef GL_GREMEDY_frame_terminator

24245 if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16))

24246 {

24247 ret = GLEW_GREMEDY_frame_terminator;

24248 continue;

24249 }

24250 #endif

24251 #ifdef GL_GREMEDY_string_marker

24252 if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13))

24253 {

24254 ret = GLEW_GREMEDY_string_marker;

24255 continue;

24256 }

24257 #endif

24258 }

24259 if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))

24260 {

24261 #ifdef GL_HP_convolution_border_modes

24262 if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

24263 {

24264 ret = GLEW_HP_convolution_border_modes;

24265 continue;

24266 }

24267 #endif

24268 #ifdef GL_HP_image_transform

24269 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))

24270 {

24271 ret = GLEW_HP_image_transform;

24272 continue;

24273 }

24274 #endif

24275 #ifdef GL_HP_occlusion_test

24276 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))

24277 {

24278 ret = GLEW_HP_occlusion_test;

24279 continue;

24280 }

24281 #endif

24282 #ifdef GL_HP_texture_lighting

24283 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))

24284 {

24285 ret = GLEW_HP_texture_lighting;

24286 continue;

24287 }

24288 #endif

24289 }

24290 if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))

24291 {

24292 #ifdef GL_IBM_cull_vertex

24293 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

24294 {

24295 ret = GLEW_IBM_cull_vertex;

24296 continue;

24297 }

24298 #endif

24299 #ifdef GL_IBM_multimode_draw_arrays

24300 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))

24301 {

24302 ret = GLEW_IBM_multimode_draw_arrays;

24303 continue;

24304 }

24305 #endif

24306 #ifdef GL_IBM_rasterpos_clip

24307 if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))

24308 {

24309 ret = GLEW_IBM_rasterpos_clip;

24310 continue;

24311 }

24312 #endif

24313 #ifdef GL_IBM_static_data

24314 if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))

24315 {

24316 ret = GLEW_IBM_static_data;

24317 continue;

24318 }

24319 #endif

24320 #ifdef GL_IBM_texture_mirrored_repeat

24321 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

24322 {

24323 ret = GLEW_IBM_texture_mirrored_repeat;

24324 continue;

24325 }

24326 #endif

24327 #ifdef GL_IBM_vertex_array_lists

24328 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))

24329 {

24330 ret = GLEW_IBM_vertex_array_lists;

24331 continue;

24332 }

24333 #endif

24334 }

24335 if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))

24336 {

24337 #ifdef GL_INGR_color_clamp

24338 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))

24339 {

24340 ret = GLEW_INGR_color_clamp;

24341 continue;

24342 }

24343 #endif

24344 #ifdef GL_INGR_interlace_read

24345 if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))

24346 {

24347 ret = GLEW_INGR_interlace_read;

24348 continue;

24349 }

24350 #endif

24351 }

24352 if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))

24353 {

24354 #ifdef GL_INTEL_conservative_rasterization

24355 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_rasterization", 26))

24356 {

24357 ret = GLEW_INTEL_conservative_rasterization;

24358 continue;

24359 }

24360 #endif

24361 #ifdef GL_INTEL_fragment_shader_ordering

24362 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_ordering", 24))

24363 {

24364 ret = GLEW_INTEL_fragment_shader_ordering;

24365 continue;

24366 }

24367 #endif

24368 #ifdef GL_INTEL_framebuffer_CMAA

24369 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_CMAA", 16))

24370 {

24371 ret = GLEW_INTEL_framebuffer_CMAA;

24372 continue;

24373 }

24374 #endif

24375 #ifdef GL_INTEL_map_texture

24376 if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_texture", 11))

24377 {

24378 ret = GLEW_INTEL_map_texture;

24379 continue;

24380 }

24381 #endif

24382 #ifdef GL_INTEL_parallel_arrays

24383 if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))

24384 {

24385 ret = GLEW_INTEL_parallel_arrays;

24386 continue;

24387 }

24388 #endif

24389 #ifdef GL_INTEL_performance_query

24390 if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_query", 17))

24391 {

24392 ret = GLEW_INTEL_performance_query;

24393 continue;

24394 }

24395 #endif

24396 #ifdef GL_INTEL_texture_scissor

24397 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))

24398 {

24399 ret = GLEW_INTEL_texture_scissor;

24400 continue;

24401 }

24402 #endif

24403 }

24404 if (_glewStrSame2(&pos, &len, (const GLubyte*)"KHR_", 4))

24405 {

24406 #ifdef GL_KHR_blend_equation_advanced

24407 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced", 23))

24408 {

24409 ret = GLEW_KHR_blend_equation_advanced;

24410 continue;

24411 }

24412 #endif

24413 #ifdef GL_KHR_blend_equation_advanced_coherent

24414 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced_coherent", 32))

24415 {

24416 ret = GLEW_KHR_blend_equation_advanced_coherent;

24417 continue;

24418 }

24419 #endif

24420 #ifdef GL_KHR_context_flush_control

24421 if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21))

24422 {

24423 ret = GLEW_KHR_context_flush_control;

24424 continue;

24425 }

24426 #endif

24427 #ifdef GL_KHR_debug

24428 if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug", 5))

24429 {

24430 ret = GLEW_KHR_debug;

24431 continue;

24432 }

24433 #endif

24434 #ifdef GL_KHR_no_error

24435 if (_glewStrSame3(&pos, &len, (const GLubyte*)"no_error", 8))

24436 {

24437 ret = GLEW_KHR_no_error;

24438 continue;

24439 }

24440 #endif

24441 #ifdef GL_KHR_parallel_shader_compile

24442 if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_shader_compile", 23))

24443 {

24444 ret = GLEW_KHR_parallel_shader_compile;

24445 continue;

24446 }

24447 #endif

24448 #ifdef GL_KHR_robust_buffer_access_behavior

24449 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29))

24450 {

24451 ret = GLEW_KHR_robust_buffer_access_behavior;

24452 continue;

24453 }

24454 #endif

24455 #ifdef GL_KHR_robustness

24456 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10))

24457 {

24458 ret = GLEW_KHR_robustness;

24459 continue;

24460 }

24461 #endif

24462 #ifdef GL_KHR_texture_compression_astc_hdr

24463 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_hdr", 28))

24464 {

24465 ret = GLEW_KHR_texture_compression_astc_hdr;

24466 continue;

24467 }

24468 #endif

24469 #ifdef GL_KHR_texture_compression_astc_ldr

24470 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_ldr", 28))

24471 {

24472 ret = GLEW_KHR_texture_compression_astc_ldr;

24473 continue;

24474 }

24475 #endif

24476 #ifdef GL_KHR_texture_compression_astc_sliced_3d

24477 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_sliced_3d", 34))

24478 {

24479 ret = GLEW_KHR_texture_compression_astc_sliced_3d;

24480 continue;

24481 }

24482 #endif

24483 }

24484 if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))

24485 {

24486 #ifdef GL_KTX_buffer_region

24487 if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

24488 {

24489 ret = GLEW_KTX_buffer_region;

24490 continue;

24491 }

24492 #endif

24493 }

24494 if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6))

24495 {

24496 #ifdef GL_MESAX_texture_stack

24497 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13))

24498 {

24499 ret = GLEW_MESAX_texture_stack;

24500 continue;

24501 }

24502 #endif

24503 }

24504 if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

24505 {

24506 #ifdef GL_MESA_pack_invert

24507 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))

24508 {

24509 ret = GLEW_MESA_pack_invert;

24510 continue;

24511 }

24512 #endif

24513 #ifdef GL_MESA_resize_buffers

24514 if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))

24515 {

24516 ret = GLEW_MESA_resize_buffers;

24517 continue;

24518 }

24519 #endif

24520 #ifdef GL_MESA_shader_integer_functions

24521 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_integer_functions", 24))

24522 {

24523 ret = GLEW_MESA_shader_integer_functions;

24524 continue;

24525 }

24526 #endif

24527 #ifdef GL_MESA_window_pos

24528 if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

24529 {

24530 ret = GLEW_MESA_window_pos;

24531 continue;

24532 }

24533 #endif

24534 #ifdef GL_MESA_ycbcr_texture

24535 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))

24536 {

24537 ret = GLEW_MESA_ycbcr_texture;

24538 continue;

24539 }

24540 #endif

24541 }

24542 if (_glewStrSame2(&pos, &len, (const GLubyte*)"NVX_", 4))

24543 {

24544 #ifdef GL_NVX_blend_equation_advanced_multi_draw_buffers

24545 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced_multi_draw_buffers", 42))

24546 {

24547 ret = GLEW_NVX_blend_equation_advanced_multi_draw_buffers;

24548 continue;

24549 }

24550 #endif

24551 #ifdef GL_NVX_conditional_render

24552 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))

24553 {

24554 ret = GLEW_NVX_conditional_render;

24555 continue;

24556 }

24557 #endif

24558 #ifdef GL_NVX_gpu_memory_info

24559 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_memory_info", 15))

24560 {

24561 ret = GLEW_NVX_gpu_memory_info;

24562 continue;

24563 }

24564 #endif

24565 #ifdef GL_NVX_linked_gpu_multicast

24566 if (_glewStrSame3(&pos, &len, (const GLubyte*)"linked_gpu_multicast", 20))

24567 {

24568 ret = GLEW_NVX_linked_gpu_multicast;

24569 continue;

24570 }

24571 #endif

24572 }

24573 if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

24574 {

24575 #ifdef GL_NV_3dvision_settings

24576 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3dvision_settings", 17))

24577 {

24578 ret = GLEW_NV_3dvision_settings;

24579 continue;

24580 }

24581 #endif

24582 #ifdef GL_NV_EGL_stream_consumer_external

24583 if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_stream_consumer_external", 28))

24584 {

24585 ret = GLEW_NV_EGL_stream_consumer_external;

24586 continue;

24587 }

24588 #endif

24589 #ifdef GL_NV_alpha_to_coverage_dither_control

24590 if (_glewStrSame3(&pos, &len, (const GLubyte*)"alpha_to_coverage_dither_control", 32))

24591 {

24592 ret = GLEW_NV_alpha_to_coverage_dither_control;

24593 continue;

24594 }

24595 #endif

24596 #ifdef GL_NV_bgr

24597 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgr", 3))

24598 {

24599 ret = GLEW_NV_bgr;

24600 continue;

24601 }

24602 #endif

24603 #ifdef GL_NV_bindless_multi_draw_indirect

24604 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_multi_draw_indirect", 28))

24605 {

24606 ret = GLEW_NV_bindless_multi_draw_indirect;

24607 continue;

24608 }

24609 #endif

24610 #ifdef GL_NV_bindless_multi_draw_indirect_count

24611 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_multi_draw_indirect_count", 34))

24612 {

24613 ret = GLEW_NV_bindless_multi_draw_indirect_count;

24614 continue;

24615 }

24616 #endif

24617 #ifdef GL_NV_bindless_texture

24618 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16))

24619 {

24620 ret = GLEW_NV_bindless_texture;

24621 continue;

24622 }

24623 #endif

24624 #ifdef GL_NV_blend_equation_advanced

24625 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced", 23))

24626 {

24627 ret = GLEW_NV_blend_equation_advanced;

24628 continue;

24629 }

24630 #endif

24631 #ifdef GL_NV_blend_equation_advanced_coherent

24632 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced_coherent", 32))

24633 {

24634 ret = GLEW_NV_blend_equation_advanced_coherent;

24635 continue;

24636 }

24637 #endif

24638 #ifdef GL_NV_blend_minmax_factor

24639 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19))

24640 {

24641 ret = GLEW_NV_blend_minmax_factor;

24642 continue;

24643 }

24644 #endif

24645 #ifdef GL_NV_blend_square

24646 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))

24647 {

24648 ret = GLEW_NV_blend_square;

24649 continue;

24650 }

24651 #endif

24652 #ifdef GL_NV_clip_space_w_scaling

24653 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_space_w_scaling", 20))

24654 {

24655 ret = GLEW_NV_clip_space_w_scaling;

24656 continue;

24657 }

24658 #endif

24659 #ifdef GL_NV_command_list

24660 if (_glewStrSame3(&pos, &len, (const GLubyte*)"command_list", 12))

24661 {

24662 ret = GLEW_NV_command_list;

24663 continue;

24664 }

24665 #endif

24666 #ifdef GL_NV_compute_program5

24667 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_program5", 16))

24668 {

24669 ret = GLEW_NV_compute_program5;

24670 continue;

24671 }

24672 #endif

24673 #ifdef GL_NV_conditional_render

24674 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))

24675 {

24676 ret = GLEW_NV_conditional_render;

24677 continue;

24678 }

24679 #endif

24680 #ifdef GL_NV_conservative_raster

24681 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster", 19))

24682 {

24683 ret = GLEW_NV_conservative_raster;

24684 continue;

24685 }

24686 #endif

24687 #ifdef GL_NV_conservative_raster_dilate

24688 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster_dilate", 26))

24689 {

24690 ret = GLEW_NV_conservative_raster_dilate;

24691 continue;

24692 }

24693 #endif

24694 #ifdef GL_NV_conservative_raster_pre_snap_triangles

24695 if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster_pre_snap_triangles", 38))

24696 {

24697 ret = GLEW_NV_conservative_raster_pre_snap_triangles;

24698 continue;

24699 }

24700 #endif

24701 #ifdef GL_NV_copy_buffer

24702 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))

24703 {

24704 ret = GLEW_NV_copy_buffer;

24705 continue;

24706 }

24707 #endif

24708 #ifdef GL_NV_copy_depth_to_color

24709 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))

24710 {

24711 ret = GLEW_NV_copy_depth_to_color;

24712 continue;

24713 }

24714 #endif

24715 #ifdef GL_NV_copy_image

24716 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))

24717 {

24718 ret = GLEW_NV_copy_image;

24719 continue;

24720 }

24721 #endif

24722 #ifdef GL_NV_deep_texture3D

24723 if (_glewStrSame3(&pos, &len, (const GLubyte*)"deep_texture3D", 14))

24724 {

24725 ret = GLEW_NV_deep_texture3D;

24726 continue;

24727 }

24728 #endif

24729 #ifdef GL_NV_depth_buffer_float

24730 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))

24731 {

24732 ret = GLEW_NV_depth_buffer_float;

24733 continue;

24734 }

24735 #endif

24736 #ifdef GL_NV_depth_clamp

24737 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))

24738 {

24739 ret = GLEW_NV_depth_clamp;

24740 continue;

24741 }

24742 #endif

24743 #ifdef GL_NV_depth_range_unclamped

24744 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21))

24745 {

24746 ret = GLEW_NV_depth_range_unclamped;

24747 continue;

24748 }

24749 #endif

24750 #ifdef GL_NV_draw_buffers

24751 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

24752 {

24753 ret = GLEW_NV_draw_buffers;

24754 continue;

24755 }

24756 #endif

24757 #ifdef GL_NV_draw_instanced

24758 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))

24759 {

24760 ret = GLEW_NV_draw_instanced;

24761 continue;

24762 }

24763 #endif

24764 #ifdef GL_NV_draw_texture

24765 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_texture", 12))

24766 {

24767 ret = GLEW_NV_draw_texture;

24768 continue;

24769 }

24770 #endif

24771 #ifdef GL_NV_draw_vulkan_image

24772 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_vulkan_image", 17))

24773 {

24774 ret = GLEW_NV_draw_vulkan_image;

24775 continue;

24776 }

24777 #endif

24778 #ifdef GL_NV_evaluators

24779 if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))

24780 {

24781 ret = GLEW_NV_evaluators;

24782 continue;

24783 }

24784 #endif

24785 #ifdef GL_NV_explicit_attrib_location

24786 if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24))

24787 {

24788 ret = GLEW_NV_explicit_attrib_location;

24789 continue;

24790 }

24791 #endif

24792 #ifdef GL_NV_explicit_multisample

24793 if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20))

24794 {

24795 ret = GLEW_NV_explicit_multisample;

24796 continue;

24797 }

24798 #endif

24799 #ifdef GL_NV_fbo_color_attachments

24800 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbo_color_attachments", 21))

24801 {

24802 ret = GLEW_NV_fbo_color_attachments;

24803 continue;

24804 }

24805 #endif

24806 #ifdef GL_NV_fence

24807 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

24808 {

24809 ret = GLEW_NV_fence;

24810 continue;

24811 }

24812 #endif

24813 #ifdef GL_NV_fill_rectangle

24814 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fill_rectangle", 14))

24815 {

24816 ret = GLEW_NV_fill_rectangle;

24817 continue;

24818 }

24819 #endif

24820 #ifdef GL_NV_float_buffer

24821 if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

24822 {

24823 ret = GLEW_NV_float_buffer;

24824 continue;

24825 }

24826 #endif

24827 #ifdef GL_NV_fog_distance

24828 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))

24829 {

24830 ret = GLEW_NV_fog_distance;

24831 continue;

24832 }

24833 #endif

24834 #ifdef GL_NV_fragment_coverage_to_color

24835 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coverage_to_color", 26))

24836 {

24837 ret = GLEW_NV_fragment_coverage_to_color;

24838 continue;

24839 }

24840 #endif

24841 #ifdef GL_NV_fragment_program

24842 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

24843 {

24844 ret = GLEW_NV_fragment_program;

24845 continue;

24846 }

24847 #endif

24848 #ifdef GL_NV_fragment_program2

24849 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))

24850 {

24851 ret = GLEW_NV_fragment_program2;

24852 continue;

24853 }

24854 #endif

24855 #ifdef GL_NV_fragment_program4

24856 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17))

24857 {

24858 ret = GLEW_NV_fragment_program4;

24859 continue;

24860 }

24861 #endif

24862 #ifdef GL_NV_fragment_program_option

24863 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))

24864 {

24865 ret = GLEW_NV_fragment_program_option;

24866 continue;

24867 }

24868 #endif

24869 #ifdef GL_NV_fragment_shader_interlock

24870 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_interlock", 25))

24871 {

24872 ret = GLEW_NV_fragment_shader_interlock;

24873 continue;

24874 }

24875 #endif

24876 #ifdef GL_NV_framebuffer_blit

24877 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))

24878 {

24879 ret = GLEW_NV_framebuffer_blit;

24880 continue;

24881 }

24882 #endif

24883 #ifdef GL_NV_framebuffer_mixed_samples

24884 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_mixed_samples", 25))

24885 {

24886 ret = GLEW_NV_framebuffer_mixed_samples;

24887 continue;

24888 }

24889 #endif

24890 #ifdef GL_NV_framebuffer_multisample

24891 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))

24892 {

24893 ret = GLEW_NV_framebuffer_multisample;

24894 continue;

24895 }

24896 #endif

24897 #ifdef GL_NV_framebuffer_multisample_coverage

24898 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32))

24899 {

24900 ret = GLEW_NV_framebuffer_multisample_coverage;

24901 continue;

24902 }

24903 #endif

24904 #ifdef GL_NV_generate_mipmap_sRGB

24905 if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap_sRGB", 20))

24906 {

24907 ret = GLEW_NV_generate_mipmap_sRGB;

24908 continue;

24909 }

24910 #endif

24911 #ifdef GL_NV_geometry_program4

24912 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17))

24913 {

24914 ret = GLEW_NV_geometry_program4;

24915 continue;

24916 }

24917 #endif

24918 #ifdef GL_NV_geometry_shader4

24919 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

24920 {

24921 ret = GLEW_NV_geometry_shader4;

24922 continue;

24923 }

24924 #endif

24925 #ifdef GL_NV_geometry_shader_passthrough

24926 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader_passthrough", 27))

24927 {

24928 ret = GLEW_NV_geometry_shader_passthrough;

24929 continue;

24930 }

24931 #endif

24932 #ifdef GL_NV_gpu_multicast

24933 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_multicast", 13))

24934 {

24935 ret = GLEW_NV_gpu_multicast;

24936 continue;

24937 }

24938 #endif

24939 #ifdef GL_NV_gpu_program4

24940 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12))

24941 {

24942 ret = GLEW_NV_gpu_program4;

24943 continue;

24944 }

24945 #endif

24946 #ifdef GL_NV_gpu_program5

24947 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12))

24948 {

24949 ret = GLEW_NV_gpu_program5;

24950 continue;

24951 }

24952 #endif

24953 #ifdef GL_NV_gpu_program5_mem_extended

24954 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5_mem_extended", 25))

24955 {

24956 ret = GLEW_NV_gpu_program5_mem_extended;

24957 continue;

24958 }

24959 #endif

24960 #ifdef GL_NV_gpu_program_fp64

24961 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16))

24962 {

24963 ret = GLEW_NV_gpu_program_fp64;

24964 continue;

24965 }

24966 #endif

24967 #ifdef GL_NV_gpu_shader5

24968 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))

24969 {

24970 ret = GLEW_NV_gpu_shader5;

24971 continue;

24972 }

24973 #endif

24974 #ifdef GL_NV_half_float

24975 if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))

24976 {

24977 ret = GLEW_NV_half_float;

24978 continue;

24979 }

24980 #endif

24981 #ifdef GL_NV_image_formats

24982 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_formats", 13))

24983 {

24984 ret = GLEW_NV_image_formats;

24985 continue;

24986 }

24987 #endif

24988 #ifdef GL_NV_instanced_arrays

24989 if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))

24990 {

24991 ret = GLEW_NV_instanced_arrays;

24992 continue;

24993 }

24994 #endif

24995 #ifdef GL_NV_internalformat_sample_query

24996 if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_sample_query", 27))

24997 {

24998 ret = GLEW_NV_internalformat_sample_query;

24999 continue;

25000 }

25001 #endif

25002 #ifdef GL_NV_light_max_exponent

25003 if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))

25004 {

25005 ret = GLEW_NV_light_max_exponent;

25006 continue;

25007 }

25008 #endif

25009 #ifdef GL_NV_multisample_coverage

25010 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))

25011 {

25012 ret = GLEW_NV_multisample_coverage;

25013 continue;

25014 }

25015 #endif

25016 #ifdef GL_NV_multisample_filter_hint

25017 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))

25018 {

25019 ret = GLEW_NV_multisample_filter_hint;

25020 continue;

25021 }

25022 #endif

25023 #ifdef GL_NV_non_square_matrices

25024 if (_glewStrSame3(&pos, &len, (const GLubyte*)"non_square_matrices", 19))

25025 {

25026 ret = GLEW_NV_non_square_matrices;

25027 continue;

25028 }

25029 #endif

25030 #ifdef GL_NV_occlusion_query

25031 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

25032 {

25033 ret = GLEW_NV_occlusion_query;

25034 continue;

25035 }

25036 #endif

25037 #ifdef GL_NV_pack_subimage

25038 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_subimage", 13))

25039 {

25040 ret = GLEW_NV_pack_subimage;

25041 continue;

25042 }

25043 #endif

25044 #ifdef GL_NV_packed_depth_stencil

25045 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

25046 {

25047 ret = GLEW_NV_packed_depth_stencil;

25048 continue;

25049 }

25050 #endif

25051 #ifdef GL_NV_packed_float

25052 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))

25053 {

25054 ret = GLEW_NV_packed_float;

25055 continue;

25056 }

25057 #endif

25058 #ifdef GL_NV_packed_float_linear

25059 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float_linear", 19))

25060 {

25061 ret = GLEW_NV_packed_float_linear;

25062 continue;

25063 }

25064 #endif

25065 #ifdef GL_NV_parameter_buffer_object

25066 if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23))

25067 {

25068 ret = GLEW_NV_parameter_buffer_object;

25069 continue;

25070 }

25071 #endif

25072 #ifdef GL_NV_parameter_buffer_object2

25073 if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24))

25074 {

25075 ret = GLEW_NV_parameter_buffer_object2;

25076 continue;

25077 }

25078 #endif

25079 #ifdef GL_NV_path_rendering

25080 if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering", 14))

25081 {

25082 ret = GLEW_NV_path_rendering;

25083 continue;

25084 }

25085 #endif

25086 #ifdef GL_NV_path_rendering_shared_edge

25087 if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering_shared_edge", 26))

25088 {

25089 ret = GLEW_NV_path_rendering_shared_edge;

25090 continue;

25091 }

25092 #endif

25093 #ifdef GL_NV_pixel_buffer_object

25094 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

25095 {

25096 ret = GLEW_NV_pixel_buffer_object;

25097 continue;

25098 }

25099 #endif

25100 #ifdef GL_NV_pixel_data_range

25101 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))

25102 {

25103 ret = GLEW_NV_pixel_data_range;

25104 continue;

25105 }

25106 #endif

25107 #ifdef GL_NV_platform_binary

25108 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_binary", 15))

25109 {

25110 ret = GLEW_NV_platform_binary;

25111 continue;

25112 }

25113 #endif

25114 #ifdef GL_NV_point_sprite

25115 if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

25116 {

25117 ret = GLEW_NV_point_sprite;

25118 continue;

25119 }

25120 #endif

25121 #ifdef GL_NV_polygon_mode

25122 if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_mode", 12))

25123 {

25124 ret = GLEW_NV_polygon_mode;

25125 continue;

25126 }

25127 #endif

25128 #ifdef GL_NV_present_video

25129 if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))

25130 {

25131 ret = GLEW_NV_present_video;

25132 continue;

25133 }

25134 #endif

25135 #ifdef GL_NV_primitive_restart

25136 if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))

25137 {

25138 ret = GLEW_NV_primitive_restart;

25139 continue;

25140 }

25141 #endif

25142 #ifdef GL_NV_read_depth

25143 if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_depth", 10))

25144 {

25145 ret = GLEW_NV_read_depth;

25146 continue;

25147 }

25148 #endif

25149 #ifdef GL_NV_read_depth_stencil

25150 if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_depth_stencil", 18))

25151 {

25152 ret = GLEW_NV_read_depth_stencil;

25153 continue;

25154 }

25155 #endif

25156 #ifdef GL_NV_read_stencil

25157 if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_stencil", 12))

25158 {

25159 ret = GLEW_NV_read_stencil;

25160 continue;

25161 }

25162 #endif

25163 #ifdef GL_NV_register_combiners

25164 if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))

25165 {

25166 ret = GLEW_NV_register_combiners;

25167 continue;

25168 }

25169 #endif

25170 #ifdef GL_NV_register_combiners2

25171 if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))

25172 {

25173 ret = GLEW_NV_register_combiners2;

25174 continue;

25175 }

25176 #endif

25177 #ifdef GL_NV_robustness_video_memory_purge

25178 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_video_memory_purge", 29))

25179 {

25180 ret = GLEW_NV_robustness_video_memory_purge;

25181 continue;

25182 }

25183 #endif

25184 #ifdef GL_NV_sRGB_formats

25185 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB_formats", 12))

25186 {

25187 ret = GLEW_NV_sRGB_formats;

25188 continue;

25189 }

25190 #endif

25191 #ifdef GL_NV_sample_locations

25192 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_locations", 16))

25193 {

25194 ret = GLEW_NV_sample_locations;

25195 continue;

25196 }

25197 #endif

25198 #ifdef GL_NV_sample_mask_override_coverage

25199 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_mask_override_coverage", 29))

25200 {

25201 ret = GLEW_NV_sample_mask_override_coverage;

25202 continue;

25203 }

25204 #endif

25205 #ifdef GL_NV_shader_atomic_counters

25206 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22))

25207 {

25208 ret = GLEW_NV_shader_atomic_counters;

25209 continue;

25210 }

25211 #endif

25212 #ifdef GL_NV_shader_atomic_float

25213 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_float", 19))

25214 {

25215 ret = GLEW_NV_shader_atomic_float;

25216 continue;

25217 }

25218 #endif

25219 #ifdef GL_NV_shader_atomic_float64

25220 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_float64", 21))

25221 {

25222 ret = GLEW_NV_shader_atomic_float64;

25223 continue;

25224 }

25225 #endif

25226 #ifdef GL_NV_shader_atomic_fp16_vector

25227 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_fp16_vector", 25))

25228 {

25229 ret = GLEW_NV_shader_atomic_fp16_vector;

25230 continue;

25231 }

25232 #endif

25233 #ifdef GL_NV_shader_atomic_int64

25234 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_int64", 19))

25235 {

25236 ret = GLEW_NV_shader_atomic_int64;

25237 continue;

25238 }

25239 #endif

25240 #ifdef GL_NV_shader_buffer_load

25241 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18))

25242 {

25243 ret = GLEW_NV_shader_buffer_load;

25244 continue;

25245 }

25246 #endif

25247 #ifdef GL_NV_shader_noperspective_interpolation

25248 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_noperspective_interpolation", 34))

25249 {

25250 ret = GLEW_NV_shader_noperspective_interpolation;

25251 continue;

25252 }

25253 #endif

25254 #ifdef GL_NV_shader_storage_buffer_object

25255 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28))

25256 {

25257 ret = GLEW_NV_shader_storage_buffer_object;

25258 continue;

25259 }

25260 #endif

25261 #ifdef GL_NV_shader_thread_group

25262 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_thread_group", 19))

25263 {

25264 ret = GLEW_NV_shader_thread_group;

25265 continue;

25266 }

25267 #endif

25268 #ifdef GL_NV_shader_thread_shuffle

25269 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_thread_shuffle", 21))

25270 {

25271 ret = GLEW_NV_shader_thread_shuffle;

25272 continue;

25273 }

25274 #endif

25275 #ifdef GL_NV_shadow_samplers_array

25276 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers_array", 21))

25277 {

25278 ret = GLEW_NV_shadow_samplers_array;

25279 continue;

25280 }

25281 #endif

25282 #ifdef GL_NV_shadow_samplers_cube

25283 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers_cube", 20))

25284 {

25285 ret = GLEW_NV_shadow_samplers_cube;

25286 continue;

25287 }

25288 #endif

25289 #ifdef GL_NV_stereo_view_rendering

25290 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_view_rendering", 21))

25291 {

25292 ret = GLEW_NV_stereo_view_rendering;

25293 continue;

25294 }

25295 #endif

25296 #ifdef GL_NV_tessellation_program5

25297 if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21))

25298 {

25299 ret = GLEW_NV_tessellation_program5;

25300 continue;

25301 }

25302 #endif

25303 #ifdef GL_NV_texgen_emboss

25304 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))

25305 {

25306 ret = GLEW_NV_texgen_emboss;

25307 continue;

25308 }

25309 #endif

25310 #ifdef GL_NV_texgen_reflection

25311 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))

25312 {

25313 ret = GLEW_NV_texgen_reflection;

25314 continue;

25315 }

25316 #endif

25317 #ifdef GL_NV_texture_array

25318 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))

25319 {

25320 ret = GLEW_NV_texture_array;

25321 continue;

25322 }

25323 #endif

25324 #ifdef GL_NV_texture_barrier

25325 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15))

25326 {

25327 ret = GLEW_NV_texture_barrier;

25328 continue;

25329 }

25330 #endif

25331 #ifdef GL_NV_texture_border_clamp

25332 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

25333 {

25334 ret = GLEW_NV_texture_border_clamp;

25335 continue;

25336 }

25337 #endif

25338 #ifdef GL_NV_texture_compression_latc

25339 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))

25340 {

25341 ret = GLEW_NV_texture_compression_latc;

25342 continue;

25343 }

25344 #endif

25345 #ifdef GL_NV_texture_compression_s3tc

25346 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))

25347 {

25348 ret = GLEW_NV_texture_compression_s3tc;

25349 continue;

25350 }

25351 #endif

25352 #ifdef GL_NV_texture_compression_s3tc_update

25353 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc_update", 31))

25354 {

25355 ret = GLEW_NV_texture_compression_s3tc_update;

25356 continue;

25357 }

25358 #endif

25359 #ifdef GL_NV_texture_compression_vtc

25360 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))

25361 {

25362 ret = GLEW_NV_texture_compression_vtc;

25363 continue;

25364 }

25365 #endif

25366 #ifdef GL_NV_texture_env_combine4

25367 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))

25368 {

25369 ret = GLEW_NV_texture_env_combine4;

25370 continue;

25371 }

25372 #endif

25373 #ifdef GL_NV_texture_expand_normal

25374 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))

25375 {

25376 ret = GLEW_NV_texture_expand_normal;

25377 continue;

25378 }

25379 #endif

25380 #ifdef GL_NV_texture_multisample

25381 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))

25382 {

25383 ret = GLEW_NV_texture_multisample;

25384 continue;

25385 }

25386 #endif

25387 #ifdef GL_NV_texture_npot_2D_mipmap

25388 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_npot_2D_mipmap", 22))

25389 {

25390 ret = GLEW_NV_texture_npot_2D_mipmap;

25391 continue;

25392 }

25393 #endif

25394 #ifdef GL_NV_texture_rectangle

25395 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

25396 {

25397 ret = GLEW_NV_texture_rectangle;

25398 continue;

25399 }

25400 #endif

25401 #ifdef GL_NV_texture_rectangle_compressed

25402 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle_compressed", 28))

25403 {

25404 ret = GLEW_NV_texture_rectangle_compressed;

25405 continue;

25406 }

25407 #endif

25408 #ifdef GL_NV_texture_shader

25409 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))

25410 {

25411 ret = GLEW_NV_texture_shader;

25412 continue;

25413 }

25414 #endif

25415 #ifdef GL_NV_texture_shader2

25416 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))

25417 {

25418 ret = GLEW_NV_texture_shader2;

25419 continue;

25420 }

25421 #endif

25422 #ifdef GL_NV_texture_shader3

25423 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))

25424 {

25425 ret = GLEW_NV_texture_shader3;

25426 continue;

25427 }

25428 #endif

25429 #ifdef GL_NV_transform_feedback

25430 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))

25431 {

25432 ret = GLEW_NV_transform_feedback;

25433 continue;

25434 }

25435 #endif

25436 #ifdef GL_NV_transform_feedback2

25437 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))

25438 {

25439 ret = GLEW_NV_transform_feedback2;

25440 continue;

25441 }

25442 #endif

25443 #ifdef GL_NV_uniform_buffer_unified_memory

25444 if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_unified_memory", 29))

25445 {

25446 ret = GLEW_NV_uniform_buffer_unified_memory;

25447 continue;

25448 }

25449 #endif

25450 #ifdef GL_NV_vdpau_interop

25451 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vdpau_interop", 13))

25452 {

25453 ret = GLEW_NV_vdpau_interop;

25454 continue;

25455 }

25456 #endif

25457 #ifdef GL_NV_vertex_array_range

25458 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

25459 {

25460 ret = GLEW_NV_vertex_array_range;

25461 continue;

25462 }

25463 #endif

25464 #ifdef GL_NV_vertex_array_range2

25465 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))

25466 {

25467 ret = GLEW_NV_vertex_array_range2;

25468 continue;

25469 }

25470 #endif

25471 #ifdef GL_NV_vertex_attrib_integer_64bit

25472 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27))

25473 {

25474 ret = GLEW_NV_vertex_attrib_integer_64bit;

25475 continue;

25476 }

25477 #endif

25478 #ifdef GL_NV_vertex_buffer_unified_memory

25479 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28))

25480 {

25481 ret = GLEW_NV_vertex_buffer_unified_memory;

25482 continue;

25483 }

25484 #endif

25485 #ifdef GL_NV_vertex_program

25486 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

25487 {

25488 ret = GLEW_NV_vertex_program;

25489 continue;

25490 }

25491 #endif

25492 #ifdef GL_NV_vertex_program1_1

25493 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))

25494 {

25495 ret = GLEW_NV_vertex_program1_1;

25496 continue;

25497 }

25498 #endif

25499 #ifdef GL_NV_vertex_program2

25500 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))

25501 {

25502 ret = GLEW_NV_vertex_program2;

25503 continue;

25504 }

25505 #endif

25506 #ifdef GL_NV_vertex_program2_option

25507 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))

25508 {

25509 ret = GLEW_NV_vertex_program2_option;

25510 continue;

25511 }

25512 #endif

25513 #ifdef GL_NV_vertex_program3

25514 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))

25515 {

25516 ret = GLEW_NV_vertex_program3;

25517 continue;

25518 }

25519 #endif

25520 #ifdef GL_NV_vertex_program4

25521 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15))

25522 {

25523 ret = GLEW_NV_vertex_program4;

25524 continue;

25525 }

25526 #endif

25527 #ifdef GL_NV_video_capture

25528 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))

25529 {

25530 ret = GLEW_NV_video_capture;

25531 continue;

25532 }

25533 #endif

25534 #ifdef GL_NV_viewport_array

25535 if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14))

25536 {

25537 ret = GLEW_NV_viewport_array;

25538 continue;

25539 }

25540 #endif

25541 #ifdef GL_NV_viewport_array2

25542 if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array2", 15))

25543 {

25544 ret = GLEW_NV_viewport_array2;

25545 continue;

25546 }

25547 #endif

25548 #ifdef GL_NV_viewport_swizzle

25549 if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_swizzle", 16))

25550 {

25551 ret = GLEW_NV_viewport_swizzle;

25552 continue;

25553 }

25554 #endif

25555 }

25556 if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4))

25557 {

25558 #ifdef GL_OES_byte_coordinates

25559 if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16))

25560 {

25561 ret = GLEW_OES_byte_coordinates;

25562 continue;

25563 }

25564 #endif

25565 }

25566 if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

25567 {

25568 #ifdef GL_OML_interlace

25569 if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

25570 {

25571 ret = GLEW_OML_interlace;

25572 continue;

25573 }

25574 #endif

25575 #ifdef GL_OML_resample

25576 if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

25577 {

25578 ret = GLEW_OML_resample;

25579 continue;

25580 }

25581 #endif

25582 #ifdef GL_OML_subsample

25583 if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))

25584 {

25585 ret = GLEW_OML_subsample;

25586 continue;

25587 }

25588 #endif

25589 }

25590 if (_glewStrSame2(&pos, &len, (const GLubyte*)"OVR_", 4))

25591 {

25592 #ifdef GL_OVR_multiview

25593 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview", 9))

25594 {

25595 ret = GLEW_OVR_multiview;

25596 continue;

25597 }

25598 #endif

25599 #ifdef GL_OVR_multiview2

25600 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview2", 10))

25601 {

25602 ret = GLEW_OVR_multiview2;

25603 continue;

25604 }

25605 #endif

25606 #ifdef GL_OVR_multiview_multisampled_render_to_texture

25607 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_multisampled_render_to_texture", 40))

25608 {

25609 ret = GLEW_OVR_multiview_multisampled_render_to_texture;

25610 continue;

25611 }

25612 #endif

25613 }

25614 if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))

25615 {

25616 #ifdef GL_PGI_misc_hints

25617 if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))

25618 {

25619 ret = GLEW_PGI_misc_hints;

25620 continue;

25621 }

25622 #endif

25623 #ifdef GL_PGI_vertex_hints

25624 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))

25625 {

25626 ret = GLEW_PGI_vertex_hints;

25627 continue;

25628 }

25629 #endif

25630 }

25631 if (_glewStrSame2(&pos, &len, (const GLubyte*)"QCOM_", 5))

25632 {

25633 #ifdef GL_QCOM_alpha_test

25634 if (_glewStrSame3(&pos, &len, (const GLubyte*)"alpha_test", 10))

25635 {

25636 ret = GLEW_QCOM_alpha_test;

25637 continue;

25638 }

25639 #endif

25640 #ifdef GL_QCOM_binning_control

25641 if (_glewStrSame3(&pos, &len, (const GLubyte*)"binning_control", 15))

25642 {

25643 ret = GLEW_QCOM_binning_control;

25644 continue;

25645 }

25646 #endif

25647 #ifdef GL_QCOM_driver_control

25648 if (_glewStrSame3(&pos, &len, (const GLubyte*)"driver_control", 14))

25649 {

25650 ret = GLEW_QCOM_driver_control;

25651 continue;

25652 }

25653 #endif

25654 #ifdef GL_QCOM_extended_get

25655 if (_glewStrSame3(&pos, &len, (const GLubyte*)"extended_get", 12))

25656 {

25657 ret = GLEW_QCOM_extended_get;

25658 continue;

25659 }

25660 #endif

25661 #ifdef GL_QCOM_extended_get2

25662 if (_glewStrSame3(&pos, &len, (const GLubyte*)"extended_get2", 13))

25663 {

25664 ret = GLEW_QCOM_extended_get2;

25665 continue;

25666 }

25667 #endif

25668 #ifdef GL_QCOM_framebuffer_foveated

25669 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_foveated", 20))

25670 {

25671 ret = GLEW_QCOM_framebuffer_foveated;

25672 continue;

25673 }

25674 #endif

25675 #ifdef GL_QCOM_perfmon_global_mode

25676 if (_glewStrSame3(&pos, &len, (const GLubyte*)"perfmon_global_mode", 19))

25677 {

25678 ret = GLEW_QCOM_perfmon_global_mode;

25679 continue;

25680 }

25681 #endif

25682 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent

25683 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_noncoherent", 36))

25684 {

25685 ret = GLEW_QCOM_shader_framebuffer_fetch_noncoherent;

25686 continue;

25687 }

25688 #endif

25689 #ifdef GL_QCOM_tiled_rendering

25690 if (_glewStrSame3(&pos, &len, (const GLubyte*)"tiled_rendering", 15))

25691 {

25692 ret = GLEW_QCOM_tiled_rendering;

25693 continue;

25694 }

25695 #endif

25696 #ifdef GL_QCOM_writeonly_rendering

25697 if (_glewStrSame3(&pos, &len, (const GLubyte*)"writeonly_rendering", 19))

25698 {

25699 ret = GLEW_QCOM_writeonly_rendering;

25700 continue;

25701 }

25702 #endif

25703 }

25704 if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6))

25705 {

25706 #ifdef GL_REGAL_ES1_0_compatibility

25707 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES1_0_compatibility", 19))

25708 {

25709 ret = GLEW_REGAL_ES1_0_compatibility;

25710 continue;

25711 }

25712 #endif

25713 #ifdef GL_REGAL_ES1_1_compatibility

25714 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES1_1_compatibility", 19))

25715 {

25716 ret = GLEW_REGAL_ES1_1_compatibility;

25717 continue;

25718 }

25719 #endif

25720 #ifdef GL_REGAL_enable

25721 if (_glewStrSame3(&pos, &len, (const GLubyte*)"enable", 6))

25722 {

25723 ret = GLEW_REGAL_enable;

25724 continue;

25725 }

25726 #endif

25727 #ifdef GL_REGAL_error_string

25728 if (_glewStrSame3(&pos, &len, (const GLubyte*)"error_string", 12))

25729 {

25730 ret = GLEW_REGAL_error_string;

25731 continue;

25732 }

25733 #endif

25734 #ifdef GL_REGAL_extension_query

25735 if (_glewStrSame3(&pos, &len, (const GLubyte*)"extension_query", 15))

25736 {

25737 ret = GLEW_REGAL_extension_query;

25738 continue;

25739 }

25740 #endif

25741 #ifdef GL_REGAL_log

25742 if (_glewStrSame3(&pos, &len, (const GLubyte*)"log", 3))

25743 {

25744 ret = GLEW_REGAL_log;

25745 continue;

25746 }

25747 #endif

25748 #ifdef GL_REGAL_proc_address

25749 if (_glewStrSame3(&pos, &len, (const GLubyte*)"proc_address", 12))

25750 {

25751 ret = GLEW_REGAL_proc_address;

25752 continue;

25753 }

25754 #endif

25755 }

25756 if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))

25757 {

25758 #ifdef GL_REND_screen_coordinates

25759 if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))

25760 {

25761 ret = GLEW_REND_screen_coordinates;

25762 continue;

25763 }

25764 #endif

25765 }

25766 if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))

25767 {

25768 #ifdef GL_S3_s3tc

25769 if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))

25770 {

25771 ret = GLEW_S3_s3tc;

25772 continue;

25773 }

25774 #endif

25775 }

25776 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

25777 {

25778 #ifdef GL_SGIS_clip_band_hint

25779 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_band_hint", 14))

25780 {

25781 ret = GLEW_SGIS_clip_band_hint;

25782 continue;

25783 }

25784 #endif

25785 #ifdef GL_SGIS_color_range

25786 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

25787 {

25788 ret = GLEW_SGIS_color_range;

25789 continue;

25790 }

25791 #endif

25792 #ifdef GL_SGIS_detail_texture

25793 if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))

25794 {

25795 ret = GLEW_SGIS_detail_texture;

25796 continue;

25797 }

25798 #endif

25799 #ifdef GL_SGIS_fog_function

25800 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))

25801 {

25802 ret = GLEW_SGIS_fog_function;

25803 continue;

25804 }

25805 #endif

25806 #ifdef GL_SGIS_generate_mipmap

25807 if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))

25808 {

25809 ret = GLEW_SGIS_generate_mipmap;

25810 continue;

25811 }

25812 #endif

25813 #ifdef GL_SGIS_line_texgen

25814 if (_glewStrSame3(&pos, &len, (const GLubyte*)"line_texgen", 11))

25815 {

25816 ret = GLEW_SGIS_line_texgen;

25817 continue;

25818 }

25819 #endif

25820 #ifdef GL_SGIS_multisample

25821 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

25822 {

25823 ret = GLEW_SGIS_multisample;

25824 continue;

25825 }

25826 #endif

25827 #ifdef GL_SGIS_multitexture

25828 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))

25829 {

25830 ret = GLEW_SGIS_multitexture;

25831 continue;

25832 }

25833 #endif

25834 #ifdef GL_SGIS_pixel_texture

25835 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

25836 {

25837 ret = GLEW_SGIS_pixel_texture;

25838 continue;

25839 }

25840 #endif

25841 #ifdef GL_SGIS_point_line_texgen

25842 if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17))

25843 {

25844 ret = GLEW_SGIS_point_line_texgen;

25845 continue;

25846 }

25847 #endif

25848 #ifdef GL_SGIS_shared_multisample

25849 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))

25850 {

25851 ret = GLEW_SGIS_shared_multisample;

25852 continue;

25853 }

25854 #endif

25855 #ifdef GL_SGIS_sharpen_texture

25856 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))

25857 {

25858 ret = GLEW_SGIS_sharpen_texture;

25859 continue;

25860 }

25861 #endif

25862 #ifdef GL_SGIS_texture4D

25863 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))

25864 {

25865 ret = GLEW_SGIS_texture4D;

25866 continue;

25867 }

25868 #endif

25869 #ifdef GL_SGIS_texture_border_clamp

25870 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

25871 {

25872 ret = GLEW_SGIS_texture_border_clamp;

25873 continue;

25874 }

25875 #endif

25876 #ifdef GL_SGIS_texture_edge_clamp

25877 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

25878 {

25879 ret = GLEW_SGIS_texture_edge_clamp;

25880 continue;

25881 }

25882 #endif

25883 #ifdef GL_SGIS_texture_filter4

25884 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))

25885 {

25886 ret = GLEW_SGIS_texture_filter4;

25887 continue;

25888 }

25889 #endif

25890 #ifdef GL_SGIS_texture_lod

25891 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))

25892 {

25893 ret = GLEW_SGIS_texture_lod;

25894 continue;

25895 }

25896 #endif

25897 #ifdef GL_SGIS_texture_select

25898 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))

25899 {

25900 ret = GLEW_SGIS_texture_select;

25901 continue;

25902 }

25903 #endif

25904 }

25905 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

25906 {

25907 #ifdef GL_SGIX_async

25908 if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))

25909 {

25910 ret = GLEW_SGIX_async;

25911 continue;

25912 }

25913 #endif

25914 #ifdef GL_SGIX_async_histogram

25915 if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))

25916 {

25917 ret = GLEW_SGIX_async_histogram;

25918 continue;

25919 }

25920 #endif

25921 #ifdef GL_SGIX_async_pixel

25922 if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))

25923 {

25924 ret = GLEW_SGIX_async_pixel;

25925 continue;

25926 }

25927 #endif

25928 #ifdef GL_SGIX_bali_g_instruments

25929 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bali_g_instruments", 18))

25930 {

25931 ret = GLEW_SGIX_bali_g_instruments;

25932 continue;

25933 }

25934 #endif

25935 #ifdef GL_SGIX_bali_r_instruments

25936 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bali_r_instruments", 18))

25937 {

25938 ret = GLEW_SGIX_bali_r_instruments;

25939 continue;

25940 }

25941 #endif

25942 #ifdef GL_SGIX_bali_timer_instruments

25943 if (_glewStrSame3(&pos, &len, (const GLubyte*)"bali_timer_instruments", 22))

25944 {

25945 ret = GLEW_SGIX_bali_timer_instruments;

25946 continue;

25947 }

25948 #endif

25949 #ifdef GL_SGIX_blend_alpha_minmax

25950 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))

25951 {

25952 ret = GLEW_SGIX_blend_alpha_minmax;

25953 continue;

25954 }

25955 #endif

25956 #ifdef GL_SGIX_blend_cadd

25957 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_cadd", 10))

25958 {

25959 ret = GLEW_SGIX_blend_cadd;

25960 continue;

25961 }

25962 #endif

25963 #ifdef GL_SGIX_blend_cmultiply

25964 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_cmultiply", 15))

25965 {

25966 ret = GLEW_SGIX_blend_cmultiply;

25967 continue;

25968 }

25969 #endif

25970 #ifdef GL_SGIX_calligraphic_fragment

25971 if (_glewStrSame3(&pos, &len, (const GLubyte*)"calligraphic_fragment", 21))

25972 {

25973 ret = GLEW_SGIX_calligraphic_fragment;

25974 continue;

25975 }

25976 #endif

25977 #ifdef GL_SGIX_clipmap

25978 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))

25979 {

25980 ret = GLEW_SGIX_clipmap;

25981 continue;

25982 }

25983 #endif

25984 #ifdef GL_SGIX_color_matrix_accuracy

25985 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix_accuracy", 21))

25986 {

25987 ret = GLEW_SGIX_color_matrix_accuracy;

25988 continue;

25989 }

25990 #endif

25991 #ifdef GL_SGIX_color_table_index_mode

25992 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table_index_mode", 22))

25993 {

25994 ret = GLEW_SGIX_color_table_index_mode;

25995 continue;

25996 }

25997 #endif

25998 #ifdef GL_SGIX_complex_polar

25999 if (_glewStrSame3(&pos, &len, (const GLubyte*)"complex_polar", 13))

26000 {

26001 ret = GLEW_SGIX_complex_polar;

26002 continue;

26003 }

26004 #endif

26005 #ifdef GL_SGIX_convolution_accuracy

26006 if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20))

26007 {

26008 ret = GLEW_SGIX_convolution_accuracy;

26009 continue;

26010 }

26011 #endif

26012 #ifdef GL_SGIX_cube_map

26013 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cube_map", 8))

26014 {

26015 ret = GLEW_SGIX_cube_map;

26016 continue;

26017 }

26018 #endif

26019 #ifdef GL_SGIX_cylinder_texgen

26020 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cylinder_texgen", 15))

26021 {

26022 ret = GLEW_SGIX_cylinder_texgen;

26023 continue;

26024 }

26025 #endif

26026 #ifdef GL_SGIX_datapipe

26027 if (_glewStrSame3(&pos, &len, (const GLubyte*)"datapipe", 8))

26028 {

26029 ret = GLEW_SGIX_datapipe;

26030 continue;

26031 }

26032 #endif

26033 #ifdef GL_SGIX_decimation

26034 if (_glewStrSame3(&pos, &len, (const GLubyte*)"decimation", 10))

26035 {

26036 ret = GLEW_SGIX_decimation;

26037 continue;

26038 }

26039 #endif

26040 #ifdef GL_SGIX_depth_pass_instrument

26041 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_pass_instrument", 21))

26042 {

26043 ret = GLEW_SGIX_depth_pass_instrument;

26044 continue;

26045 }

26046 #endif

26047 #ifdef GL_SGIX_depth_texture

26048 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

26049 {

26050 ret = GLEW_SGIX_depth_texture;

26051 continue;

26052 }

26053 #endif

26054 #ifdef GL_SGIX_dvc

26055 if (_glewStrSame3(&pos, &len, (const GLubyte*)"dvc", 3))

26056 {

26057 ret = GLEW_SGIX_dvc;

26058 continue;

26059 }

26060 #endif

26061 #ifdef GL_SGIX_flush_raster

26062 if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))

26063 {

26064 ret = GLEW_SGIX_flush_raster;

26065 continue;

26066 }

26067 #endif

26068 #ifdef GL_SGIX_fog_blend

26069 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_blend", 9))

26070 {

26071 ret = GLEW_SGIX_fog_blend;

26072 continue;

26073 }

26074 #endif

26075 #ifdef GL_SGIX_fog_factor_to_alpha

26076 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_factor_to_alpha", 19))

26077 {

26078 ret = GLEW_SGIX_fog_factor_to_alpha;

26079 continue;

26080 }

26081 #endif

26082 #ifdef GL_SGIX_fog_layers

26083 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_layers", 10))

26084 {

26085 ret = GLEW_SGIX_fog_layers;

26086 continue;

26087 }

26088 #endif

26089 #ifdef GL_SGIX_fog_offset

26090 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))

26091 {

26092 ret = GLEW_SGIX_fog_offset;

26093 continue;

26094 }

26095 #endif

26096 #ifdef GL_SGIX_fog_patchy

26097 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_patchy", 10))

26098 {

26099 ret = GLEW_SGIX_fog_patchy;

26100 continue;

26101 }

26102 #endif

26103 #ifdef GL_SGIX_fog_scale

26104 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_scale", 9))

26105 {

26106 ret = GLEW_SGIX_fog_scale;

26107 continue;

26108 }

26109 #endif

26110 #ifdef GL_SGIX_fog_texture

26111 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))

26112 {

26113 ret = GLEW_SGIX_fog_texture;

26114 continue;

26115 }

26116 #endif

26117 #ifdef GL_SGIX_fragment_lighting_space

26118 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting_space", 23))

26119 {

26120 ret = GLEW_SGIX_fragment_lighting_space;

26121 continue;

26122 }

26123 #endif

26124 #ifdef GL_SGIX_fragment_specular_lighting

26125 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))

26126 {

26127 ret = GLEW_SGIX_fragment_specular_lighting;

26128 continue;

26129 }

26130 #endif

26131 #ifdef GL_SGIX_fragments_instrument

26132 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragments_instrument", 20))

26133 {

26134 ret = GLEW_SGIX_fragments_instrument;

26135 continue;

26136 }

26137 #endif

26138 #ifdef GL_SGIX_framezoom

26139 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))

26140 {

26141 ret = GLEW_SGIX_framezoom;

26142 continue;

26143 }

26144 #endif

26145 #ifdef GL_SGIX_icc_texture

26146 if (_glewStrSame3(&pos, &len, (const GLubyte*)"icc_texture", 11))

26147 {

26148 ret = GLEW_SGIX_icc_texture;

26149 continue;

26150 }

26151 #endif

26152 #ifdef GL_SGIX_igloo_interface

26153 if (_glewStrSame3(&pos, &len, (const GLubyte*)"igloo_interface", 15))

26154 {

26155 ret = GLEW_SGIX_igloo_interface;

26156 continue;

26157 }

26158 #endif

26159 #ifdef GL_SGIX_image_compression

26160 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_compression", 17))

26161 {

26162 ret = GLEW_SGIX_image_compression;

26163 continue;

26164 }

26165 #endif

26166 #ifdef GL_SGIX_impact_pixel_texture

26167 if (_glewStrSame3(&pos, &len, (const GLubyte*)"impact_pixel_texture", 20))

26168 {

26169 ret = GLEW_SGIX_impact_pixel_texture;

26170 continue;

26171 }

26172 #endif

26173 #ifdef GL_SGIX_instrument_error

26174 if (_glewStrSame3(&pos, &len, (const GLubyte*)"instrument_error", 16))

26175 {

26176 ret = GLEW_SGIX_instrument_error;

26177 continue;

26178 }

26179 #endif

26180 #ifdef GL_SGIX_interlace

26181 if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

26182 {

26183 ret = GLEW_SGIX_interlace;

26184 continue;

26185 }

26186 #endif

26187 #ifdef GL_SGIX_ir_instrument1

26188 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))

26189 {

26190 ret = GLEW_SGIX_ir_instrument1;

26191 continue;

26192 }

26193 #endif

26194 #ifdef GL_SGIX_line_quality_hint

26195 if (_glewStrSame3(&pos, &len, (const GLubyte*)"line_quality_hint", 17))

26196 {

26197 ret = GLEW_SGIX_line_quality_hint;

26198 continue;

26199 }

26200 #endif

26201 #ifdef GL_SGIX_list_priority

26202 if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))

26203 {

26204 ret = GLEW_SGIX_list_priority;

26205 continue;

26206 }

26207 #endif

26208 #ifdef GL_SGIX_mpeg1

26209 if (_glewStrSame3(&pos, &len, (const GLubyte*)"mpeg1", 5))

26210 {

26211 ret = GLEW_SGIX_mpeg1;

26212 continue;

26213 }

26214 #endif

26215 #ifdef GL_SGIX_mpeg2

26216 if (_glewStrSame3(&pos, &len, (const GLubyte*)"mpeg2", 5))

26217 {

26218 ret = GLEW_SGIX_mpeg2;

26219 continue;

26220 }

26221 #endif

26222 #ifdef GL_SGIX_nonlinear_lighting_pervertex

26223 if (_glewStrSame3(&pos, &len, (const GLubyte*)"nonlinear_lighting_pervertex", 28))

26224 {

26225 ret = GLEW_SGIX_nonlinear_lighting_pervertex;

26226 continue;

26227 }

26228 #endif

26229 #ifdef GL_SGIX_nurbs_eval

26230 if (_glewStrSame3(&pos, &len, (const GLubyte*)"nurbs_eval", 10))

26231 {

26232 ret = GLEW_SGIX_nurbs_eval;

26233 continue;

26234 }

26235 #endif

26236 #ifdef GL_SGIX_occlusion_instrument

26237 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_instrument", 20))

26238 {

26239 ret = GLEW_SGIX_occlusion_instrument;

26240 continue;

26241 }

26242 #endif

26243 #ifdef GL_SGIX_packed_6bytes

26244 if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_6bytes", 13))

26245 {

26246 ret = GLEW_SGIX_packed_6bytes;

26247 continue;

26248 }

26249 #endif

26250 #ifdef GL_SGIX_pixel_texture

26251 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

26252 {

26253 ret = GLEW_SGIX_pixel_texture;

26254 continue;

26255 }

26256 #endif

26257 #ifdef GL_SGIX_pixel_texture_bits

26258 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))

26259 {

26260 ret = GLEW_SGIX_pixel_texture_bits;

26261 continue;

26262 }

26263 #endif

26264 #ifdef GL_SGIX_pixel_texture_lod

26265 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_lod", 17))

26266 {

26267 ret = GLEW_SGIX_pixel_texture_lod;

26268 continue;

26269 }

26270 #endif

26271 #ifdef GL_SGIX_pixel_tiles

26272 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_tiles", 11))

26273 {

26274 ret = GLEW_SGIX_pixel_tiles;

26275 continue;

26276 }

26277 #endif

26278 #ifdef GL_SGIX_polynomial_ffd

26279 if (_glewStrSame3(&pos, &len, (const GLubyte*)"polynomial_ffd", 14))

26280 {

26281 ret = GLEW_SGIX_polynomial_ffd;

26282 continue;

26283 }

26284 #endif

26285 #ifdef GL_SGIX_quad_mesh

26286 if (_glewStrSame3(&pos, &len, (const GLubyte*)"quad_mesh", 9))

26287 {

26288 ret = GLEW_SGIX_quad_mesh;

26289 continue;

26290 }

26291 #endif

26292 #ifdef GL_SGIX_reference_plane

26293 if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))

26294 {

26295 ret = GLEW_SGIX_reference_plane;

26296 continue;

26297 }

26298 #endif

26299 #ifdef GL_SGIX_resample

26300 if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

26301 {

26302 ret = GLEW_SGIX_resample;

26303 continue;

26304 }

26305 #endif

26306 #ifdef GL_SGIX_scalebias_hint

26307 if (_glewStrSame3(&pos, &len, (const GLubyte*)"scalebias_hint", 14))

26308 {

26309 ret = GLEW_SGIX_scalebias_hint;

26310 continue;

26311 }

26312 #endif

26313 #ifdef GL_SGIX_shadow

26314 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

26315 {

26316 ret = GLEW_SGIX_shadow;

26317 continue;

26318 }

26319 #endif

26320 #ifdef GL_SGIX_shadow_ambient

26321 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

26322 {

26323 ret = GLEW_SGIX_shadow_ambient;

26324 continue;

26325 }

26326 #endif

26327 #ifdef GL_SGIX_slim

26328 if (_glewStrSame3(&pos, &len, (const GLubyte*)"slim", 4))

26329 {

26330 ret = GLEW_SGIX_slim;

26331 continue;

26332 }

26333 #endif

26334 #ifdef GL_SGIX_spotlight_cutoff

26335 if (_glewStrSame3(&pos, &len, (const GLubyte*)"spotlight_cutoff", 16))

26336 {

26337 ret = GLEW_SGIX_spotlight_cutoff;

26338 continue;

26339 }

26340 #endif

26341 #ifdef GL_SGIX_sprite

26342 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))

26343 {

26344 ret = GLEW_SGIX_sprite;

26345 continue;

26346 }

26347 #endif

26348 #ifdef GL_SGIX_subdiv_patch

26349 if (_glewStrSame3(&pos, &len, (const GLubyte*)"subdiv_patch", 12))

26350 {

26351 ret = GLEW_SGIX_subdiv_patch;

26352 continue;

26353 }

26354 #endif

26355 #ifdef GL_SGIX_subsample

26356 if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))

26357 {

26358 ret = GLEW_SGIX_subsample;

26359 continue;

26360 }

26361 #endif

26362 #ifdef GL_SGIX_tag_sample_buffer

26363 if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))

26364 {

26365 ret = GLEW_SGIX_tag_sample_buffer;

26366 continue;

26367 }

26368 #endif

26369 #ifdef GL_SGIX_texture_add_env

26370 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))

26371 {

26372 ret = GLEW_SGIX_texture_add_env;

26373 continue;

26374 }

26375 #endif

26376 #ifdef GL_SGIX_texture_coordinate_clamp

26377 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))

26378 {

26379 ret = GLEW_SGIX_texture_coordinate_clamp;

26380 continue;

26381 }

26382 #endif

26383 #ifdef GL_SGIX_texture_lod_bias

26384 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

26385 {

26386 ret = GLEW_SGIX_texture_lod_bias;

26387 continue;

26388 }

26389 #endif

26390 #ifdef GL_SGIX_texture_mipmap_anisotropic

26391 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mipmap_anisotropic", 26))

26392 {

26393 ret = GLEW_SGIX_texture_mipmap_anisotropic;

26394 continue;

26395 }

26396 #endif

26397 #ifdef GL_SGIX_texture_multi_buffer

26398 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))

26399 {

26400 ret = GLEW_SGIX_texture_multi_buffer;

26401 continue;

26402 }

26403 #endif

26404 #ifdef GL_SGIX_texture_phase

26405 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_phase", 13))

26406 {

26407 ret = GLEW_SGIX_texture_phase;

26408 continue;

26409 }

26410 #endif

26411 #ifdef GL_SGIX_texture_range

26412 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

26413 {

26414 ret = GLEW_SGIX_texture_range;

26415 continue;

26416 }

26417 #endif

26418 #ifdef GL_SGIX_texture_scale_bias

26419 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))

26420 {

26421 ret = GLEW_SGIX_texture_scale_bias;

26422 continue;

26423 }

26424 #endif

26425 #ifdef GL_SGIX_texture_supersample

26426 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_supersample", 19))

26427 {

26428 ret = GLEW_SGIX_texture_supersample;

26429 continue;

26430 }

26431 #endif

26432 #ifdef GL_SGIX_vector_ops

26433 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vector_ops", 10))

26434 {

26435 ret = GLEW_SGIX_vector_ops;

26436 continue;

26437 }

26438 #endif

26439 #ifdef GL_SGIX_vertex_array_object

26440 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

26441 {

26442 ret = GLEW_SGIX_vertex_array_object;

26443 continue;

26444 }

26445 #endif

26446 #ifdef GL_SGIX_vertex_preclip

26447 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))

26448 {

26449 ret = GLEW_SGIX_vertex_preclip;

26450 continue;

26451 }

26452 #endif

26453 #ifdef GL_SGIX_vertex_preclip_hint

26454 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))

26455 {

26456 ret = GLEW_SGIX_vertex_preclip_hint;

26457 continue;

26458 }

26459 #endif

26460 #ifdef GL_SGIX_ycrcb

26461 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))

26462 {

26463 ret = GLEW_SGIX_ycrcb;

26464 continue;

26465 }

26466 #endif

26467 #ifdef GL_SGIX_ycrcb_subsample

26468 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb_subsample", 15))

26469 {

26470 ret = GLEW_SGIX_ycrcb_subsample;

26471 continue;

26472 }

26473 #endif

26474 #ifdef GL_SGIX_ycrcba

26475 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcba", 6))

26476 {

26477 ret = GLEW_SGIX_ycrcba;

26478 continue;

26479 }

26480 #endif

26481 }

26482 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

26483 {

26484 #ifdef GL_SGI_color_matrix

26485 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))

26486 {

26487 ret = GLEW_SGI_color_matrix;

26488 continue;

26489 }

26490 #endif

26491 #ifdef GL_SGI_color_table

26492 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))

26493 {

26494 ret = GLEW_SGI_color_table;

26495 continue;

26496 }

26497 #endif

26498 #ifdef GL_SGI_complex

26499 if (_glewStrSame3(&pos, &len, (const GLubyte*)"complex", 7))

26500 {

26501 ret = GLEW_SGI_complex;

26502 continue;

26503 }

26504 #endif

26505 #ifdef GL_SGI_complex_type

26506 if (_glewStrSame3(&pos, &len, (const GLubyte*)"complex_type", 12))

26507 {

26508 ret = GLEW_SGI_complex_type;

26509 continue;

26510 }

26511 #endif

26512 #ifdef GL_SGI_fft

26513 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fft", 3))

26514 {

26515 ret = GLEW_SGI_fft;

26516 continue;

26517 }

26518 #endif

26519 #ifdef GL_SGI_texture_color_table

26520 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))

26521 {

26522 ret = GLEW_SGI_texture_color_table;

26523 continue;

26524 }

26525 #endif

26526 }

26527 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))

26528 {

26529 #ifdef GL_SUNX_constant_data

26530 if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))

26531 {

26532 ret = GLEW_SUNX_constant_data;

26533 continue;

26534 }

26535 #endif

26536 }

26537 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

26538 {

26539 #ifdef GL_SUN_convolution_border_modes

26540 if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

26541 {

26542 ret = GLEW_SUN_convolution_border_modes;

26543 continue;

26544 }

26545 #endif

26546 #ifdef GL_SUN_global_alpha

26547 if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))

26548 {

26549 ret = GLEW_SUN_global_alpha;

26550 continue;

26551 }

26552 #endif

26553 #ifdef GL_SUN_mesh_array

26554 if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))

26555 {

26556 ret = GLEW_SUN_mesh_array;

26557 continue;

26558 }

26559 #endif

26560 #ifdef GL_SUN_read_video_pixels

26561 if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))

26562 {

26563 ret = GLEW_SUN_read_video_pixels;

26564 continue;

26565 }

26566 #endif

26567 #ifdef GL_SUN_slice_accum

26568 if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))

26569 {

26570 ret = GLEW_SUN_slice_accum;

26571 continue;

26572 }

26573 #endif

26574 #ifdef GL_SUN_triangle_list

26575 if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))

26576 {

26577 ret = GLEW_SUN_triangle_list;

26578 continue;

26579 }

26580 #endif

26581 #ifdef GL_SUN_vertex

26582 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))

26583 {

26584 ret = GLEW_SUN_vertex;

26585 continue;

26586 }

26587 #endif

26588 }

26589 if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))

26590 {

26591 #ifdef GL_WIN_phong_shading

26592 if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))

26593 {

26594 ret = GLEW_WIN_phong_shading;

26595 continue;

26596 }

26597 #endif

26598 #ifdef GL_WIN_scene_markerXXX

26599 if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_markerXXX", 15))

26600 {

26601 ret = GLEW_WIN_scene_markerXXX;

26602 continue;

26603 }

26604 #endif

26605 #ifdef GL_WIN_specular_fog

26606 if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))

26607 {

26608 ret = GLEW_WIN_specular_fog;

26609 continue;

26610 }

26611 #endif

26612 #ifdef GL_WIN_swap_hint

26613 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))

26614 {

26615 ret = GLEW_WIN_swap_hint;

26616 continue;

26617 }

26618 #endif

26619 }

26620 }

26621 ret = (len == 0);

26622 }

26623 return ret;

26624 }

26625

26626 #if defined(_WIN32) && !defined(GLEW_EGL) && !defined(GLEW_OSMESA)

26627

26628 GLboolean GLEWAPIENTRY wglewIsSupported (const char* name)

26629 {

26630 const GLubyte* pos = (const GLubyte*)name;

26631 GLuint len = _glewStrLen(pos);

26632 GLboolean ret = GL_TRUE;

26633 while (ret && len > 0)

26634 {

26635 if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))

26636 {

26637 if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

26638 {

26639 #ifdef WGL_3DFX_multisample

26640 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

26641 {

26642 ret = WGLEW_3DFX_multisample;

26643 continue;

26644 }

26645 #endif

26646 }

26647 if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4))

26648 {

26649 #ifdef WGL_3DL_stereo_control

26650 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14))

26651 {

26652 ret = WGLEW_3DL_stereo_control;

26653 continue;

26654 }

26655 #endif

26656 }

26657 if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))

26658 {

26659 #ifdef WGL_AMD_gpu_association

26660 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))

26661 {

26662 ret = WGLEW_AMD_gpu_association;

26663 continue;

26664 }

26665 #endif

26666 }

26667 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

26668 {

26669 #ifdef WGL_ARB_buffer_region

26670 if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

26671 {

26672 ret = WGLEW_ARB_buffer_region;

26673 continue;

26674 }

26675 #endif

26676 #ifdef WGL_ARB_context_flush_control

26677 if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21))

26678 {

26679 ret = WGLEW_ARB_context_flush_control;

26680 continue;

26681 }

26682 #endif

26683 #ifdef WGL_ARB_create_context

26684 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))

26685 {

26686 ret = WGLEW_ARB_create_context;

26687 continue;

26688 }

26689 #endif

26690 #ifdef WGL_ARB_create_context_no_error

26691 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_no_error", 23))

26692 {

26693 ret = WGLEW_ARB_create_context_no_error;

26694 continue;

26695 }

26696 #endif

26697 #ifdef WGL_ARB_create_context_profile

26698 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))

26699 {

26700 ret = WGLEW_ARB_create_context_profile;

26701 continue;

26702 }

26703 #endif

26704 #ifdef WGL_ARB_create_context_robustness

26705 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))

26706 {

26707 ret = WGLEW_ARB_create_context_robustness;

26708 continue;

26709 }

26710 #endif

26711 #ifdef WGL_ARB_extensions_string

26712 if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

26713 {

26714 ret = WGLEW_ARB_extensions_string;

26715 continue;

26716 }

26717 #endif

26718 #ifdef WGL_ARB_framebuffer_sRGB

26719 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

26720 {

26721 ret = WGLEW_ARB_framebuffer_sRGB;

26722 continue;

26723 }

26724 #endif

26725 #ifdef WGL_ARB_make_current_read

26726 if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

26727 {

26728 ret = WGLEW_ARB_make_current_read;

26729 continue;

26730 }

26731 #endif

26732 #ifdef WGL_ARB_multisample

26733 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

26734 {

26735 ret = WGLEW_ARB_multisample;

26736 continue;

26737 }

26738 #endif

26739 #ifdef WGL_ARB_pbuffer

26740 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

26741 {

26742 ret = WGLEW_ARB_pbuffer;

26743 continue;

26744 }

26745 #endif

26746 #ifdef WGL_ARB_pixel_format

26747 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

26748 {

26749 ret = WGLEW_ARB_pixel_format;

26750 continue;

26751 }

26752 #endif

26753 #ifdef WGL_ARB_pixel_format_float

26754 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

26755 {

26756 ret = WGLEW_ARB_pixel_format_float;

26757 continue;

26758 }

26759 #endif

26760 #ifdef WGL_ARB_render_texture

26761 if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

26762 {

26763 ret = WGLEW_ARB_render_texture;

26764 continue;

26765 }

26766 #endif

26767 #ifdef WGL_ARB_robustness_application_isolation

26768 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))

26769 {

26770 ret = WGLEW_ARB_robustness_application_isolation;

26771 continue;

26772 }

26773 #endif

26774 #ifdef WGL_ARB_robustness_share_group_isolation

26775 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))

26776 {

26777 ret = WGLEW_ARB_robustness_share_group_isolation;

26778 continue;

26779 }

26780 #endif

26781 }

26782 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

26783 {

26784 #ifdef WGL_ATI_pixel_format_float

26785 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

26786 {

26787 ret = WGLEW_ATI_pixel_format_float;

26788 continue;

26789 }

26790 #endif

26791 #ifdef WGL_ATI_render_texture_rectangle

26792 if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

26793 {

26794 ret = WGLEW_ATI_render_texture_rectangle;

26795 continue;

26796 }

26797 #endif

26798 }

26799 if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

26800 {

26801 #ifdef WGL_EXT_colorspace

26802 if (_glewStrSame3(&pos, &len, (const GLubyte*)"colorspace", 10))

26803 {

26804 ret = WGLEW_EXT_colorspace;

26805 continue;

26806 }

26807 #endif

26808 #ifdef WGL_EXT_create_context_es2_profile

26809 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))

26810 {

26811 ret = WGLEW_EXT_create_context_es2_profile;

26812 continue;

26813 }

26814 #endif

26815 #ifdef WGL_EXT_create_context_es_profile

26816 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25))

26817 {

26818 ret = WGLEW_EXT_create_context_es_profile;

26819 continue;

26820 }

26821 #endif

26822 #ifdef WGL_EXT_depth_float

26823 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))

26824 {

26825 ret = WGLEW_EXT_depth_float;

26826 continue;

26827 }

26828 #endif

26829 #ifdef WGL_EXT_display_color_table

26830 if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))

26831 {

26832 ret = WGLEW_EXT_display_color_table;

26833 continue;

26834 }

26835 #endif

26836 #ifdef WGL_EXT_extensions_string

26837 if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

26838 {

26839 ret = WGLEW_EXT_extensions_string;

26840 continue;

26841 }

26842 #endif

26843 #ifdef WGL_EXT_framebuffer_sRGB

26844 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

26845 {

26846 ret = WGLEW_EXT_framebuffer_sRGB;

26847 continue;

26848 }

26849 #endif

26850 #ifdef WGL_EXT_make_current_read

26851 if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

26852 {

26853 ret = WGLEW_EXT_make_current_read;

26854 continue;

26855 }

26856 #endif

26857 #ifdef WGL_EXT_multisample

26858 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

26859 {

26860 ret = WGLEW_EXT_multisample;

26861 continue;

26862 }

26863 #endif

26864 #ifdef WGL_EXT_pbuffer

26865 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

26866 {

26867 ret = WGLEW_EXT_pbuffer;

26868 continue;

26869 }

26870 #endif

26871 #ifdef WGL_EXT_pixel_format

26872 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

26873 {

26874 ret = WGLEW_EXT_pixel_format;

26875 continue;

26876 }

26877 #endif

26878 #ifdef WGL_EXT_pixel_format_packed_float

26879 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25))

26880 {

26881 ret = WGLEW_EXT_pixel_format_packed_float;

26882 continue;

26883 }

26884 #endif

26885 #ifdef WGL_EXT_swap_control

26886 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

26887 {

26888 ret = WGLEW_EXT_swap_control;

26889 continue;

26890 }

26891 #endif

26892 #ifdef WGL_EXT_swap_control_tear

26893 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17))

26894 {

26895 ret = WGLEW_EXT_swap_control_tear;

26896 continue;

26897 }

26898 #endif

26899 }

26900 if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))

26901 {

26902 #ifdef WGL_I3D_digital_video_control

26903 if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))

26904 {

26905 ret = WGLEW_I3D_digital_video_control;

26906 continue;

26907 }

26908 #endif

26909 #ifdef WGL_I3D_gamma

26910 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))

26911 {

26912 ret = WGLEW_I3D_gamma;

26913 continue;

26914 }

26915 #endif

26916 #ifdef WGL_I3D_genlock

26917 if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))

26918 {

26919 ret = WGLEW_I3D_genlock;

26920 continue;

26921 }

26922 #endif

26923 #ifdef WGL_I3D_image_buffer

26924 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))

26925 {

26926 ret = WGLEW_I3D_image_buffer;

26927 continue;

26928 }

26929 #endif

26930 #ifdef WGL_I3D_swap_frame_lock

26931 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))

26932 {

26933 ret = WGLEW_I3D_swap_frame_lock;

26934 continue;

26935 }

26936 #endif

26937 #ifdef WGL_I3D_swap_frame_usage

26938 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))

26939 {

26940 ret = WGLEW_I3D_swap_frame_usage;

26941 continue;

26942 }

26943 #endif

26944 }

26945 if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

26946 {

26947 #ifdef WGL_NV_DX_interop

26948 if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop", 10))

26949 {

26950 ret = WGLEW_NV_DX_interop;

26951 continue;

26952 }

26953 #endif

26954 #ifdef WGL_NV_DX_interop2

26955 if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop2", 11))

26956 {

26957 ret = WGLEW_NV_DX_interop2;

26958 continue;

26959 }

26960 #endif

26961 #ifdef WGL_NV_copy_image

26962 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))

26963 {

26964 ret = WGLEW_NV_copy_image;

26965 continue;

26966 }

26967 #endif

26968 #ifdef WGL_NV_delay_before_swap

26969 if (_glewStrSame3(&pos, &len, (const GLubyte*)"delay_before_swap", 17))

26970 {

26971 ret = WGLEW_NV_delay_before_swap;

26972 continue;

26973 }

26974 #endif

26975 #ifdef WGL_NV_float_buffer

26976 if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

26977 {

26978 ret = WGLEW_NV_float_buffer;

26979 continue;

26980 }

26981 #endif

26982 #ifdef WGL_NV_gpu_affinity

26983 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12))

26984 {

26985 ret = WGLEW_NV_gpu_affinity;

26986 continue;

26987 }

26988 #endif

26989 #ifdef WGL_NV_multisample_coverage

26990 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))

26991 {

26992 ret = WGLEW_NV_multisample_coverage;

26993 continue;

26994 }

26995 #endif

26996 #ifdef WGL_NV_present_video

26997 if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))

26998 {

26999 ret = WGLEW_NV_present_video;

27000 continue;

27001 }

27002 #endif

27003 #ifdef WGL_NV_render_depth_texture

27004 if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))

27005 {

27006 ret = WGLEW_NV_render_depth_texture;

27007 continue;

27008 }

27009 #endif

27010 #ifdef WGL_NV_render_texture_rectangle

27011 if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

27012 {

27013 ret = WGLEW_NV_render_texture_rectangle;

27014 continue;

27015 }

27016 #endif

27017 #ifdef WGL_NV_swap_group

27018 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

27019 {

27020 ret = WGLEW_NV_swap_group;

27021 continue;

27022 }

27023 #endif

27024 #ifdef WGL_NV_vertex_array_range

27025 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

27026 {

27027 ret = WGLEW_NV_vertex_array_range;

27028 continue;

27029 }

27030 #endif

27031 #ifdef WGL_NV_video_capture

27032 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))

27033 {

27034 ret = WGLEW_NV_video_capture;

27035 continue;

27036 }

27037 #endif

27038 #ifdef WGL_NV_video_output

27039 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))

27040 {

27041 ret = WGLEW_NV_video_output;

27042 continue;

27043 }

27044 #endif

27045 }

27046 if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

27047 {

27048 #ifdef WGL_OML_sync_control

27049 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

27050 {

27051 ret = WGLEW_OML_sync_control;

27052 continue;

27053 }

27054 #endif

27055 }

27056 }

27057 ret = (len == 0);

27058 }

27059 return ret;

27060 }

27061

27062 #elif !defined(GLEW_OSMESA) && !defined(GLEW_EGL) && !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

27063

27064 GLboolean glxewIsSupported (const char* name)

27065 {

27066 const GLubyte* pos = (const GLubyte*)name;

27067 GLuint len = _glewStrLen(pos);

27068 GLboolean ret = GL_TRUE;

27069 while (ret && len > 0)

27070 {

27071 if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))

27072 {

27073 if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

27074 {

27075 #ifdef GLX_VERSION_1_2

27076 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

27077 {

27078 ret = GLXEW_VERSION_1_2;

27079 continue;

27080 }

27081 #endif

27082 #ifdef GLX_VERSION_1_3

27083 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

27084 {

27085 ret = GLXEW_VERSION_1_3;

27086 continue;

27087 }

27088 #endif

27089 #ifdef GLX_VERSION_1_4

27090 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

27091 {

27092 ret = GLXEW_VERSION_1_4;

27093 continue;

27094 }

27095 #endif

27096 }

27097 if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

27098 {

27099 #ifdef GLX_3DFX_multisample

27100 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

27101 {

27102 ret = GLXEW_3DFX_multisample;

27103 continue;

27104 }

27105 #endif

27106 }

27107 if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))

27108 {

27109 #ifdef GLX_AMD_gpu_association

27110 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))

27111 {

27112 ret = GLXEW_AMD_gpu_association;

27113 continue;

27114 }

27115 #endif

27116 }

27117 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

27118 {

27119 #ifdef GLX_ARB_context_flush_control

27120 if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21))

27121 {

27122 ret = GLXEW_ARB_context_flush_control;

27123 continue;

27124 }

27125 #endif

27126 #ifdef GLX_ARB_create_context

27127 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))

27128 {

27129 ret = GLXEW_ARB_create_context;

27130 continue;

27131 }

27132 #endif

27133 #ifdef GLX_ARB_create_context_no_error

27134 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_no_error", 23))

27135 {

27136 ret = GLXEW_ARB_create_context_no_error;

27137 continue;

27138 }

27139 #endif

27140 #ifdef GLX_ARB_create_context_profile

27141 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))

27142 {

27143 ret = GLXEW_ARB_create_context_profile;

27144 continue;

27145 }

27146 #endif

27147 #ifdef GLX_ARB_create_context_robustness

27148 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))

27149 {

27150 ret = GLXEW_ARB_create_context_robustness;

27151 continue;

27152 }

27153 #endif

27154 #ifdef GLX_ARB_fbconfig_float

27155 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))

27156 {

27157 ret = GLXEW_ARB_fbconfig_float;

27158 continue;

27159 }

27160 #endif

27161 #ifdef GLX_ARB_framebuffer_sRGB

27162 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

27163 {

27164 ret = GLXEW_ARB_framebuffer_sRGB;

27165 continue;

27166 }

27167 #endif

27168 #ifdef GLX_ARB_get_proc_address

27169 if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))

27170 {

27171 ret = GLXEW_ARB_get_proc_address;

27172 continue;

27173 }

27174 #endif

27175 #ifdef GLX_ARB_multisample

27176 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

27177 {

27178 ret = GLXEW_ARB_multisample;

27179 continue;

27180 }

27181 #endif

27182 #ifdef GLX_ARB_robustness_application_isolation

27183 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32))

27184 {

27185 ret = GLXEW_ARB_robustness_application_isolation;

27186 continue;

27187 }

27188 #endif

27189 #ifdef GLX_ARB_robustness_share_group_isolation

27190 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32))

27191 {

27192 ret = GLXEW_ARB_robustness_share_group_isolation;

27193 continue;

27194 }

27195 #endif

27196 #ifdef GLX_ARB_vertex_buffer_object

27197 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))

27198 {

27199 ret = GLXEW_ARB_vertex_buffer_object;

27200 continue;

27201 }

27202 #endif

27203 }

27204 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

27205 {

27206 #ifdef GLX_ATI_pixel_format_float

27207 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

27208 {

27209 ret = GLXEW_ATI_pixel_format_float;

27210 continue;

27211 }

27212 #endif

27213 #ifdef GLX_ATI_render_texture

27214 if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

27215 {

27216 ret = GLXEW_ATI_render_texture;

27217 continue;

27218 }

27219 #endif

27220 }

27221 if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

27222 {

27223 #ifdef GLX_EXT_buffer_age

27224 if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_age", 10))

27225 {

27226 ret = GLXEW_EXT_buffer_age;

27227 continue;

27228 }

27229 #endif

27230 #ifdef GLX_EXT_create_context_es2_profile

27231 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))

27232 {

27233 ret = GLXEW_EXT_create_context_es2_profile;

27234 continue;

27235 }

27236 #endif

27237 #ifdef GLX_EXT_create_context_es_profile

27238 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25))

27239 {

27240 ret = GLXEW_EXT_create_context_es_profile;

27241 continue;

27242 }

27243 #endif

27244 #ifdef GLX_EXT_fbconfig_packed_float

27245 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21))

27246 {

27247 ret = GLXEW_EXT_fbconfig_packed_float;

27248 continue;

27249 }

27250 #endif

27251 #ifdef GLX_EXT_framebuffer_sRGB

27252 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

27253 {

27254 ret = GLXEW_EXT_framebuffer_sRGB;

27255 continue;

27256 }

27257 #endif

27258 #ifdef GLX_EXT_import_context

27259 if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))

27260 {

27261 ret = GLXEW_EXT_import_context;

27262 continue;

27263 }

27264 #endif

27265 #ifdef GLX_EXT_libglvnd

27266 if (_glewStrSame3(&pos, &len, (const GLubyte*)"libglvnd", 8))

27267 {

27268 ret = GLXEW_EXT_libglvnd;

27269 continue;

27270 }

27271 #endif

27272 #ifdef GLX_EXT_scene_marker

27273 if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

27274 {

27275 ret = GLXEW_EXT_scene_marker;

27276 continue;

27277 }

27278 #endif

27279 #ifdef GLX_EXT_stereo_tree

27280 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_tree", 11))

27281 {

27282 ret = GLXEW_EXT_stereo_tree;

27283 continue;

27284 }

27285 #endif

27286 #ifdef GLX_EXT_swap_control

27287 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

27288 {

27289 ret = GLXEW_EXT_swap_control;

27290 continue;

27291 }

27292 #endif

27293 #ifdef GLX_EXT_swap_control_tear

27294 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17))

27295 {

27296 ret = GLXEW_EXT_swap_control_tear;

27297 continue;

27298 }

27299 #endif

27300 #ifdef GLX_EXT_texture_from_pixmap

27301 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))

27302 {

27303 ret = GLXEW_EXT_texture_from_pixmap;

27304 continue;

27305 }

27306 #endif

27307 #ifdef GLX_EXT_visual_info

27308 if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))

27309 {

27310 ret = GLXEW_EXT_visual_info;

27311 continue;

27312 }

27313 #endif

27314 #ifdef GLX_EXT_visual_rating

27315 if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))

27316 {

27317 ret = GLXEW_EXT_visual_rating;

27318 continue;

27319 }

27320 #endif

27321 }

27322 if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))

27323 {

27324 #ifdef GLX_INTEL_swap_event

27325 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10))

27326 {

27327 ret = GLXEW_INTEL_swap_event;

27328 continue;

27329 }

27330 #endif

27331 }

27332 if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

27333 {

27334 #ifdef GLX_MESA_agp_offset

27335 if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))

27336 {

27337 ret = GLXEW_MESA_agp_offset;

27338 continue;

27339 }

27340 #endif

27341 #ifdef GLX_MESA_copy_sub_buffer

27342 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))

27343 {

27344 ret = GLXEW_MESA_copy_sub_buffer;

27345 continue;

27346 }

27347 #endif

27348 #ifdef GLX_MESA_pixmap_colormap

27349 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))

27350 {

27351 ret = GLXEW_MESA_pixmap_colormap;

27352 continue;

27353 }

27354 #endif

27355 #ifdef GLX_MESA_query_renderer

27356 if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_renderer", 14))

27357 {

27358 ret = GLXEW_MESA_query_renderer;

27359 continue;

27360 }

27361 #endif

27362 #ifdef GLX_MESA_release_buffers

27363 if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))

27364 {

27365 ret = GLXEW_MESA_release_buffers;

27366 continue;

27367 }

27368 #endif

27369 #ifdef GLX_MESA_set_3dfx_mode

27370 if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))

27371 {

27372 ret = GLXEW_MESA_set_3dfx_mode;

27373 continue;

27374 }

27375 #endif

27376 #ifdef GLX_MESA_swap_control

27377 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

27378 {

27379 ret = GLXEW_MESA_swap_control;

27380 continue;

27381 }

27382 #endif

27383 }

27384 if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

27385 {

27386 #ifdef GLX_NV_copy_buffer

27387 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))

27388 {

27389 ret = GLXEW_NV_copy_buffer;

27390 continue;

27391 }

27392 #endif

27393 #ifdef GLX_NV_copy_image

27394 if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))

27395 {

27396 ret = GLXEW_NV_copy_image;

27397 continue;

27398 }

27399 #endif

27400 #ifdef GLX_NV_delay_before_swap

27401 if (_glewStrSame3(&pos, &len, (const GLubyte*)"delay_before_swap", 17))

27402 {

27403 ret = GLXEW_NV_delay_before_swap;

27404 continue;

27405 }

27406 #endif

27407 #ifdef GLX_NV_float_buffer

27408 if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

27409 {

27410 ret = GLXEW_NV_float_buffer;

27411 continue;

27412 }

27413 #endif

27414 #ifdef GLX_NV_multisample_coverage

27415 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))

27416 {

27417 ret = GLXEW_NV_multisample_coverage;

27418 continue;

27419 }

27420 #endif

27421 #ifdef GLX_NV_present_video

27422 if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))

27423 {

27424 ret = GLXEW_NV_present_video;

27425 continue;

27426 }

27427 #endif

27428 #ifdef GLX_NV_robustness_video_memory_purge

27429 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_video_memory_purge", 29))

27430 {

27431 ret = GLXEW_NV_robustness_video_memory_purge;

27432 continue;

27433 }

27434 #endif

27435 #ifdef GLX_NV_swap_group

27436 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

27437 {

27438 ret = GLXEW_NV_swap_group;

27439 continue;

27440 }

27441 #endif

27442 #ifdef GLX_NV_vertex_array_range

27443 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

27444 {

27445 ret = GLXEW_NV_vertex_array_range;

27446 continue;

27447 }

27448 #endif

27449 #ifdef GLX_NV_video_capture

27450 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))

27451 {

27452 ret = GLXEW_NV_video_capture;

27453 continue;

27454 }

27455 #endif

27456 #ifdef GLX_NV_video_out

27457 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_out", 9))

27458 {

27459 ret = GLXEW_NV_video_out;

27460 continue;

27461 }

27462 #endif

27463 }

27464 if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

27465 {

27466 #ifdef GLX_OML_swap_method

27467 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))

27468 {

27469 ret = GLXEW_OML_swap_method;

27470 continue;

27471 }

27472 #endif

27473 #ifdef GLX_OML_sync_control

27474 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

27475 {

27476 ret = GLXEW_OML_sync_control;

27477 continue;

27478 }

27479 #endif

27480 }

27481 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

27482 {

27483 #ifdef GLX_SGIS_blended_overlay

27484 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))

27485 {

27486 ret = GLXEW_SGIS_blended_overlay;

27487 continue;

27488 }

27489 #endif

27490 #ifdef GLX_SGIS_color_range

27491 if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

27492 {

27493 ret = GLXEW_SGIS_color_range;

27494 continue;

27495 }

27496 #endif

27497 #ifdef GLX_SGIS_multisample

27498 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

27499 {

27500 ret = GLXEW_SGIS_multisample;

27501 continue;

27502 }

27503 #endif

27504 #ifdef GLX_SGIS_shared_multisample

27505 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))

27506 {

27507 ret = GLXEW_SGIS_shared_multisample;

27508 continue;

27509 }

27510 #endif

27511 }

27512 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

27513 {

27514 #ifdef GLX_SGIX_fbconfig

27515 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))

27516 {

27517 ret = GLXEW_SGIX_fbconfig;

27518 continue;

27519 }

27520 #endif

27521 #ifdef GLX_SGIX_hyperpipe

27522 if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9))

27523 {

27524 ret = GLXEW_SGIX_hyperpipe;

27525 continue;

27526 }

27527 #endif

27528 #ifdef GLX_SGIX_pbuffer

27529 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

27530 {

27531 ret = GLXEW_SGIX_pbuffer;

27532 continue;

27533 }

27534 #endif

27535 #ifdef GLX_SGIX_swap_barrier

27536 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))

27537 {

27538 ret = GLXEW_SGIX_swap_barrier;

27539 continue;

27540 }

27541 #endif

27542 #ifdef GLX_SGIX_swap_group

27543 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

27544 {

27545 ret = GLXEW_SGIX_swap_group;

27546 continue;

27547 }

27548 #endif

27549 #ifdef GLX_SGIX_video_resize

27550 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

27551 {

27552 ret = GLXEW_SGIX_video_resize;

27553 continue;

27554 }

27555 #endif

27556 #ifdef GLX_SGIX_visual_select_group

27557 if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))

27558 {

27559 ret = GLXEW_SGIX_visual_select_group;

27560 continue;

27561 }

27562 #endif

27563 }

27564 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

27565 {

27566 #ifdef GLX_SGI_cushion

27567 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))

27568 {

27569 ret = GLXEW_SGI_cushion;

27570 continue;

27571 }

27572 #endif

27573 #ifdef GLX_SGI_make_current_read

27574 if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

27575 {

27576 ret = GLXEW_SGI_make_current_read;

27577 continue;

27578 }

27579 #endif

27580 #ifdef GLX_SGI_swap_control

27581 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

27582 {

27583 ret = GLXEW_SGI_swap_control;

27584 continue;

27585 }

27586 #endif

27587 #ifdef GLX_SGI_video_sync

27588 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))

27589 {

27590 ret = GLXEW_SGI_video_sync;

27591 continue;

27592 }

27593 #endif

27594 }

27595 if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

27596 {

27597 #ifdef GLX_SUN_get_transparent_index

27598 if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))

27599 {

27600 ret = GLXEW_SUN_get_transparent_index;

27601 continue;

27602 }

27603 #endif

27604 #ifdef GLX_SUN_video_resize

27605 if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

27606 {

27607 ret = GLXEW_SUN_video_resize;

27608 continue;

27609 }

27610 #endif

27611 }

27612 }

27613 ret = (len == 0);

27614 }

27615 return ret;

27616 }

27617

27618 #elif defined(GLEW_EGL)

27619

27620 GLboolean eglewIsSupported (const char* name)

27621 {

27622 const GLubyte* pos = (const GLubyte*)name;

27623 GLuint len = _glewStrLen(pos);

27624 GLboolean ret = GL_TRUE;

27625 while (ret && len > 0)

27626 {

27627 if(_glewStrSame1(&pos, &len, (const GLubyte*)"EGL_", 4))

27628 {

27629 if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

27630 {

27631 #ifdef EGL_VERSION_1_0

27632 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_0", 3))

27633 {

27634 ret = EGLEW_VERSION_1_0;

27635 continue;

27636 }

27637 #endif

27638 #ifdef EGL_VERSION_1_1

27639 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_1", 3))

27640 {

27641 ret = EGLEW_VERSION_1_1;

27642 continue;

27643 }

27644 #endif

27645 #ifdef EGL_VERSION_1_2

27646 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

27647 {

27648 ret = EGLEW_VERSION_1_2;

27649 continue;

27650 }

27651 #endif

27652 #ifdef EGL_VERSION_1_3

27653 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

27654 {

27655 ret = EGLEW_VERSION_1_3;

27656 continue;

27657 }

27658 #endif

27659 #ifdef EGL_VERSION_1_4

27660 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

27661 {

27662 ret = EGLEW_VERSION_1_4;

27663 continue;

27664 }

27665 #endif

27666 #ifdef EGL_VERSION_1_5

27667 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))

27668 {

27669 ret = EGLEW_VERSION_1_5;

27670 continue;

27671 }

27672 #endif

27673 }

27674 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANDROID_", 8))

27675 {

27676 #ifdef EGL_ANDROID_blob_cache

27677 if (_glewStrSame3(&pos, &len, (const GLubyte*)"blob_cache", 10))

27678 {

27679 ret = EGLEW_ANDROID_blob_cache;

27680 continue;

27681 }

27682 #endif

27683 #ifdef EGL_ANDROID_create_native_client_buffer

27684 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_native_client_buffer", 27))

27685 {

27686 ret = EGLEW_ANDROID_create_native_client_buffer;

27687 continue;

27688 }

27689 #endif

27690 #ifdef EGL_ANDROID_framebuffer_target

27691 if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_target", 18))

27692 {

27693 ret = EGLEW_ANDROID_framebuffer_target;

27694 continue;

27695 }

27696 #endif

27697 #ifdef EGL_ANDROID_front_buffer_auto_refresh

27698 if (_glewStrSame3(&pos, &len, (const GLubyte*)"front_buffer_auto_refresh", 25))

27699 {

27700 ret = EGLEW_ANDROID_front_buffer_auto_refresh;

27701 continue;

27702 }

27703 #endif

27704 #ifdef EGL_ANDROID_image_native_buffer

27705 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_native_buffer", 19))

27706 {

27707 ret = EGLEW_ANDROID_image_native_buffer;

27708 continue;

27709 }

27710 #endif

27711 #ifdef EGL_ANDROID_native_fence_sync

27712 if (_glewStrSame3(&pos, &len, (const GLubyte*)"native_fence_sync", 17))

27713 {

27714 ret = EGLEW_ANDROID_native_fence_sync;

27715 continue;

27716 }

27717 #endif

27718 #ifdef EGL_ANDROID_presentation_time

27719 if (_glewStrSame3(&pos, &len, (const GLubyte*)"presentation_time", 17))

27720 {

27721 ret = EGLEW_ANDROID_presentation_time;

27722 continue;

27723 }

27724 #endif

27725 #ifdef EGL_ANDROID_recordable

27726 if (_glewStrSame3(&pos, &len, (const GLubyte*)"recordable", 10))

27727 {

27728 ret = EGLEW_ANDROID_recordable;

27729 continue;

27730 }

27731 #endif

27732 }

27733 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6))

27734 {

27735 #ifdef EGL_ANGLE_d3d_share_handle_client_buffer

27736 if (_glewStrSame3(&pos, &len, (const GLubyte*)"d3d_share_handle_client_buffer", 30))

27737 {

27738 ret = EGLEW_ANGLE_d3d_share_handle_client_buffer;

27739 continue;

27740 }

27741 #endif

27742 #ifdef EGL_ANGLE_device_d3d

27743 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_d3d", 10))

27744 {

27745 ret = EGLEW_ANGLE_device_d3d;

27746 continue;

27747 }

27748 #endif

27749 #ifdef EGL_ANGLE_query_surface_pointer

27750 if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_surface_pointer", 21))

27751 {

27752 ret = EGLEW_ANGLE_query_surface_pointer;

27753 continue;

27754 }

27755 #endif

27756 #ifdef EGL_ANGLE_surface_d3d_texture_2d_share_handle

27757 if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_d3d_texture_2d_share_handle", 35))

27758 {

27759 ret = EGLEW_ANGLE_surface_d3d_texture_2d_share_handle;

27760 continue;

27761 }

27762 #endif

27763 #ifdef EGL_ANGLE_window_fixed_size

27764 if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_fixed_size", 17))

27765 {

27766 ret = EGLEW_ANGLE_window_fixed_size;

27767 continue;

27768 }

27769 #endif

27770 }

27771 if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARM_", 4))

27772 {

27773 #ifdef EGL_ARM_implicit_external_sync

27774 if (_glewStrSame3(&pos, &len, (const GLubyte*)"implicit_external_sync", 22))

27775 {

27776 ret = EGLEW_ARM_implicit_external_sync;

27777 continue;

27778 }

27779 #endif

27780 #ifdef EGL_ARM_pixmap_multisample_discard

27781 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_multisample_discard", 26))

27782 {

27783 ret = EGLEW_ARM_pixmap_multisample_discard;

27784 continue;

27785 }

27786 #endif

27787 }

27788 if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

27789 {

27790 #ifdef EGL_EXT_buffer_age

27791 if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_age", 10))

27792 {

27793 ret = EGLEW_EXT_buffer_age;

27794 continue;

27795 }

27796 #endif

27797 #ifdef EGL_EXT_client_extensions

27798 if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_extensions", 17))

27799 {

27800 ret = EGLEW_EXT_client_extensions;

27801 continue;

27802 }

27803 #endif

27804 #ifdef EGL_EXT_create_context_robustness

27805 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))

27806 {

27807 ret = EGLEW_EXT_create_context_robustness;

27808 continue;

27809 }

27810 #endif

27811 #ifdef EGL_EXT_device_base

27812 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_base", 11))

27813 {

27814 ret = EGLEW_EXT_device_base;

27815 continue;

27816 }

27817 #endif

27818 #ifdef EGL_EXT_device_drm

27819 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_drm", 10))

27820 {

27821 ret = EGLEW_EXT_device_drm;

27822 continue;

27823 }

27824 #endif

27825 #ifdef EGL_EXT_device_enumeration

27826 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_enumeration", 18))

27827 {

27828 ret = EGLEW_EXT_device_enumeration;

27829 continue;

27830 }

27831 #endif

27832 #ifdef EGL_EXT_device_openwf

27833 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_openwf", 13))

27834 {

27835 ret = EGLEW_EXT_device_openwf;

27836 continue;

27837 }

27838 #endif

27839 #ifdef EGL_EXT_device_query

27840 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_query", 12))

27841 {

27842 ret = EGLEW_EXT_device_query;

27843 continue;

27844 }

27845 #endif

27846 #ifdef EGL_EXT_gl_colorspace_bt2020_linear

27847 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_linear", 27))

27848 {

27849 ret = EGLEW_EXT_gl_colorspace_bt2020_linear;

27850 continue;

27851 }

27852 #endif

27853 #ifdef EGL_EXT_gl_colorspace_bt2020_pq

27854 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_pq", 23))

27855 {

27856 ret = EGLEW_EXT_gl_colorspace_bt2020_pq;

27857 continue;

27858 }

27859 #endif

27860 #ifdef EGL_EXT_gl_colorspace_scrgb_linear

27861 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_scrgb_linear", 26))

27862 {

27863 ret = EGLEW_EXT_gl_colorspace_scrgb_linear;

27864 continue;

27865 }

27866 #endif

27867 #ifdef EGL_EXT_image_dma_buf_import

27868 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_dma_buf_import", 20))

27869 {

27870 ret = EGLEW_EXT_image_dma_buf_import;

27871 continue;

27872 }

27873 #endif

27874 #ifdef EGL_EXT_image_dma_buf_import_modifiers

27875 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_dma_buf_import_modifiers", 30))

27876 {

27877 ret = EGLEW_EXT_image_dma_buf_import_modifiers;

27878 continue;

27879 }

27880 #endif

27881 #ifdef EGL_EXT_multiview_window

27882 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_window", 16))

27883 {

27884 ret = EGLEW_EXT_multiview_window;

27885 continue;

27886 }

27887 #endif

27888 #ifdef EGL_EXT_output_base

27889 if (_glewStrSame3(&pos, &len, (const GLubyte*)"output_base", 11))

27890 {

27891 ret = EGLEW_EXT_output_base;

27892 continue;

27893 }

27894 #endif

27895 #ifdef EGL_EXT_output_drm

27896 if (_glewStrSame3(&pos, &len, (const GLubyte*)"output_drm", 10))

27897 {

27898 ret = EGLEW_EXT_output_drm;

27899 continue;

27900 }

27901 #endif

27902 #ifdef EGL_EXT_output_openwf

27903 if (_glewStrSame3(&pos, &len, (const GLubyte*)"output_openwf", 13))

27904 {

27905 ret = EGLEW_EXT_output_openwf;

27906 continue;

27907 }

27908 #endif

27909 #ifdef EGL_EXT_pixel_format_float

27910 if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

27911 {

27912 ret = EGLEW_EXT_pixel_format_float;

27913 continue;

27914 }

27915 #endif

27916 #ifdef EGL_EXT_platform_base

27917 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_base", 13))

27918 {

27919 ret = EGLEW_EXT_platform_base;

27920 continue;

27921 }

27922 #endif

27923 #ifdef EGL_EXT_platform_device

27924 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_device", 15))

27925 {

27926 ret = EGLEW_EXT_platform_device;

27927 continue;

27928 }

27929 #endif

27930 #ifdef EGL_EXT_platform_wayland

27931 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_wayland", 16))

27932 {

27933 ret = EGLEW_EXT_platform_wayland;

27934 continue;

27935 }

27936 #endif

27937 #ifdef EGL_EXT_platform_x11

27938 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_x11", 12))

27939 {

27940 ret = EGLEW_EXT_platform_x11;

27941 continue;

27942 }

27943 #endif

27944 #ifdef EGL_EXT_protected_content

27945 if (_glewStrSame3(&pos, &len, (const GLubyte*)"protected_content", 17))

27946 {

27947 ret = EGLEW_EXT_protected_content;

27948 continue;

27949 }

27950 #endif

27951 #ifdef EGL_EXT_protected_surface

27952 if (_glewStrSame3(&pos, &len, (const GLubyte*)"protected_surface", 17))

27953 {

27954 ret = EGLEW_EXT_protected_surface;

27955 continue;

27956 }

27957 #endif

27958 #ifdef EGL_EXT_stream_consumer_egloutput

27959 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_egloutput", 25))

27960 {

27961 ret = EGLEW_EXT_stream_consumer_egloutput;

27962 continue;

27963 }

27964 #endif

27965 #ifdef EGL_EXT_surface_SMPTE2086_metadata

27966 if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_SMPTE2086_metadata", 26))

27967 {

27968 ret = EGLEW_EXT_surface_SMPTE2086_metadata;

27969 continue;

27970 }

27971 #endif

27972 #ifdef EGL_EXT_swap_buffers_with_damage

27973 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_buffers_with_damage", 24))

27974 {

27975 ret = EGLEW_EXT_swap_buffers_with_damage;

27976 continue;

27977 }

27978 #endif

27979 #ifdef EGL_EXT_yuv_surface

27980 if (_glewStrSame3(&pos, &len, (const GLubyte*)"yuv_surface", 11))

27981 {

27982 ret = EGLEW_EXT_yuv_surface;

27983 continue;

27984 }

27985 #endif

27986 }

27987 if (_glewStrSame2(&pos, &len, (const GLubyte*)"HI_", 3))

27988 {

27989 #ifdef EGL_HI_clientpixmap

27990 if (_glewStrSame3(&pos, &len, (const GLubyte*)"clientpixmap", 12))

27991 {

27992 ret = EGLEW_HI_clientpixmap;

27993 continue;

27994 }

27995 #endif

27996 #ifdef EGL_HI_colorformats

27997 if (_glewStrSame3(&pos, &len, (const GLubyte*)"colorformats", 12))

27998 {

27999 ret = EGLEW_HI_colorformats;

28000 continue;

28001 }

28002 #endif

28003 }

28004 if (_glewStrSame2(&pos, &len, (const GLubyte*)"IMG_", 4))

28005 {

28006 #ifdef EGL_IMG_context_priority

28007 if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_priority", 16))

28008 {

28009 ret = EGLEW_IMG_context_priority;

28010 continue;

28011 }

28012 #endif

28013 #ifdef EGL_IMG_image_plane_attribs

28014 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_plane_attribs", 19))

28015 {

28016 ret = EGLEW_IMG_image_plane_attribs;

28017 continue;

28018 }

28019 #endif

28020 }

28021 if (_glewStrSame2(&pos, &len, (const GLubyte*)"KHR_", 4))

28022 {

28023 #ifdef EGL_KHR_cl_event

28024 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8))

28025 {

28026 ret = EGLEW_KHR_cl_event;

28027 continue;

28028 }

28029 #endif

28030 #ifdef EGL_KHR_cl_event2

28031 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event2", 9))

28032 {

28033 ret = EGLEW_KHR_cl_event2;

28034 continue;

28035 }

28036 #endif

28037 #ifdef EGL_KHR_client_get_all_proc_addresses

28038 if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_get_all_proc_addresses", 29))

28039 {

28040 ret = EGLEW_KHR_client_get_all_proc_addresses;

28041 continue;

28042 }

28043 #endif

28044 #ifdef EGL_KHR_config_attribs

28045 if (_glewStrSame3(&pos, &len, (const GLubyte*)"config_attribs", 14))

28046 {

28047 ret = EGLEW_KHR_config_attribs;

28048 continue;

28049 }

28050 #endif

28051 #ifdef EGL_KHR_context_flush_control

28052 if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21))

28053 {

28054 ret = EGLEW_KHR_context_flush_control;

28055 continue;

28056 }

28057 #endif

28058 #ifdef EGL_KHR_create_context

28059 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))

28060 {

28061 ret = EGLEW_KHR_create_context;

28062 continue;

28063 }

28064 #endif

28065 #ifdef EGL_KHR_create_context_no_error

28066 if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_no_error", 23))

28067 {

28068 ret = EGLEW_KHR_create_context_no_error;

28069 continue;

28070 }

28071 #endif

28072 #ifdef EGL_KHR_debug

28073 if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug", 5))

28074 {

28075 ret = EGLEW_KHR_debug;

28076 continue;

28077 }

28078 #endif

28079 #ifdef EGL_KHR_fence_sync

28080 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence_sync", 10))

28081 {

28082 ret = EGLEW_KHR_fence_sync;

28083 continue;

28084 }

28085 #endif

28086 #ifdef EGL_KHR_get_all_proc_addresses

28087 if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_all_proc_addresses", 22))

28088 {

28089 ret = EGLEW_KHR_get_all_proc_addresses;

28090 continue;

28091 }

28092 #endif

28093 #ifdef EGL_KHR_gl_colorspace

28094 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace", 13))

28095 {

28096 ret = EGLEW_KHR_gl_colorspace;

28097 continue;

28098 }

28099 #endif

28100 #ifdef EGL_KHR_gl_renderbuffer_image

28101 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_renderbuffer_image", 21))

28102 {

28103 ret = EGLEW_KHR_gl_renderbuffer_image;

28104 continue;

28105 }

28106 #endif

28107 #ifdef EGL_KHR_gl_texture_2D_image

28108 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_texture_2D_image", 19))

28109 {

28110 ret = EGLEW_KHR_gl_texture_2D_image;

28111 continue;

28112 }

28113 #endif

28114 #ifdef EGL_KHR_gl_texture_3D_image

28115 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_texture_3D_image", 19))

28116 {

28117 ret = EGLEW_KHR_gl_texture_3D_image;

28118 continue;

28119 }

28120 #endif

28121 #ifdef EGL_KHR_gl_texture_cubemap_image

28122 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_texture_cubemap_image", 24))

28123 {

28124 ret = EGLEW_KHR_gl_texture_cubemap_image;

28125 continue;

28126 }

28127 #endif

28128 #ifdef EGL_KHR_image

28129 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image", 5))

28130 {

28131 ret = EGLEW_KHR_image;

28132 continue;

28133 }

28134 #endif

28135 #ifdef EGL_KHR_image_base

28136 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_base", 10))

28137 {

28138 ret = EGLEW_KHR_image_base;

28139 continue;

28140 }

28141 #endif

28142 #ifdef EGL_KHR_image_pixmap

28143 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_pixmap", 12))

28144 {

28145 ret = EGLEW_KHR_image_pixmap;

28146 continue;

28147 }

28148 #endif

28149 #ifdef EGL_KHR_lock_surface

28150 if (_glewStrSame3(&pos, &len, (const GLubyte*)"lock_surface", 12))

28151 {

28152 ret = EGLEW_KHR_lock_surface;

28153 continue;

28154 }

28155 #endif

28156 #ifdef EGL_KHR_lock_surface2

28157 if (_glewStrSame3(&pos, &len, (const GLubyte*)"lock_surface2", 13))

28158 {

28159 ret = EGLEW_KHR_lock_surface2;

28160 continue;

28161 }

28162 #endif

28163 #ifdef EGL_KHR_lock_surface3

28164 if (_glewStrSame3(&pos, &len, (const GLubyte*)"lock_surface3", 13))

28165 {

28166 ret = EGLEW_KHR_lock_surface3;

28167 continue;

28168 }

28169 #endif

28170 #ifdef EGL_KHR_mutable_render_buffer

28171 if (_glewStrSame3(&pos, &len, (const GLubyte*)"mutable_render_buffer", 21))

28172 {

28173 ret = EGLEW_KHR_mutable_render_buffer;

28174 continue;

28175 }

28176 #endif

28177 #ifdef EGL_KHR_no_config_context

28178 if (_glewStrSame3(&pos, &len, (const GLubyte*)"no_config_context", 17))

28179 {

28180 ret = EGLEW_KHR_no_config_context;

28181 continue;

28182 }

28183 #endif

28184 #ifdef EGL_KHR_partial_update

28185 if (_glewStrSame3(&pos, &len, (const GLubyte*)"partial_update", 14))

28186 {

28187 ret = EGLEW_KHR_partial_update;

28188 continue;

28189 }

28190 #endif

28191 #ifdef EGL_KHR_platform_android

28192 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_android", 16))

28193 {

28194 ret = EGLEW_KHR_platform_android;

28195 continue;

28196 }

28197 #endif

28198 #ifdef EGL_KHR_platform_gbm

28199 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_gbm", 12))

28200 {

28201 ret = EGLEW_KHR_platform_gbm;

28202 continue;

28203 }

28204 #endif

28205 #ifdef EGL_KHR_platform_wayland

28206 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_wayland", 16))

28207 {

28208 ret = EGLEW_KHR_platform_wayland;

28209 continue;

28210 }

28211 #endif

28212 #ifdef EGL_KHR_platform_x11

28213 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_x11", 12))

28214 {

28215 ret = EGLEW_KHR_platform_x11;

28216 continue;

28217 }

28218 #endif

28219 #ifdef EGL_KHR_reusable_sync

28220 if (_glewStrSame3(&pos, &len, (const GLubyte*)"reusable_sync", 13))

28221 {

28222 ret = EGLEW_KHR_reusable_sync;

28223 continue;

28224 }

28225 #endif

28226 #ifdef EGL_KHR_stream

28227 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream", 6))

28228 {

28229 ret = EGLEW_KHR_stream;

28230 continue;

28231 }

28232 #endif

28233 #ifdef EGL_KHR_stream_attrib

28234 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_attrib", 13))

28235 {

28236 ret = EGLEW_KHR_stream_attrib;

28237 continue;

28238 }

28239 #endif

28240 #ifdef EGL_KHR_stream_consumer_gltexture

28241 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_gltexture", 25))

28242 {

28243 ret = EGLEW_KHR_stream_consumer_gltexture;

28244 continue;

28245 }

28246 #endif

28247 #ifdef EGL_KHR_stream_cross_process_fd

28248 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_process_fd", 23))

28249 {

28250 ret = EGLEW_KHR_stream_cross_process_fd;

28251 continue;

28252 }

28253 #endif

28254 #ifdef EGL_KHR_stream_fifo

28255 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_fifo", 11))

28256 {

28257 ret = EGLEW_KHR_stream_fifo;

28258 continue;

28259 }

28260 #endif

28261 #ifdef EGL_KHR_stream_producer_aldatalocator

28262 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_producer_aldatalocator", 29))

28263 {

28264 ret = EGLEW_KHR_stream_producer_aldatalocator;

28265 continue;

28266 }

28267 #endif

28268 #ifdef EGL_KHR_stream_producer_eglsurface

28269 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_producer_eglsurface", 26))

28270 {

28271 ret = EGLEW_KHR_stream_producer_eglsurface;

28272 continue;

28273 }

28274 #endif

28275 #ifdef EGL_KHR_surfaceless_context

28276 if (_glewStrSame3(&pos, &len, (const GLubyte*)"surfaceless_context", 19))

28277 {

28278 ret = EGLEW_KHR_surfaceless_context;

28279 continue;

28280 }

28281 #endif

28282 #ifdef EGL_KHR_swap_buffers_with_damage

28283 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_buffers_with_damage", 24))

28284 {

28285 ret = EGLEW_KHR_swap_buffers_with_damage;

28286 continue;

28287 }

28288 #endif

28289 #ifdef EGL_KHR_vg_parent_image

28290 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vg_parent_image", 15))

28291 {

28292 ret = EGLEW_KHR_vg_parent_image;

28293 continue;

28294 }

28295 #endif

28296 #ifdef EGL_KHR_wait_sync

28297 if (_glewStrSame3(&pos, &len, (const GLubyte*)"wait_sync", 9))

28298 {

28299 ret = EGLEW_KHR_wait_sync;

28300 continue;

28301 }

28302 #endif

28303 }

28304 if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

28305 {

28306 #ifdef EGL_MESA_drm_image

28307 if (_glewStrSame3(&pos, &len, (const GLubyte*)"drm_image", 9))

28308 {

28309 ret = EGLEW_MESA_drm_image;

28310 continue;

28311 }

28312 #endif

28313 #ifdef EGL_MESA_image_dma_buf_export

28314 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_dma_buf_export", 20))

28315 {

28316 ret = EGLEW_MESA_image_dma_buf_export;

28317 continue;

28318 }

28319 #endif

28320 #ifdef EGL_MESA_platform_gbm

28321 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_gbm", 12))

28322 {

28323 ret = EGLEW_MESA_platform_gbm;

28324 continue;

28325 }

28326 #endif

28327 #ifdef EGL_MESA_platform_surfaceless

28328 if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_surfaceless", 20))

28329 {

28330 ret = EGLEW_MESA_platform_surfaceless;

28331 continue;

28332 }

28333 #endif

28334 }

28335 if (_glewStrSame2(&pos, &len, (const GLubyte*)"NOK_", 4))

28336 {

28337 #ifdef EGL_NOK_swap_region

28338 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_region", 11))

28339 {

28340 ret = EGLEW_NOK_swap_region;

28341 continue;

28342 }

28343 #endif

28344 #ifdef EGL_NOK_swap_region2

28345 if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_region2", 12))

28346 {

28347 ret = EGLEW_NOK_swap_region2;

28348 continue;

28349 }

28350 #endif

28351 #ifdef EGL_NOK_texture_from_pixmap

28352 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))

28353 {

28354 ret = EGLEW_NOK_texture_from_pixmap;

28355 continue;

28356 }

28357 #endif

28358 }

28359 if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

28360 {

28361 #ifdef EGL_NV_3dvision_surface

28362 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3dvision_surface", 16))

28363 {

28364 ret = EGLEW_NV_3dvision_surface;

28365 continue;

28366 }

28367 #endif

28368 #ifdef EGL_NV_coverage_sample

28369 if (_glewStrSame3(&pos, &len, (const GLubyte*)"coverage_sample", 15))

28370 {

28371 ret = EGLEW_NV_coverage_sample;

28372 continue;

28373 }

28374 #endif

28375 #ifdef EGL_NV_coverage_sample_resolve

28376 if (_glewStrSame3(&pos, &len, (const GLubyte*)"coverage_sample_resolve", 23))

28377 {

28378 ret = EGLEW_NV_coverage_sample_resolve;

28379 continue;

28380 }

28381 #endif

28382 #ifdef EGL_NV_cuda_event

28383 if (_glewStrSame3(&pos, &len, (const GLubyte*)"cuda_event", 10))

28384 {

28385 ret = EGLEW_NV_cuda_event;

28386 continue;

28387 }

28388 #endif

28389 #ifdef EGL_NV_depth_nonlinear

28390 if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_nonlinear", 15))

28391 {

28392 ret = EGLEW_NV_depth_nonlinear;

28393 continue;

28394 }

28395 #endif

28396 #ifdef EGL_NV_device_cuda

28397 if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_cuda", 11))

28398 {

28399 ret = EGLEW_NV_device_cuda;

28400 continue;

28401 }

28402 #endif

28403 #ifdef EGL_NV_native_query

28404 if (_glewStrSame3(&pos, &len, (const GLubyte*)"native_query", 12))

28405 {

28406 ret = EGLEW_NV_native_query;

28407 continue;

28408 }

28409 #endif

28410 #ifdef EGL_NV_post_convert_rounding

28411 if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_convert_rounding", 21))

28412 {

28413 ret = EGLEW_NV_post_convert_rounding;

28414 continue;

28415 }

28416 #endif

28417 #ifdef EGL_NV_post_sub_buffer

28418 if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_sub_buffer", 15))

28419 {

28420 ret = EGLEW_NV_post_sub_buffer;

28421 continue;

28422 }

28423 #endif

28424 #ifdef EGL_NV_robustness_video_memory_purge

28425 if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_video_memory_purge", 29))

28426 {

28427 ret = EGLEW_NV_robustness_video_memory_purge;

28428 continue;

28429 }

28430 #endif

28431 #ifdef EGL_NV_stream_consumer_gltexture_yuv

28432 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_gltexture_yuv", 29))

28433 {

28434 ret = EGLEW_NV_stream_consumer_gltexture_yuv;

28435 continue;

28436 }

28437 #endif

28438 #ifdef EGL_NV_stream_cross_display

28439 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_display", 20))

28440 {

28441 ret = EGLEW_NV_stream_cross_display;

28442 continue;

28443 }

28444 #endif

28445 #ifdef EGL_NV_stream_cross_object

28446 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_object", 19))

28447 {

28448 ret = EGLEW_NV_stream_cross_object;

28449 continue;

28450 }

28451 #endif

28452 #ifdef EGL_NV_stream_cross_partition

28453 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_partition", 22))

28454 {

28455 ret = EGLEW_NV_stream_cross_partition;

28456 continue;

28457 }

28458 #endif

28459 #ifdef EGL_NV_stream_cross_process

28460 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_process", 20))

28461 {

28462 ret = EGLEW_NV_stream_cross_process;

28463 continue;

28464 }

28465 #endif

28466 #ifdef EGL_NV_stream_cross_system

28467 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_system", 19))

28468 {

28469 ret = EGLEW_NV_stream_cross_system;

28470 continue;

28471 }

28472 #endif

28473 #ifdef EGL_NV_stream_fifo_next

28474 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_fifo_next", 16))

28475 {

28476 ret = EGLEW_NV_stream_fifo_next;

28477 continue;

28478 }

28479 #endif

28480 #ifdef EGL_NV_stream_fifo_synchronous

28481 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_fifo_synchronous", 23))

28482 {

28483 ret = EGLEW_NV_stream_fifo_synchronous;

28484 continue;

28485 }

28486 #endif

28487 #ifdef EGL_NV_stream_frame_limits

28488 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_frame_limits", 19))

28489 {

28490 ret = EGLEW_NV_stream_frame_limits;

28491 continue;

28492 }

28493 #endif

28494 #ifdef EGL_NV_stream_metadata

28495 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_metadata", 15))

28496 {

28497 ret = EGLEW_NV_stream_metadata;

28498 continue;

28499 }

28500 #endif

28501 #ifdef EGL_NV_stream_remote

28502 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_remote", 13))

28503 {

28504 ret = EGLEW_NV_stream_remote;

28505 continue;

28506 }

28507 #endif

28508 #ifdef EGL_NV_stream_reset

28509 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_reset", 12))

28510 {

28511 ret = EGLEW_NV_stream_reset;

28512 continue;

28513 }

28514 #endif

28515 #ifdef EGL_NV_stream_socket

28516 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_socket", 13))

28517 {

28518 ret = EGLEW_NV_stream_socket;

28519 continue;

28520 }

28521 #endif

28522 #ifdef EGL_NV_stream_socket_inet

28523 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_socket_inet", 18))

28524 {

28525 ret = EGLEW_NV_stream_socket_inet;

28526 continue;

28527 }

28528 #endif

28529 #ifdef EGL_NV_stream_socket_unix

28530 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_socket_unix", 18))

28531 {

28532 ret = EGLEW_NV_stream_socket_unix;

28533 continue;

28534 }

28535 #endif

28536 #ifdef EGL_NV_stream_sync

28537 if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_sync", 11))

28538 {

28539 ret = EGLEW_NV_stream_sync;

28540 continue;

28541 }

28542 #endif

28543 #ifdef EGL_NV_sync

28544 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))

28545 {

28546 ret = EGLEW_NV_sync;

28547 continue;

28548 }

28549 #endif

28550 #ifdef EGL_NV_system_time

28551 if (_glewStrSame3(&pos, &len, (const GLubyte*)"system_time", 11))

28552 {

28553 ret = EGLEW_NV_system_time;

28554 continue;

28555 }

28556 #endif

28557 }

28558 if (_glewStrSame2(&pos, &len, (const GLubyte*)"TIZEN_", 6))

28559 {

28560 #ifdef EGL_TIZEN_image_native_buffer

28561 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_native_buffer", 19))

28562 {

28563 ret = EGLEW_TIZEN_image_native_buffer;

28564 continue;

28565 }

28566 #endif

28567 #ifdef EGL_TIZEN_image_native_surface

28568 if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_native_surface", 20))

28569 {

28570 ret = EGLEW_TIZEN_image_native_surface;

28571 continue;

28572 }

28573 #endif

28574 }

28575 }

28576 ret = (len == 0);

28577 }

28578 return ret;

28579 }

28580

28581 #endif /* _WIN32 */