~ubuntu-branches/ubuntu/trusty/glew/trusty : revision 5

1

/*

2

** The OpenGL Extension Wrangler Library

3

4

5

6

7

**

8

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

9

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

10

**

11

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

12

** this list of conditions and the following disclaimer.

13

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

14

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

15

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

16

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

17

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

18

**

19

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

20

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

21

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

22

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

23

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

24

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

25

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

26

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

27

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

28

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

29

** THE POSSIBILITY OF SUCH DAMAGE.

30

*/

31

32

#include <GL/glew.h>

33

#if defined(_WIN32)

34

# include <GL/wglew.h>

35

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

36

# include <GL/glxew.h>

37

#endif

38

39

/*

40

* Define glewGetContext and related helper macros.

41

*/

42

#ifdef GLEW_MX

43

# define glewGetContext() ctx

44

# ifdef _WIN32

45

# define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx

46

# define GLEW_CONTEXT_ARG_VAR_INIT ctx

47

# define wglewGetContext() ctx

48

# define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx

49

# define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx

50

# else /* _WIN32 */

51

# define GLEW_CONTEXT_ARG_DEF_INIT void

52

# define GLEW_CONTEXT_ARG_VAR_INIT

53

# define glxewGetContext() ctx

54

# define GLXEW_CONTEXT_ARG_DEF_INIT void

55

# define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx

56

# endif /* _WIN32 */

57

# define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx

58

#else /* GLEW_MX */

59

# define GLEW_CONTEXT_ARG_DEF_INIT void

60

# define GLEW_CONTEXT_ARG_VAR_INIT

61

# define GLEW_CONTEXT_ARG_DEF_LIST void

62

# define WGLEW_CONTEXT_ARG_DEF_INIT void

63

# define WGLEW_CONTEXT_ARG_DEF_LIST void

64

# define GLXEW_CONTEXT_ARG_DEF_INIT void

65

# define GLXEW_CONTEXT_ARG_DEF_LIST void

66

#endif /* GLEW_MX */

67

68

#if defined(__APPLE__)

69

#include <mach-o/dyld.h>

70

#include <stdlib.h>

71

#include <string.h>

72

73

void* NSGLGetProcAddress (const GLubyte *name)

74

{

75

static const struct mach_header* image = NULL;

76

NSSymbol symbol;

77

char* symbolName;

78

if (NULL == image)

79

{

80

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

81

}

82

/* prepend a '_' for the Unix C symbol mangling convention */

83

symbolName = malloc(strlen((const char*)name) + 2);

84

strcpy(symbolName+1, (const char*)name);

85

symbolName[0] = '_';

86

symbol = NULL;

87

/* if (NSIsSymbolNameDefined(symbolName))

88

symbol = NSLookupAndBindSymbol(symbolName); */

89

symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL;

90

free(symbolName);

91

return symbol ? NSAddressOfSymbol(symbol) : NULL;

92

}

93

#endif /* __APPLE__ */

94

95

#if defined(__sgi) || defined (__sun)

96

#include <dlfcn.h>

97

#include <stdio.h>

98

#include <stdlib.h>

99

100

void* dlGetProcAddress (const GLubyte* name)

101

{

102

static void* h = NULL;

103

static void* gpa;

104

105

if (h == NULL)

106

{

107

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

108

gpa = dlsym(h, "glXGetProcAddress");

109

}

110

111

if (gpa != NULL)

112

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

113

else

114

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

115

}

116

#endif /* __sgi || __sun */

117

118

/*

119

* Define glewGetProcAddress.

120

*/

121

#if defined(_WIN32)

122

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

123

#else

124

# if defined(__APPLE__)

125

# define glewGetProcAddress(name) NSGLGetProcAddress(name)

126

# else

127

# if defined(__sgi) || defined(__sun)

128

# define glewGetProcAddress(name) dlGetProcAddress(name)

129

# else /* __linux */

130

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

131

# endif

132

# endif

133

#endif

134

135

/*

136

* Define GLboolean const cast.

137

*/

138

#define CONST_CAST(x) (*(GLboolean*)&x)

139

140

/*

141

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

142

* These functions implement the functionality required in this file.

143

*/

144

static GLuint _glewStrLen (const GLubyte* s)

145

{

146

GLuint i=0;

147

if (s == NULL) return 0;

148

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

149

return i;

150

}

151

152

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

153

{

154

GLuint i=0;

155

if (s == NULL) return 0;

156

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

157

return s[i] == c ? i : 0;

158

}

159

160

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

161

{

162

GLuint i=0;

163

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

164

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

165

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

166

return i == n ? GL_TRUE : GL_FALSE;

167

}

168

169

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

170

{

171

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

172

{

173

(*a)++;

174

(*na)--;

175

}

176

if(*na >= nb)

177

{

178

GLuint i=0;

179

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

180

if(i == nb)

181

{

182

*a = *a + nb;

183

*na = *na - nb;

184

return GL_TRUE;

185

}

186

}

187

return GL_FALSE;

188

}

189

190

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

191

{

192

if(*na >= nb)

193

{

194

GLuint i=0;

195

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

196

if(i == nb)

197

{

198

*a = *a + nb;

199

*na = *na - nb;

200

return GL_TRUE;

201

}

202

}

203

return GL_FALSE;

204

}

205

206

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

207

{

208

if(*na >= nb)

209

{

210

GLuint i=0;

211

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

212

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

213

{

214

*a = *a + nb;

215

*na = *na - nb;

216

return GL_TRUE;

217

}

218

}

219

return GL_FALSE;

220

}

221

222

#if !defined(_WIN32) || !defined(GLEW_MX)

223

224

PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;

225

PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;

226

PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;

227

PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;

228

229

PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;

230

PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;

231

PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;

232

PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;

233

PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;

234

PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;

235

PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;

236

PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;

237

PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;

238

PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;

239

PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;

240

PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;

241

PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;

242

PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;

243

PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;

244

PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;

245

PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;

246

PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;

247

PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;

248

PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;

249

PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;

250

PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;

251

PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;

252

PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;

253

PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;

254

PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;

255

PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;

256

PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;

257

PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;

258

PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;

259

PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;

260

PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;

261

PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;

262

PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;

263

PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;

264

PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;

265

PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;

266

PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;

267

PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;

268

PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;

269

PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;

270

PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;

271

PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;

272

PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;

273

PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;

274

PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;

275

276

PFNGLBLENDCOLORPROC __glewBlendColor = NULL;

277

PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;

278

PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;

279

PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;

280

PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;

281

PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;

282

PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;

283

PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;

284

PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;

285

PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;

286

PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;

287

PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;

288

PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL;

289

PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL;

290

PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;

291

PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;

292

PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;

293

PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;

294

PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;

295

PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;

296

PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;

297

PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;

298

PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;

299

PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;

300

PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;

301

PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;

302

PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;

303

PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;

304

PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;

305

PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;

306

PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;

307

PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;

308

PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;

309

PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;

310

PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;

311

PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;

312

PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;

313

PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;

314

PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;

315

PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;

316

PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;

317

PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;

318

PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;

319

PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;

320

PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;

321

PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;

322

PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;

323

324

PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;

325

PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;

326

PFNGLBUFFERDATAPROC __glewBufferData = NULL;

327

PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;

328

PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;

329

PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;

330

PFNGLENDQUERYPROC __glewEndQuery = NULL;

331

PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;

332

PFNGLGENQUERIESPROC __glewGenQueries = NULL;

333

PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;

334

PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;

335

PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;

336

PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;

337

PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;

338

PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;

339

PFNGLISBUFFERPROC __glewIsBuffer = NULL;

340

PFNGLISQUERYPROC __glewIsQuery = NULL;

341

PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;

342

PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;

343

344

PFNGLATTACHSHADERPROC __glewAttachShader = NULL;

345

PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;

346

PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;

347

PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;

348

PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;

349

PFNGLCREATESHADERPROC __glewCreateShader = NULL;

350

PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;

351

PFNGLDELETESHADERPROC __glewDeleteShader = NULL;

352

PFNGLDETACHSHADERPROC __glewDetachShader = NULL;

353

PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;

354

PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;

355

PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;

356

PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;

357

PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;

358

PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;

359

PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;

360

PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;

361

PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;

362

PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;

363

PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;

364

PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;

365

PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;

366

PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;

367

PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;

368

PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;

369

PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;

370

PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;

371

PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;

372

PFNGLISPROGRAMPROC __glewIsProgram = NULL;

373

PFNGLISSHADERPROC __glewIsShader = NULL;

374

PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;

375

PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;

376

PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;

377

PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;

378

PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;

379

PFNGLUNIFORM1FPROC __glewUniform1f = NULL;

380

PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;

381

PFNGLUNIFORM1IPROC __glewUniform1i = NULL;

382

PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;

383

PFNGLUNIFORM2FPROC __glewUniform2f = NULL;

384

PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;

385

PFNGLUNIFORM2IPROC __glewUniform2i = NULL;

386

PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;

387

PFNGLUNIFORM3FPROC __glewUniform3f = NULL;

388

PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;

389

PFNGLUNIFORM3IPROC __glewUniform3i = NULL;

390

PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;

391

PFNGLUNIFORM4FPROC __glewUniform4f = NULL;

392

PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;

393

PFNGLUNIFORM4IPROC __glewUniform4i = NULL;

394

PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;

395

PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;

396

PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;

397

PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;

398

PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;

399

PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;

400

PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;

401

PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;

402

PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;

403

PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;

404

PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;

405

PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;

406

PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;

407

PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;

408

PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;

409

PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;

410

PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;

411

PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;

412

PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;

413

PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;

414

PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;

415

PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;

416

PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;

417

PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;

418

PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;

419

PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;

420

PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;

421

PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;

422

PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;

423

PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;

424

PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;

425

PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;

426

PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;

427

PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;

428

PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;

429

PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;

430

PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;

431

PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;

432

PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;

433

PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;

434

PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;

435

PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;

436

PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;

437

438

PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;

439

PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;

440

PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;

441

PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;

442

PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;

443

PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;

444

445

PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;

446

447

PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;

448

PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;

449

PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;

450

PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;

451

PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;

452

453

PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;

454

PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;

455

PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;

456

PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;

457

PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;

458

PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;

459

PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;

460

PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;

461

462

PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;

463

PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;

464

465

PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;

466

PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;

467

468

PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;

469

PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;

470

PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;

471

PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;

472

473

PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;

474

PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;

475

PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;

476

477

PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;

478

479

PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;

480

481

PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;

482

PFNGLCOLORTABLEPROC __glewColorTable = NULL;

483

PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;

484

PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;

485

PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;

486

PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;

487

PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;

488

PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;

489

PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;

490

PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;

491

PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;

492

PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;

493

PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;

494

PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;

495

PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;

496

PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;

497

PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;

498

PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;

499

PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;

500

PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;

501

PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;

502

PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;

503

PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;

504

PFNGLGETMINMAXPROC __glewGetMinmax = NULL;

505

PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;

506

PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;

507

PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;

508

PFNGLHISTOGRAMPROC __glewHistogram = NULL;

509

PFNGLMINMAXPROC __glewMinmax = NULL;

510

PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;

511

PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;

512

PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;

513

514

PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;

515

PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;

516

PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;

517

PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;

518

PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;

519

520

PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;

521

522

PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;

523

PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;

524

PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;

525

PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;

526

PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;

527

PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;

528

PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;

529

PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;

530

PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;

531

PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;

532

PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;

533

PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;

534

PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;

535

PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;

536

PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;

537

PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;

538

PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;

539

PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;

540

PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;

541

PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;

542

PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;

543

PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;

544

PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;

545

PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;

546

PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;

547

PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;

548

PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;

549

PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;

550

PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;

551

PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;

552

PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;

553

PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;

554

PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;

555

PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;

556

557

PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;

558

PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;

559

PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;

560

PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;

561

PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;

562

PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;

563

PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;

564

PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;

565

566

PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;

567

PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;

568

569

PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;

570

PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;

571

PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;

572

PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;

573

PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;

574

PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;

575

PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;

576

PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;

577

PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;

578

PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;

579

PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;

580

PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;

581

PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;

582

PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;

583

PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;

584

PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;

585

PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;

586

PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;

587

PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;

588

PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;

589

PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;

590

PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;

591

PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;

592

PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;

593

PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;

594

PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;

595

PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;

596

PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;

597

PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;

598

PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;

599

PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;

600

PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;

601

PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;

602

PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;

603

PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;

604

PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;

605

PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;

606

PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;

607

PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;

608

609

PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;

610

PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;

611

PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;

612

PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;

613

PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;

614

PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;

615

PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;

616

617

PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;

618

PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;

619

PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;

620

PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;

621

622

PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;

623

PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;

624

PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;

625

PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;

626

PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;

627

PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;

628

PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;

629

PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;

630

PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;

631

PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;

632

633

PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;

634

PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;

635

PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;

636

PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;

637

PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;

638

PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;

639

PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;

640

PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;

641

PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;

642

PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;

643

PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;

644

645

PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;

646

PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;

647

PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;

648

PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;

649

PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;

650

PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;

651

PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;

652

PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;

653

PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;

654

PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;

655

PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;

656

PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;

657

PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;

658

PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;

659

PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;

660

PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;

661

PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;

662

PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;

663

PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;

664

PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;

665

PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;

666

PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;

667

PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;

668

PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;

669

PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;

670

PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;

671

PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;

672

PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;

673

PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;

674

PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;

675

PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;

676

PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;

677

PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;

678

PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;

679

PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;

680

PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;

681

PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;

682

PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;

683

PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;

684

PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;

685

PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;

686

PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;

687

PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;

688

PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;

689

PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;

690

PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;

691

PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;

692

PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;

693

PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;

694

PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;

695

PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;

696

PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;

697

PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;

698

PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;

699

PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;

700

PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;

701

PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;

702

PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;

703

PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;

704

PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;

705

PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;

706

PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;

707

708

PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;

709

PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;

710

PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;

711

712

PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;

713

PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;

714

PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;

715

PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;

716

PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;

717

PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;

718

PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;

719

PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;

720

PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;

721

PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;

722

PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;

723

PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;

724

PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;

725

PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;

726

PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;

727

PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;

728

729

PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;

730

731

PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;

732

PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;

733

PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;

734

735

PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;

736

PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;

737

PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;

738

PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;

739

740

PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;

741

PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;

742

PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;

743

PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;

744

PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;

745

PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;

746

PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;

747

PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;

748

PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;

749

PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;

750

PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;

751

PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;

752

PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;

753

PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;

754

755

PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;

756

PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;

757

758

PFNGLPNTRIANGLESFATIPROC __glPNTrianglewesfATI = NULL;

759

PFNGLPNTRIANGLESIATIPROC __glPNTrianglewesiATI = NULL;

760

761

PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;

762

PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;

763

764

PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;

765

PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;

766

PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;

767

PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;

768

PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;

769

PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;

770

PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;

771

PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;

772

PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;

773

PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;

774

PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;

775

PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;

776

777

PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;

778

PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;

779

PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;

780

781

PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;

782

PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;

783

PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;

784

PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;

785

PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;

786

PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;

787

PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;

788

PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;

789

PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;

790

PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;

791

PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;

792

PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;

793

PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;

794

PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;

795

PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;

796

PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;

797

PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;

798

PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;

799

PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;

800

PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;

801

PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;

802

PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;

803

PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;

804

PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;

805

PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;

806

PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;

807

PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;

808

PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;

809

PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;

810

PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;

811

PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;

812

PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;

813

PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;

814

PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;

815

PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;

816

PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;

817

PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;

818

819

PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL;

820

PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL;

821

PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL;

822

823

PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;

824

825

PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;

826

827

PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;

828

829

PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;

830

831

PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;

832

PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;

833

834

PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;

835

PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;

836

837

PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;

838

PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;

839

PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;

840

PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;

841

PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;

842

PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;

843

PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;

844

PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;

845

PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;

846

PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;

847

PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;

848

PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;

849

PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;

850

851

PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;

852

PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;

853

854

PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;

855

PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;

856

PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;

857

PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;

858

PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;

859

860

PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;

861

PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;

862

863

PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;

864

865

PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;

866

PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;

867

PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL;

868

PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL;

869

PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL;

870

PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL;

871

872

PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL;

873

PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL;

874

875

PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;

876

877

PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;

878

PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;

879

PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;

880

PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;

881

PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;

882

883

PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;

884

PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;

885

PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;

886

PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;

887

PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;

888

PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;

889

PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;

890

PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;

891

PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;

892

PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;

893

PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;

894

PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;

895

PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;

896

PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;

897

PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;

898

PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;

899

PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;

900

PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;

901

902

PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;

903

904

PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;

905

906

PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;

907

PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;

908

PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;

909

PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;

910

PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;

911

PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;

912

PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;

913

PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;

914

PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;

915

PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;

916

PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;

917

PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;

918

PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;

919

PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;

920

PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;

921

PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;

922

PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;

923

924

PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL;

925

PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL;

926

PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL;

927

PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL;

928

929

PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL;

930

PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL;

931

932

PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL;

933

PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL;

934

PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL;

935

PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL;

936

PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL;

937

PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL;

938

PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL;

939

PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL;

940

PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL;

941

PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL;

942

PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL;

943

PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL;

944

PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL;

945

PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL;

946

PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL;

947

PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL;

948

PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL;

949

PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL;

950

PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL;

951

PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL;

952

PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL;

953

PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL;

954

PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL;

955

PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL;

956

PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL;

957

PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL;

958

PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL;

959

PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL;

960

PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL;

961

PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL;

962

PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL;

963

PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL;

964

PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL;

965

PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL;

966

967

PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;

968

PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;

969

PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;

970

PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;

971

PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;

972

PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;

973

PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;

974

PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;

975

PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;

976

PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;

977

978

PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;

979

980

PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;

981

982

PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;

983

PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;

984

PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;

985

986

PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;

987

PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;

988

989

PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;

990

PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;

991

992

PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;

993

PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;

994

PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;

995

PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;

996

997

PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;

998

PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;

999

PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;

1000

PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;

1001

PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;

1002

PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;

1003

1004

PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;

1005

PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;

1006

1007

PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;

1008

1009

PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;

1010

PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;

1011

1012

PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;

1013

PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;

1014

PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;

1015

PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;

1016

PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;

1017

PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;

1018

PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;

1019

PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;

1020

PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;

1021

PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;

1022

PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;

1023

PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;

1024

PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;

1025

PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;

1026

PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;

1027

PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;

1028

PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;

1029

1030

PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;

1031

1032

PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;

1033

PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;

1034

PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;

1035

1036

PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;

1037

1038

PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL;

1039

1040

PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL;

1041

PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL;

1042

PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL;

1043

PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL;

1044

PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL;

1045

PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL;

1046

1047

PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;

1048

PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;

1049

PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;

1050

PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;

1051

PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;

1052

PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;

1053

1054

PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;

1055

1056

PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;

1057

PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL;

1058

1059

PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;

1060

PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;

1061

PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;

1062

PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;

1063

PFNGLGETPOINTERVEXTPROC __glewGetPointervEXT = NULL;

1064

PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;

1065

PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;

1066

PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;

1067

PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;

1068

1069

PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;

1070

PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;

1071

PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;

1072

PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;

1073

PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;

1074

PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;

1075

PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;

1076

PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;

1077

PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;

1078

PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;

1079

PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;

1080

PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;

1081

PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;

1082

PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;

1083

PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;

1084

PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;

1085

PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;

1086

PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;

1087

PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;

1088

PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;

1089

PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;

1090

PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;

1091

PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;

1092

PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;

1093

PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;

1094

PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;

1095

PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;

1096

PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;

1097

PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;

1098

PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;

1099

PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;

1100

PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;

1101

PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;

1102

PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;

1103

PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;

1104

PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;

1105

PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;

1106

PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;

1107

PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;

1108

PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;

1109

PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;

1110

PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;

1111

1112

PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;

1113

PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;

1114

PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;

1115

1116

PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL;

1117

1118

PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL;

1119

1120

PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;

1121

PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;

1122

PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;

1123

PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;

1124

PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;

1125

PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;

1126

1127

PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;

1128

PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;

1129

1130

PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;

1131

PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;

1132

PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;

1133

PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;

1134

PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;

1135

PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;

1136

PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;

1137

PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;

1138

1139

PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;

1140

PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;

1141

PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;

1142

PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;

1143

1144

PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;

1145

PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;

1146

1147

PFNGLBUFFERREGIONENABLEDEXTPROC __glewBufferRegionEnabledEXT = NULL;

1148

PFNGLDELETEBUFFERREGIONEXTPROC __glewDeleteBufferRegionEXT = NULL;

1149

PFNGLDRAWBUFFERREGIONEXTPROC __glewDrawBufferRegionEXT = NULL;

1150

PFNGLNEWBUFFERREGIONEXTPROC __glewNewBufferRegionEXT = NULL;

1151

PFNGLREADBUFFERREGIONEXTPROC __glewReadBufferRegionEXT = NULL;

1152

1153

PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;

1154

1155

PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;

1156

PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;

1157

PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;

1158

PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;

1159

PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;

1160

PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;

1161

PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;

1162

PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;

1163

PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;

1164

PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;

1165

PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;

1166

PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;

1167

PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;

1168

PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;

1169

PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;

1170

PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;

1171

PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;

1172

PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;

1173

PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;

1174

PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;

1175

PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;

1176

PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;

1177

PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;

1178

PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;

1179

1180

PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;

1181

PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;

1182

PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;

1183

1184

PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;

1185

PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;

1186

PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;

1187

PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;

1188

PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;

1189

PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;

1190

PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;

1191

PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;

1192

PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;

1193

1194

PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;

1195

PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;

1196

PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;

1197

PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;

1198

PFNGLISFENCENVPROC __glewIsFenceNV = NULL;

1199

PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;

1200

PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;

1201

1202

PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;

1203

PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;

1204

PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;

1205

PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;

1206

PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;

1207

PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;

1208

1209

PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL;

1210

1211

PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL;

1212

1213

PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL;

1214

PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL;

1215

PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL;

1216

PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL;

1217

PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL;

1218

PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL;

1219

PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL;

1220

PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL;

1221

PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL;

1222

PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;

1223

PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;

1224

PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;

1225

1226

PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;

1227

PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;

1228

PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;

1229

PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;

1230

PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;

1231

PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;

1232

PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;

1233

PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;

1234

PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;

1235

PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;

1236

PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;

1237

PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;

1238

PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;

1239

PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;

1240

PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;

1241

PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;

1242

PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;

1243

PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;

1244

PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;

1245

PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;

1246

PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;

1247

PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;

1248

PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;

1249

PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;

1250

PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;

1251

PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;

1252

PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;

1253

PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;

1254

PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;

1255

PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;

1256

PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;

1257

PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;

1258

PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;

1259

PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;

1260

PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;

1261

PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;

1262

PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;

1263

PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;

1264

PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;

1265

PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;

1266

PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;

1267

PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;

1268

PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;

1269

PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;

1270

PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;

1271

PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;

1272

1273

PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;

1274

PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;

1275

PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;

1276

PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;

1277

PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;

1278

PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;

1279

PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;

1280

1281

PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL;

1282

PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL;

1283

PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL;

1284

1285

PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;

1286

PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;

1287

1288

PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;

1289

PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;

1290

1291

PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;

1292

PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;

1293

1294

PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;

1295

PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;

1296

PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;

1297

PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;

1298

PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;

1299

PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;

1300

PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;

1301

PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;

1302

PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;

1303

PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;

1304

PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;

1305

PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;

1306

PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;

1307

1308

PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;

1309

PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;

1310

1311

PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;

1312

PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;

1313

PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;

1314

PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL;

1315

PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL;

1316

PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL;

1317

PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL;

1318

PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL;

1319

PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;

1320

PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;

1321

PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;

1322

1323

PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;

1324

PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;

1325

1326

PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;

1327

PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;

1328

PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;

1329

PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;

1330

PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;

1331

PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;

1332

PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;

1333

PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;

1334

PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;

1335

PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;

1336

PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;

1337

PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;

1338

PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;

1339

PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;

1340

PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;

1341

PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;

1342

PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;

1343

PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;

1344

PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;

1345

PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;

1346

PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;

1347

PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;

1348

PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;

1349

PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;

1350

PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;

1351

PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;

1352

PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;

1353

PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;

1354

PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;

1355

PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;

1356

PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;

1357

PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;

1358

PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;

1359

PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;

1360

PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;

1361

PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;

1362

PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;

1363

PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;

1364

PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;

1365

PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;

1366

PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;

1367

PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;

1368

PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;

1369

PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;

1370

PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;

1371

PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;

1372

PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;

1373

PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;

1374

PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;

1375

PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;

1376

PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;

1377

PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;

1378

PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;

1379

PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;

1380

PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;

1381

PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;

1382

PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;

1383

PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;

1384

PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;

1385

PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;

1386

PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;

1387

PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;

1388

PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;

1389

PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;

1390

1391

PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL;

1392

PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL;

1393

PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL;

1394

PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL;

1395

PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL;

1396

PFNGLORTHOFOESPROC __glewOrthofOES = NULL;

1397

1398

PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;

1399

PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;

1400

1401

PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;

1402

PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;

1403

1404

PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;

1405

PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;

1406

1407

PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;

1408

PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;

1409

1410

PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;

1411

PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;

1412

1413

PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;

1414

PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;

1415

1416

PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;

1417

PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;

1418

PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;

1419

PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;

1420

PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;

1421

PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;

1422

1423

PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;

1424

1425

PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;

1426

1427

PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;

1428

PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;

1429

PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;

1430

PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;

1431

PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;

1432

PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;

1433

PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;

1434

PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;

1435

PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;

1436

PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;

1437

PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;

1438

PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;

1439

PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;

1440

PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;

1441

PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;

1442

PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;

1443

PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;

1444

1445

PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;

1446

1447

PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;

1448

1449

PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;

1450

1451

PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;

1452

PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;

1453

PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;

1454

PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;

1455

1456

PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;

1457

1458

PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;

1459

PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;

1460

PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;

1461

PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;

1462

PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;

1463

PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;

1464

PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;

1465

1466

PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;

1467

1468

PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;

1469

PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;

1470

PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;

1471

PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;

1472

PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;

1473

PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;

1474

PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;

1475

PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;

1476

1477

PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;

1478

1479

PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;

1480

PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;

1481

PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;

1482

PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;

1483

PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;

1484

PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;

1485

PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;

1486

1487

PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;

1488

PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;

1489

PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;

1490

PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;

1491

PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;

1492

PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;

1493

PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;

1494

PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;

1495

PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;

1496

PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;

1497

PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;

1498

PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;

1499

PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;

1500

PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;

1501

PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;

1502

PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;

1503

PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;

1504

PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;

1505

PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

1506

PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

1507

PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;

1508

PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;

1509

PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;

1510

PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;

1511

PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;

1512

PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;

1513

PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;

1514

PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;

1515

PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

1516

PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

1517

PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;

1518

PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;

1519

PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;

1520

PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;

1521

PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;

1522

PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;

1523

PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;

1524

PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;

1525

PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;

1526

PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;

1527

1528

PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;

1529

1530

#endif /* !WIN32 || !GLEW_MX */

1531

1532

#if !defined(GLEW_MX)

1533

1534

GLboolean __GLEW_VERSION_1_1 = GL_FALSE;

1535

GLboolean __GLEW_VERSION_1_2 = GL_FALSE;

1536

GLboolean __GLEW_VERSION_1_3 = GL_FALSE;

1537

GLboolean __GLEW_VERSION_1_4 = GL_FALSE;

1538

GLboolean __GLEW_VERSION_1_5 = GL_FALSE;

1539

GLboolean __GLEW_VERSION_2_0 = GL_FALSE;

1540

GLboolean __GLEW_VERSION_2_1 = GL_FALSE;

1541

GLboolean __GLEW_3DFX_multisample = GL_FALSE;

1542

GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;

1543

GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;

1544

GLboolean __GLEW_APPLE_client_storage = GL_FALSE;

1545

GLboolean __GLEW_APPLE_element_array = GL_FALSE;

1546

GLboolean __GLEW_APPLE_fence = GL_FALSE;

1547

GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;

1548

GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;

1549

GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;

1550

GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;

1551

GLboolean __GLEW_APPLE_texture_range = GL_FALSE;

1552

GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;

1553

GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;

1554

GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;

1555

GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;

1556

GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;

1557

GLboolean __GLEW_ARB_depth_texture = GL_FALSE;

1558

GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;

1559

GLboolean __GLEW_ARB_fragment_program = GL_FALSE;

1560

GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;

1561

GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;

1562

GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;

1563

GLboolean __GLEW_ARB_imaging = GL_FALSE;

1564

GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;

1565

GLboolean __GLEW_ARB_multisample = GL_FALSE;

1566

GLboolean __GLEW_ARB_multitexture = GL_FALSE;

1567

GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;

1568

GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;

1569

GLboolean __GLEW_ARB_point_parameters = GL_FALSE;

1570

GLboolean __GLEW_ARB_point_sprite = GL_FALSE;

1571

GLboolean __GLEW_ARB_shader_objects = GL_FALSE;

1572

GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;

1573

GLboolean __GLEW_ARB_shadow = GL_FALSE;

1574

GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;

1575

GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;

1576

GLboolean __GLEW_ARB_texture_compression = GL_FALSE;

1577

GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;

1578

GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;

1579

GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;

1580

GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;

1581

GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;

1582

GLboolean __GLEW_ARB_texture_float = GL_FALSE;

1583

GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;

1584

GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;

1585

GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;

1586

GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;

1587

GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;

1588

GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;

1589

GLboolean __GLEW_ARB_vertex_program = GL_FALSE;

1590

GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;

1591

GLboolean __GLEW_ARB_window_pos = GL_FALSE;

1592

GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;

1593

GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;

1594

GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;

1595

GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;

1596

GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;

1597

GLboolean __GLEW_ATI_element_array = GL_FALSE;

1598

GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;

1599

GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;

1600

GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;

1601

GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;

1602

GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;

1603

GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;

1604

GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;

1605

GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;

1606

GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;

1607

GLboolean __GLEW_ATI_texture_float = GL_FALSE;

1608

GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;

1609

GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;

1610

GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;

1611

GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;

1612

GLboolean __GLEW_EXT_422_pixels = GL_FALSE;

1613

GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;

1614

GLboolean __GLEW_EXT_abgr = GL_FALSE;

1615

GLboolean __GLEW_EXT_bgra = GL_FALSE;

1616

GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE;

1617

GLboolean __GLEW_EXT_blend_color = GL_FALSE;

1618

GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;

1619

GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;

1620

GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;

1621

GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;

1622

GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;

1623

GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;

1624

GLboolean __GLEW_EXT_cmyka = GL_FALSE;

1625

GLboolean __GLEW_EXT_color_subtable = GL_FALSE;

1626

GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;

1627

GLboolean __GLEW_EXT_convolution = GL_FALSE;

1628

GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;

1629

GLboolean __GLEW_EXT_copy_texture = GL_FALSE;

1630

GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;

1631

GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;

1632

GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE;

1633

GLboolean __GLEW_EXT_draw_instanced = GL_FALSE;

1634

GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;

1635

GLboolean __GLEW_EXT_fog_coord = GL_FALSE;

1636

GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;

1637

GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;

1638

GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;

1639

GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;

1640

GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE;

1641

GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE;

1642

GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE;

1643

GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE;

1644

GLboolean __GLEW_EXT_histogram = GL_FALSE;

1645

GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;

1646

GLboolean __GLEW_EXT_index_func = GL_FALSE;

1647

GLboolean __GLEW_EXT_index_material = GL_FALSE;

1648

GLboolean __GLEW_EXT_index_texture = GL_FALSE;

1649

GLboolean __GLEW_EXT_light_texture = GL_FALSE;

1650

GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;

1651

GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;

1652

GLboolean __GLEW_EXT_multisample = GL_FALSE;

1653

GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE;

1654

GLboolean __GLEW_EXT_packed_float = GL_FALSE;

1655

GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;

1656

GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;

1657

GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;

1658

GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;

1659

GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;

1660

GLboolean __GLEW_EXT_point_parameters = GL_FALSE;

1661

GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;

1662

GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;

1663

GLboolean __GLEW_EXT_scene_marker = GL_FALSE;

1664

GLboolean __GLEW_EXT_secondary_color = GL_FALSE;

1665

GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;

1666

GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;

1667

GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;

1668

GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;

1669

GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;

1670

GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;

1671

GLboolean __GLEW_EXT_subtexture = GL_FALSE;

1672

GLboolean __GLEW_EXT_texture = GL_FALSE;

1673

GLboolean __GLEW_EXT_texture3D = GL_FALSE;

1674

GLboolean __GLEW_EXT_texture_array = GL_FALSE;

1675

GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE;

1676

GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;

1677

GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE;

1678

GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE;

1679

GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;

1680

GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;

1681

GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;

1682

GLboolean __GLEW_EXT_texture_env = GL_FALSE;

1683

GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;

1684

GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;

1685

GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;

1686

GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;

1687

GLboolean __GLEW_EXT_texture_integer = GL_FALSE;

1688

GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;

1689

GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;

1690

GLboolean __GLEW_EXT_texture_object = GL_FALSE;

1691

GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;

1692

GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;

1693

GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;

1694

GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;

1695

GLboolean __GLEW_EXT_timer_query = GL_FALSE;

1696

GLboolean __GLEW_EXT_vertex_array = GL_FALSE;

1697

GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;

1698

GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;

1699

GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;

1700

GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE;

1701

GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;

1702

GLboolean __GLEW_HP_image_transform = GL_FALSE;

1703

GLboolean __GLEW_HP_occlusion_test = GL_FALSE;

1704

GLboolean __GLEW_HP_texture_lighting = GL_FALSE;

1705

GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;

1706

GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;

1707

GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;

1708

GLboolean __GLEW_IBM_static_data = GL_FALSE;

1709

GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;

1710

GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;

1711

GLboolean __GLEW_INGR_color_clamp = GL_FALSE;

1712

GLboolean __GLEW_INGR_interlace_read = GL_FALSE;

1713

GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;

1714

GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;

1715

GLboolean __GLEW_KTX_buffer_region = GL_FALSE;

1716

GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;

1717

GLboolean __GLEW_MESA_pack_invert = GL_FALSE;

1718

GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;

1719

GLboolean __GLEW_MESA_window_pos = GL_FALSE;

1720

GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;

1721

GLboolean __GLEW_NV_blend_square = GL_FALSE;

1722

GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;

1723

GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;

1724

GLboolean __GLEW_NV_depth_clamp = GL_FALSE;

1725

GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;

1726

GLboolean __GLEW_NV_evaluators = GL_FALSE;

1727

GLboolean __GLEW_NV_fence = GL_FALSE;

1728

GLboolean __GLEW_NV_float_buffer = GL_FALSE;

1729

GLboolean __GLEW_NV_fog_distance = GL_FALSE;

1730

GLboolean __GLEW_NV_fragment_program = GL_FALSE;

1731

GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;

1732

GLboolean __GLEW_NV_fragment_program4 = GL_FALSE;

1733

GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;

1734

GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;

1735

GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;

1736

GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;

1737

GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;

1738

GLboolean __GLEW_NV_half_float = GL_FALSE;

1739

GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;

1740

GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;

1741

GLboolean __GLEW_NV_occlusion_query = GL_FALSE;

1742

GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;

1743

GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;

1744

GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;

1745

GLboolean __GLEW_NV_point_sprite = GL_FALSE;

1746

GLboolean __GLEW_NV_primitive_restart = GL_FALSE;

1747

GLboolean __GLEW_NV_register_combiners = GL_FALSE;

1748

GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;

1749

GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;

1750

GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;

1751

GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;

1752

GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;

1753

GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;

1754

GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;

1755

GLboolean __GLEW_NV_texture_shader = GL_FALSE;

1756

GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;

1757

GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;

1758

GLboolean __GLEW_NV_transform_feedback = GL_FALSE;

1759

GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;

1760

GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;

1761

GLboolean __GLEW_NV_vertex_program = GL_FALSE;

1762

GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;

1763

GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;

1764

GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;

1765

GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;

1766

GLboolean __GLEW_NV_vertex_program4 = GL_FALSE;

1767

GLboolean __GLEW_OES_byte_coordinates = GL_FALSE;

1768

GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE;

1769

GLboolean __GLEW_OES_read_format = GL_FALSE;

1770

GLboolean __GLEW_OES_single_precision = GL_FALSE;

1771

GLboolean __GLEW_OML_interlace = GL_FALSE;

1772

GLboolean __GLEW_OML_resample = GL_FALSE;

1773

GLboolean __GLEW_OML_subsample = GL_FALSE;

1774

GLboolean __GLEW_PGI_misc_hints = GL_FALSE;

1775

GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;

1776

GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;

1777

GLboolean __GLEW_S3_s3tc = GL_FALSE;

1778

GLboolean __GLEW_SGIS_color_range = GL_FALSE;

1779

GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;

1780

GLboolean __GLEW_SGIS_fog_function = GL_FALSE;

1781

GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;

1782

GLboolean __GLEW_SGIS_multisample = GL_FALSE;

1783

GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;

1784

GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;

1785

GLboolean __GLEW_SGIS_texture4D = GL_FALSE;

1786

GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;

1787

GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;

1788

GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;

1789

GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;

1790

GLboolean __GLEW_SGIS_texture_select = GL_FALSE;

1791

GLboolean __GLEW_SGIX_async = GL_FALSE;

1792

GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;

1793

GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;

1794

GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;

1795

GLboolean __GLEW_SGIX_clipmap = GL_FALSE;

1796

GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;

1797

GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;

1798

GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;

1799

GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;

1800

GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;

1801

GLboolean __GLEW_SGIX_framezoom = GL_FALSE;

1802

GLboolean __GLEW_SGIX_interlace = GL_FALSE;

1803

GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;

1804

GLboolean __GLEW_SGIX_list_priority = GL_FALSE;

1805

GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;

1806

GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;

1807

GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;

1808

GLboolean __GLEW_SGIX_resample = GL_FALSE;

1809

GLboolean __GLEW_SGIX_shadow = GL_FALSE;

1810

GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;

1811

GLboolean __GLEW_SGIX_sprite = GL_FALSE;

1812

GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;

1813

GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;

1814

GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;

1815

GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;

1816

GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;

1817

GLboolean __GLEW_SGIX_texture_range = GL_FALSE;

1818

GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;

1819

GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;

1820

GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;

1821

GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;

1822

GLboolean __GLEW_SGI_color_matrix = GL_FALSE;

1823

GLboolean __GLEW_SGI_color_table = GL_FALSE;

1824

GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;

1825

GLboolean __GLEW_SUNX_constant_data = GL_FALSE;

1826

GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;

1827

GLboolean __GLEW_SUN_global_alpha = GL_FALSE;

1828

GLboolean __GLEW_SUN_mesh_array = GL_FALSE;

1829

GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;

1830

GLboolean __GLEW_SUN_slice_accum = GL_FALSE;

1831

GLboolean __GLEW_SUN_triangle_list = GL_FALSE;

1832

GLboolean __GLEW_SUN_vertex = GL_FALSE;

1833

GLboolean __GLEW_WIN_phong_shading = GL_FALSE;

1834

GLboolean __GLEW_WIN_specular_fog = GL_FALSE;

1835

GLboolean __GLEW_WIN_swap_hint = GL_FALSE;

1836

1837

#endif /* !GLEW_MX */

1838

1839

#ifdef GL_VERSION_1_2

1840

1841

static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)

1842

{

1843

GLboolean r = GL_FALSE;

1844

1845

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

1846

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

1847

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

1848

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

1849

1850

return r;

1851

}

1852

1853

#endif /* GL_VERSION_1_2 */

1854

1855

#ifdef GL_VERSION_1_3

1856

1857

static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)

1858

{

1859

GLboolean r = GL_FALSE;

1860

1861

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

1862

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

1863

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

1864

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

1865

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

1866

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

1867

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

1868

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

1869

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

1870

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

1871

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

1872

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

1873

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

1874

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

1875

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

1876

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

1877

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

1878

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

1879

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

1880

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

1881

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

1882

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

1883

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

1884

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

1885

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

1886

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

1887

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

1888

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

1889

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

1890

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

1891

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

1892

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

1893

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

1894

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

1895

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

1896

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

1897

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

1898

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

1899

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

1900

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

1901

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

1902

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

1903

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

1904

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

1905

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

1906

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

1907

1908

return r;

1909

}

1910

1911

#endif /* GL_VERSION_1_3 */

1912

1913

#ifdef GL_VERSION_1_4

1914

1915

static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)

1916

{

1917

GLboolean r = GL_FALSE;

1918

1919

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

1920

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

1921

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

1922

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

1923

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

1924

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

1925

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

1926

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

1927

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

1928

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

1929

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

1930

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

1931

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

1932

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

1933

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

1934

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

1935

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

1936

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

1937

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

1938

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

1939

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

1940

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

1941

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

1942

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

1943

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

1944

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

1945

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

1946

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

1947

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

1948

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

1949

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

1950

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

1951

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

1952

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

1953

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

1954

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

1955

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

1956

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

1957

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

1958

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

1959

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

1960

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

1961

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

1962

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

1963

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

1964

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

1965

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

1966

1967

return r;

1968

}

1969

1970

#endif /* GL_VERSION_1_4 */

1971

1972

#ifdef GL_VERSION_1_5

1973

1974

static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)

1975

{

1976

GLboolean r = GL_FALSE;

1977

1978

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

1979

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

1980

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

1981

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

1982

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

1983

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

1984

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

1985

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

1986

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

1987

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

1988

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

1989

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

1990

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

1991

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

1992

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

1993

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

1994

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

1995

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

1996

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

1997

1998

return r;

1999

}

2000

2001

#endif /* GL_VERSION_1_5 */

2002

2003

#ifdef GL_VERSION_2_0

2004

2005

static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)

2006

{

2007

GLboolean r = GL_FALSE;

2008

2009

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

2010

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

2011

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

2012

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

2013

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

2014

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

2015

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

2016

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

2017

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

2018

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

2019

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

2020

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

2021

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

2022

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

2023

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

2024

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

2025

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

2026

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

2027

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

2028

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

2029

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

2030

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

2031

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

2032

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

2033

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

2034

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

2035

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

2036

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

2037

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

2038

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

2039

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

2040

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

2041

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

2042

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

2043

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

2044

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

2045

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

2046

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

2047

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

2048

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

2049

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

2050

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

2051

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

2052

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

2053

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

2054

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

2055

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

2056

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

2057

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

2058

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

2059

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

2060

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

2061

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

2062

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

2063

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

2064

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

2065

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

2066

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

2067

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

2068

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

2069

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

2070

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

2071

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

2072

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

2073

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

2074

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

2075

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

2076

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

2077

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

2078

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

2079

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

2080

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

2081

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

2082

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

2083

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

2084

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

2085

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

2086

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

2087

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

2088

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

2089

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

2090

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

2091

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

2092

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

2093

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

2094

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

2095

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

2096

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

2097

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

2098

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

2099

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

2100

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

2101

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

2102

2103

return r;

2104

}

2105

2106

#endif /* GL_VERSION_2_0 */

2107

2108

#ifdef GL_VERSION_2_1

2109

2110

static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT)

2111

{

2112

GLboolean r = GL_FALSE;

2113

2114

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

2115

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

2116

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

2117

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

2118

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

2119

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

2120

2121

return r;

2122

}

2123

2124

#endif /* GL_VERSION_2_1 */

2125

2126

#ifdef GL_3DFX_multisample

2127

2128

#endif /* GL_3DFX_multisample */

2129

2130

#ifdef GL_3DFX_tbuffer

2131

2132

static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)

2133

{

2134

GLboolean r = GL_FALSE;

2135

2136

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

2137

2138

return r;

2139

}

2140

2141

#endif /* GL_3DFX_tbuffer */

2142

2143

#ifdef GL_3DFX_texture_compression_FXT1

2144

2145

#endif /* GL_3DFX_texture_compression_FXT1 */

2146

2147

#ifdef GL_APPLE_client_storage

2148

2149

#endif /* GL_APPLE_client_storage */

2150

2151

#ifdef GL_APPLE_element_array

2152

2153

static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT)

2154

{

2155

GLboolean r = GL_FALSE;

2156

2157

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

2158

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

2159

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

2160

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

2161

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

2162

2163

return r;

2164

}

2165

2166

#endif /* GL_APPLE_element_array */

2167

2168

#ifdef GL_APPLE_fence

2169

2170

static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT)

2171

{

2172

GLboolean r = GL_FALSE;

2173

2174

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

2175

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

2176

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

2177

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

2178

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

2179

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

2180

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

2181

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

2182

2183

return r;

2184

}

2185

2186

#endif /* GL_APPLE_fence */

2187

2188

#ifdef GL_APPLE_float_pixels

2189

2190

#endif /* GL_APPLE_float_pixels */

2191

2192

#ifdef GL_APPLE_flush_buffer_range

2193

2194

static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)

2195

{

2196

GLboolean r = GL_FALSE;

2197

2198

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

2199

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

2200

2201

return r;

2202

}

2203

2204

#endif /* GL_APPLE_flush_buffer_range */

2205

2206

#ifdef GL_APPLE_pixel_buffer

2207

2208

#endif /* GL_APPLE_pixel_buffer */

2209

2210

#ifdef GL_APPLE_specular_vector

2211

2212

#endif /* GL_APPLE_specular_vector */

2213

2214

#ifdef GL_APPLE_texture_range

2215

2216

static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT)

2217

{

2218

GLboolean r = GL_FALSE;

2219

2220

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

2221

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

2222

2223

return r;

2224

}

2225

2226

#endif /* GL_APPLE_texture_range */

2227

2228

#ifdef GL_APPLE_transform_hint

2229

2230

#endif /* GL_APPLE_transform_hint */

2231

2232

#ifdef GL_APPLE_vertex_array_object

2233

2234

static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

2235

{

2236

GLboolean r = GL_FALSE;

2237

2238

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

2239

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

2240

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

2241

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

2242

2243

return r;

2244

}

2245

2246

#endif /* GL_APPLE_vertex_array_object */

2247

2248

#ifdef GL_APPLE_vertex_array_range

2249

2250

static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)

2251

{

2252

GLboolean r = GL_FALSE;

2253

2254

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

2255

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

2256

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

2257

2258

return r;

2259

}

2260

2261

#endif /* GL_APPLE_vertex_array_range */

2262

2263

#ifdef GL_APPLE_ycbcr_422

2264

2265

#endif /* GL_APPLE_ycbcr_422 */

2266

2267

#ifdef GL_ARB_color_buffer_float

2268

2269

static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)

2270

{

2271

GLboolean r = GL_FALSE;

2272

2273

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

2274

2275

return r;

2276

}

2277

2278

#endif /* GL_ARB_color_buffer_float */

2279

2280

#ifdef GL_ARB_depth_texture

2281

2282

#endif /* GL_ARB_depth_texture */

2283

2284

#ifdef GL_ARB_draw_buffers

2285

2286

static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

2287

{

2288

GLboolean r = GL_FALSE;

2289

2290

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

2291

2292

return r;

2293

}

2294

2295

#endif /* GL_ARB_draw_buffers */

2296

2297

#ifdef GL_ARB_fragment_program

2298

2299

#endif /* GL_ARB_fragment_program */

2300

2301

#ifdef GL_ARB_fragment_program_shadow

2302

2303

#endif /* GL_ARB_fragment_program_shadow */

2304

2305

#ifdef GL_ARB_fragment_shader

2306

2307

#endif /* GL_ARB_fragment_shader */

2308

2309

#ifdef GL_ARB_half_float_pixel

2310

2311

#endif /* GL_ARB_half_float_pixel */

2312

2313

#ifdef GL_ARB_imaging

2314

2315

static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT)

2316

{

2317

GLboolean r = GL_FALSE;

2318

2319

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

2320

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

2321

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

2322

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

2323

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

2324

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

2325

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

2326

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

2327

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

2328

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

2329

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

2330

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

2331

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

2332

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

2333

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

2334

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

2335

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

2336

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

2337

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

2338

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

2339

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

2340

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

2341

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

2342

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

2343

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

2344

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

2345

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

2346

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

2347

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

2348

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

2349

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

2350

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

2351

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

2352

2353

return r;

2354

}

2355

2356

#endif /* GL_ARB_imaging */

2357

2358

#ifdef GL_ARB_matrix_palette

2359

2360

static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT)

2361

{

2362

GLboolean r = GL_FALSE;

2363

2364

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

2365

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

2366

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

2367

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

2368

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

2369

2370

return r;

2371

}

2372

2373

#endif /* GL_ARB_matrix_palette */

2374

2375

#ifdef GL_ARB_multisample

2376

2377

static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

2378

{

2379

GLboolean r = GL_FALSE;

2380

2381

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

2382

2383

return r;

2384

}

2385

2386

#endif /* GL_ARB_multisample */

2387

2388

#ifdef GL_ARB_multitexture

2389

2390

static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)

2391

{

2392

GLboolean r = GL_FALSE;

2393

2394

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

2395

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

2396

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

2397

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

2398

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

2399

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

2400

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

2401

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

2402

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

2403

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

2404

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

2405

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

2406

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

2407

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

2408

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

2409

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

2410

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

2411

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

2412

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

2413

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

2414

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

2415

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

2416

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

2417

r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;

2418

r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;

2419

r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;

2420

r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;

2421

r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;

2422

r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;

2423

r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;

2424

r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;

2425

r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;

2426

r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;

2427

r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;

2428

2429

return r;

2430

}

2431

2432

#endif /* GL_ARB_multitexture */

2433

2434

#ifdef GL_ARB_occlusion_query

2435

2436

static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)

2437

{

2438

GLboolean r = GL_FALSE;

2439

2440

r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;

2441

r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;

2442

r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;

2443

r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;

2444

r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;

2445

r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;

2446

r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;

2447

r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;

2448

2449

return r;

2450

}

2451

2452

#endif /* GL_ARB_occlusion_query */

2453

2454

#ifdef GL_ARB_pixel_buffer_object

2455

2456

#endif /* GL_ARB_pixel_buffer_object */

2457

2458

#ifdef GL_ARB_point_parameters

2459

2460

static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

2461

{

2462

GLboolean r = GL_FALSE;

2463

2464

r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;

2465

r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;

2466

2467

return r;

2468

}

2469

2470

#endif /* GL_ARB_point_parameters */

2471

2472

#ifdef GL_ARB_point_sprite

2473

2474

#endif /* GL_ARB_point_sprite */

2475

2476

#ifdef GL_ARB_shader_objects

2477

2478

static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)

2479

{

2480

GLboolean r = GL_FALSE;

2481

2482

r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;

2483

r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;

2484

r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;

2485

r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;

2486

r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;

2487

r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;

2488

r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;

2489

r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;

2490

r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;

2491

r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;

2492

r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;

2493

r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;

2494

r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;

2495

r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;

2496

r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;

2497

r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;

2498

r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;

2499

r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;

2500

r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;

2501

r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;

2502

r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;

2503

r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;

2504

r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;

2505

r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;

2506

r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;

2507

r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;

2508

r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;

2509

r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;

2510

r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;

2511

r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;

2512

r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;

2513

r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;

2514

r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;

2515

r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;

2516

r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;

2517

r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;

2518

r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;

2519

r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;

2520

r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;

2521

2522

return r;

2523

}

2524

2525

#endif /* GL_ARB_shader_objects */

2526

2527

#ifdef GL_ARB_shading_language_100

2528

2529

#endif /* GL_ARB_shading_language_100 */

2530

2531

#ifdef GL_ARB_shadow

2532

2533

#endif /* GL_ARB_shadow */

2534

2535

#ifdef GL_ARB_shadow_ambient

2536

2537

#endif /* GL_ARB_shadow_ambient */

2538

2539

#ifdef GL_ARB_texture_border_clamp

2540

2541

#endif /* GL_ARB_texture_border_clamp */

2542

2543

#ifdef GL_ARB_texture_compression

2544

2545

static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)

2546

{

2547

GLboolean r = GL_FALSE;

2548

2549

r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;

2550

r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;

2551

r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;

2552

r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;

2553

r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;

2554

r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;

2555

r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;

2556

2557

return r;

2558

}

2559

2560

#endif /* GL_ARB_texture_compression */

2561

2562

#ifdef GL_ARB_texture_cube_map

2563

2564

#endif /* GL_ARB_texture_cube_map */

2565

2566

#ifdef GL_ARB_texture_env_add

2567

2568

#endif /* GL_ARB_texture_env_add */

2569

2570

#ifdef GL_ARB_texture_env_combine

2571

2572

#endif /* GL_ARB_texture_env_combine */

2573

2574

#ifdef GL_ARB_texture_env_crossbar

2575

2576

#endif /* GL_ARB_texture_env_crossbar */

2577

2578

#ifdef GL_ARB_texture_env_dot3

2579

2580

#endif /* GL_ARB_texture_env_dot3 */

2581

2582

#ifdef GL_ARB_texture_float

2583

2584

#endif /* GL_ARB_texture_float */

2585

2586

#ifdef GL_ARB_texture_mirrored_repeat

2587

2588

#endif /* GL_ARB_texture_mirrored_repeat */

2589

2590

#ifdef GL_ARB_texture_non_power_of_two

2591

2592

#endif /* GL_ARB_texture_non_power_of_two */

2593

2594

#ifdef GL_ARB_texture_rectangle

2595

2596

#endif /* GL_ARB_texture_rectangle */

2597

2598

#ifdef GL_ARB_transpose_matrix

2599

2600

static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)

2601

{

2602

GLboolean r = GL_FALSE;

2603

2604

r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r;

2605

r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r;

2606

r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r;

2607

r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r;

2608

2609

return r;

2610

}

2611

2612

#endif /* GL_ARB_transpose_matrix */

2613

2614

#ifdef GL_ARB_vertex_blend

2615

2616

static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT)

2617

{

2618

GLboolean r = GL_FALSE;

2619

2620

r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r;

2621

r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r;

2622

r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r;

2623

r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r;

2624

r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r;

2625

r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r;

2626

r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r;

2627

r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r;

2628

r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r;

2629

r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r;

2630

2631

return r;

2632

}

2633

2634

#endif /* GL_ARB_vertex_blend */

2635

2636

#ifdef GL_ARB_vertex_buffer_object

2637

2638

static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

2639

{

2640

GLboolean r = GL_FALSE;

2641

2642

r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;

2643

r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;

2644

r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;

2645

r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;

2646

r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;

2647

r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;

2648

r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;

2649

r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;

2650

r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;

2651

r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;

2652

r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;

2653

2654

return r;

2655

}

2656

2657

#endif /* GL_ARB_vertex_buffer_object */

2658

2659

#ifdef GL_ARB_vertex_program

2660

2661

static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)

2662

{

2663

GLboolean r = GL_FALSE;

2664

2665

r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;

2666

r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;

2667

r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;

2668

r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;

2669

r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;

2670

r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;

2671

r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;

2672

r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;

2673

r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;

2674

r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;

2675

r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;

2676

r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;

2677

r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;

2678

r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;

2679

r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;

2680

r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;

2681

r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;

2682

r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;

2683

r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;

2684

r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;

2685

r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;

2686

r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;

2687

r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;

2688

r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;

2689

r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;

2690

r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;

2691

r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;

2692

r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;

2693

r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;

2694

r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;

2695

r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;

2696

r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;

2697

r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;

2698

r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;

2699

r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;

2700

r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;

2701

r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;

2702

r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;

2703

r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;

2704

r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;

2705

r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;

2706

r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;

2707

r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;

2708

r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;

2709

r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;

2710

r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;

2711

r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;

2712

r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;

2713

r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;

2714

r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;

2715

r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;

2716

r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;

2717

r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;

2718

r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;

2719

r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;

2720

r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;

2721

r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;

2722

r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;

2723

r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;

2724

r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;

2725

r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;

2726

r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;

2727

2728

return r;

2729

}

2730

2731

#endif /* GL_ARB_vertex_program */

2732

2733

#ifdef GL_ARB_vertex_shader

2734

2735

static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)

2736

{

2737

GLboolean r = GL_FALSE;

2738

2739

r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;

2740

r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;

2741

r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;

2742

2743

return r;

2744

}

2745

2746

#endif /* GL_ARB_vertex_shader */

2747

2748

#ifdef GL_ARB_window_pos

2749

2750

static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)

2751

{

2752

GLboolean r = GL_FALSE;

2753

2754

r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r;

2755

r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r;

2756

r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r;

2757

r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r;

2758

r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r;

2759

r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r;

2760

r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r;

2761

r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r;

2762

r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r;

2763

r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r;

2764

r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r;

2765

r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r;

2766

r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r;

2767

r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r;

2768

r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r;

2769

r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r;

2770

2771

return r;

2772

}

2773

2774

#endif /* GL_ARB_window_pos */

2775

2776

#ifdef GL_ATIX_point_sprites

2777

2778

#endif /* GL_ATIX_point_sprites */

2779

2780

#ifdef GL_ATIX_texture_env_combine3

2781

2782

#endif /* GL_ATIX_texture_env_combine3 */

2783

2784

#ifdef GL_ATIX_texture_env_route

2785

2786

#endif /* GL_ATIX_texture_env_route */

2787

2788

#ifdef GL_ATIX_vertex_shader_output_point_size

2789

2790

#endif /* GL_ATIX_vertex_shader_output_point_size */

2791

2792

#ifdef GL_ATI_draw_buffers

2793

2794

static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

2795

{

2796

GLboolean r = GL_FALSE;

2797

2798

r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;

2799

2800

return r;

2801

}

2802

2803

#endif /* GL_ATI_draw_buffers */

2804

2805

#ifdef GL_ATI_element_array

2806

2807

static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT)

2808

{

2809

GLboolean r = GL_FALSE;

2810

2811

r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r;

2812

r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r;

2813

r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r;

2814

2815

return r;

2816

}

2817

2818

#endif /* GL_ATI_element_array */

2819

2820

#ifdef GL_ATI_envmap_bumpmap

2821

2822

static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT)

2823

{

2824

GLboolean r = GL_FALSE;

2825

2826

r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r;

2827

r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r;

2828

r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r;

2829

r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r;

2830

2831

return r;

2832

}

2833

2834

#endif /* GL_ATI_envmap_bumpmap */

2835

2836

#ifdef GL_ATI_fragment_shader

2837

2838

static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)

2839

{

2840

GLboolean r = GL_FALSE;

2841

2842

r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;

2843

r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;

2844

r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;

2845

r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;

2846

r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;

2847

r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;

2848

r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;

2849

r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;

2850

r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;

2851

r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;

2852

r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;

2853

r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;

2854

r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;

2855

r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;

2856

2857

return r;

2858

}

2859

2860

#endif /* GL_ATI_fragment_shader */

2861

2862

#ifdef GL_ATI_map_object_buffer

2863

2864

static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)

2865

{

2866

GLboolean r = GL_FALSE;

2867

2868

r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r;

2869

r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r;

2870

2871

return r;

2872

}

2873

2874

#endif /* GL_ATI_map_object_buffer */

2875

2876

#ifdef GL_ATI_pn_triangles

2877

2878

static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)

2879

{

2880

GLboolean r = GL_FALSE;

2881

2882

r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r;

2883

r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r;

2884

2885

return r;

2886

}

2887

2888

#endif /* GL_ATI_pn_triangles */

2889

2890

#ifdef GL_ATI_separate_stencil

2891

2892

static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT)

2893

{

2894

GLboolean r = GL_FALSE;

2895

2896

r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r;

2897

r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r;

2898

2899

return r;

2900

}

2901

2902

#endif /* GL_ATI_separate_stencil */

2903

2904

#ifdef GL_ATI_shader_texture_lod

2905

2906

#endif /* GL_ATI_shader_texture_lod */

2907

2908

#ifdef GL_ATI_text_fragment_shader

2909

2910

#endif /* GL_ATI_text_fragment_shader */

2911

2912

#ifdef GL_ATI_texture_compression_3dc

2913

2914

#endif /* GL_ATI_texture_compression_3dc */

2915

2916

#ifdef GL_ATI_texture_env_combine3

2917

2918

#endif /* GL_ATI_texture_env_combine3 */

2919

2920

#ifdef GL_ATI_texture_float

2921

2922

#endif /* GL_ATI_texture_float */

2923

2924

#ifdef GL_ATI_texture_mirror_once

2925

2926

#endif /* GL_ATI_texture_mirror_once */

2927

2928

#ifdef GL_ATI_vertex_array_object

2929

2930

static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

2931

{

2932

GLboolean r = GL_FALSE;

2933

2934

r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r;

2935

r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r;

2936

r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r;

2937

r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r;

2938

r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r;

2939

r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r;

2940

r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r;

2941

r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r;

2942

r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r;

2943

r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r;

2944

r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r;

2945

r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r;

2946

2947

return r;

2948

}

2949

2950

#endif /* GL_ATI_vertex_array_object */

2951

2952

#ifdef GL_ATI_vertex_attrib_array_object

2953

2954

static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

2955

{

2956

GLboolean r = GL_FALSE;

2957

2958

r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r;

2959

r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r;

2960

r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r;

2961

2962

return r;

2963

}

2964

2965

#endif /* GL_ATI_vertex_attrib_array_object */

2966

2967

#ifdef GL_ATI_vertex_streams

2968

2969

static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT)

2970

{

2971

GLboolean r = GL_FALSE;

2972

2973

r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r;

2974

r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r;

2975

r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r;

2976

r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r;

2977

r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r;

2978

r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r;

2979

r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r;

2980

r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r;

2981

r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r;

2982

r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r;

2983

r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r;

2984

r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r;

2985

r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r;

2986

r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r;

2987

r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r;

2988

r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r;

2989

r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r;

2990

r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r;

2991

r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r;

2992

r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r;

2993

r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r;

2994

r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r;

2995

r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r;

2996

r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r;

2997

r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r;

2998

r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r;

2999

r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r;

3000

r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r;

3001

r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r;

3002

r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r;

3003

r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r;

3004

r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r;

3005

r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r;

3006

r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r;

3007

r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r;

3008

r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r;

3009

r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r;

3010

3011

return r;

3012

}

3013

3014

#endif /* GL_ATI_vertex_streams */

3015

3016

#ifdef GL_EXT_422_pixels

3017

3018

#endif /* GL_EXT_422_pixels */

3019

3020

#ifdef GL_EXT_Cg_shader

3021

3022

#endif /* GL_EXT_Cg_shader */

3023

3024

#ifdef GL_EXT_abgr

3025

3026

#endif /* GL_EXT_abgr */

3027

3028

#ifdef GL_EXT_bgra

3029

3030

#endif /* GL_EXT_bgra */

3031

3032

#ifdef GL_EXT_bindable_uniform

3033

3034

static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT)

3035

{

3036

GLboolean r = GL_FALSE;

3037

3038

r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r;

3039

r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r;

3040

r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r;

3041

3042

return r;

3043

}

3044

3045

#endif /* GL_EXT_bindable_uniform */

3046

3047

#ifdef GL_EXT_blend_color

3048

3049

static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT)

3050

{

3051

GLboolean r = GL_FALSE;

3052

3053

r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r;

3054

3055

return r;

3056

}

3057

3058

#endif /* GL_EXT_blend_color */

3059

3060

#ifdef GL_EXT_blend_equation_separate

3061

3062

static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT)

3063

{

3064

GLboolean r = GL_FALSE;

3065

3066

r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r;

3067

3068

return r;

3069

}

3070

3071

#endif /* GL_EXT_blend_equation_separate */

3072

3073

#ifdef GL_EXT_blend_func_separate

3074

3075

static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT)

3076

{

3077

GLboolean r = GL_FALSE;

3078

3079

r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r;

3080

3081

return r;

3082

}

3083

3084

#endif /* GL_EXT_blend_func_separate */

3085

3086

#ifdef GL_EXT_blend_logic_op

3087

3088

#endif /* GL_EXT_blend_logic_op */

3089

3090

#ifdef GL_EXT_blend_minmax

3091

3092

static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT)

3093

{

3094

GLboolean r = GL_FALSE;

3095

3096

r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r;

3097

3098

return r;

3099

}

3100

3101

#endif /* GL_EXT_blend_minmax */

3102

3103

#ifdef GL_EXT_blend_subtract

3104

3105

#endif /* GL_EXT_blend_subtract */

3106

3107

#ifdef GL_EXT_clip_volume_hint

3108

3109

#endif /* GL_EXT_clip_volume_hint */

3110

3111

#ifdef GL_EXT_cmyka

3112

3113

#endif /* GL_EXT_cmyka */

3114

3115

#ifdef GL_EXT_color_subtable

3116

3117

static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT)

3118

{

3119

GLboolean r = GL_FALSE;

3120

3121

r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r;

3122

r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r;

3123

3124

return r;

3125

}

3126

3127

#endif /* GL_EXT_color_subtable */

3128

3129

#ifdef GL_EXT_compiled_vertex_array

3130

3131

static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)

3132

{

3133

GLboolean r = GL_FALSE;

3134

3135

r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r;

3136

r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r;

3137

3138

return r;

3139

}

3140

3141

#endif /* GL_EXT_compiled_vertex_array */

3142

3143

#ifdef GL_EXT_convolution

3144

3145

static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT)

3146

{

3147

GLboolean r = GL_FALSE;

3148

3149

r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r;

3150

r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r;

3151

r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r;

3152

r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r;

3153

r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r;

3154

r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r;

3155

r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r;

3156

r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r;

3157

r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r;

3158

r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r;

3159

r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r;

3160

r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r;

3161

r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r;

3162

3163

return r;

3164

}

3165

3166

#endif /* GL_EXT_convolution */

3167

3168

#ifdef GL_EXT_coordinate_frame

3169

3170

static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT)

3171

{

3172

GLboolean r = GL_FALSE;

3173

3174

r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r;

3175

r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r;

3176

3177

return r;

3178

}

3179

3180

#endif /* GL_EXT_coordinate_frame */

3181

3182

#ifdef GL_EXT_copy_texture

3183

3184

static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT)

3185

{

3186

GLboolean r = GL_FALSE;

3187

3188

r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r;

3189

r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r;

3190

r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r;

3191

r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r;

3192

r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r;

3193

3194

return r;

3195

}

3196

3197

#endif /* GL_EXT_copy_texture */

3198

3199

#ifdef GL_EXT_cull_vertex

3200

3201

static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT)

3202

{

3203

GLboolean r = GL_FALSE;

3204

3205

r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r;

3206

r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r;

3207

3208

return r;

3209

}

3210

3211

#endif /* GL_EXT_cull_vertex */

3212

3213

#ifdef GL_EXT_depth_bounds_test

3214

3215

static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT)

3216

{

3217

GLboolean r = GL_FALSE;

3218

3219

r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r;

3220

3221

return r;

3222

}

3223

3224

#endif /* GL_EXT_depth_bounds_test */

3225

3226

#ifdef GL_EXT_draw_buffers2

3227

3228

static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT)

3229

{

3230

GLboolean r = GL_FALSE;

3231

3232

r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r;

3233

r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r;

3234

r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r;

3235

r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r;

3236

r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r;

3237

r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r;

3238

3239

return r;

3240

}

3241

3242

#endif /* GL_EXT_draw_buffers2 */

3243

3244

#ifdef GL_EXT_draw_instanced

3245

3246

static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)

3247

{

3248

GLboolean r = GL_FALSE;

3249

3250

r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r;

3251

r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r;

3252

3253

return r;

3254

}

3255

3256

#endif /* GL_EXT_draw_instanced */

3257

3258

#ifdef GL_EXT_draw_range_elements

3259

3260

static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT)

3261

{

3262

GLboolean r = GL_FALSE;

3263

3264

r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r;

3265

3266

return r;

3267

}

3268

3269

#endif /* GL_EXT_draw_range_elements */

3270

3271

#ifdef GL_EXT_fog_coord

3272

3273

static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT)

3274

{

3275

GLboolean r = GL_FALSE;

3276

3277

r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r;

3278

r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r;

3279

r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r;

3280

r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r;

3281

r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r;

3282

3283

return r;

3284

}

3285

3286

#endif /* GL_EXT_fog_coord */

3287

3288

#ifdef GL_EXT_fragment_lighting

3289

3290

static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT)

3291

{

3292

GLboolean r = GL_FALSE;

3293

3294

r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r;

3295

r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r;

3296

r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r;

3297

r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r;

3298

r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r;

3299

r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r;

3300

r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r;

3301

r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r;

3302

r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r;

3303

r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r;

3304

r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r;

3305

r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r;

3306

r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r;

3307

r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r;

3308

r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r;

3309

r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r;

3310

r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r;

3311

r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r;

3312

3313

return r;

3314

}

3315

3316

#endif /* GL_EXT_fragment_lighting */

3317

3318

#ifdef GL_EXT_framebuffer_blit

3319

3320

static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT)

3321

{

3322

GLboolean r = GL_FALSE;

3323

3324

r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r;

3325

3326

return r;

3327

}

3328

3329

#endif /* GL_EXT_framebuffer_blit */

3330

3331

#ifdef GL_EXT_framebuffer_multisample

3332

3333

static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

3334

{

3335

GLboolean r = GL_FALSE;

3336

3337

r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r;

3338

3339

return r;

3340

}

3341

3342

#endif /* GL_EXT_framebuffer_multisample */

3343

3344

#ifdef GL_EXT_framebuffer_object

3345

3346

static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

3347

{

3348

GLboolean r = GL_FALSE;

3349

3350

r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;

3351

r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;

3352

r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;

3353

r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;

3354

r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;

3355

r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;

3356

r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;

3357

r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;

3358

r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;

3359

r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;

3360

r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;

3361

r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;

3362

r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;

3363

r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;

3364

r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;

3365

r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;

3366

r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;

3367

3368

return r;

3369

}

3370

3371

#endif /* GL_EXT_framebuffer_object */

3372

3373

#ifdef GL_EXT_framebuffer_sRGB

3374

3375

#endif /* GL_EXT_framebuffer_sRGB */

3376

3377

#ifdef GL_EXT_geometry_shader4

3378

3379

static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)

3380

{

3381

GLboolean r = GL_FALSE;

3382

3383

r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r;

3384

r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r;

3385

r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r;

3386

r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r;

3387

3388

return r;

3389

}

3390

3391

#endif /* GL_EXT_geometry_shader4 */

3392

3393

#ifdef GL_EXT_gpu_program_parameters

3394

3395

static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

3396

{

3397

GLboolean r = GL_FALSE;

3398

3399

r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r;

3400

r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r;

3401

3402

return r;

3403

}

3404

3405

#endif /* GL_EXT_gpu_program_parameters */

3406

3407

#ifdef GL_EXT_gpu_shader4

3408

3409

static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)

3410

{

3411

GLboolean r = GL_FALSE;

3412

3413

r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r;

3414

r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r;

3415

r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r;

3416

r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r;

3417

r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r;

3418

r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r;

3419

r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r;

3420

r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r;

3421

r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r;

3422

r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r;

3423

r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r;

3424

r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r;

3425

r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r;

3426

r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r;

3427

r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r;

3428

r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r;

3429

r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r;

3430

r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r;

3431

r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r;

3432

r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r;

3433

r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r;

3434

r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r;

3435

r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r;

3436

r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r;

3437

r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r;

3438

r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r;

3439

r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r;

3440

r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r;

3441

r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r;

3442

r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r;

3443

r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r;

3444

r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r;

3445

r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r;

3446

r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r;

3447

3448

return r;

3449

}

3450

3451

#endif /* GL_EXT_gpu_shader4 */

3452

3453

#ifdef GL_EXT_histogram

3454

3455

static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT)

3456

{

3457

GLboolean r = GL_FALSE;

3458

3459

r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r;

3460

r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r;

3461

r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r;

3462

r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r;

3463

r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r;

3464

r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r;

3465

r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r;

3466

r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r;

3467

r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r;

3468

r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r;

3469

3470

return r;

3471

}

3472

3473

#endif /* GL_EXT_histogram */

3474

3475

#ifdef GL_EXT_index_array_formats

3476

3477

#endif /* GL_EXT_index_array_formats */

3478

3479

#ifdef GL_EXT_index_func

3480

3481

static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT)

3482

{

3483

GLboolean r = GL_FALSE;

3484

3485

r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r;

3486

3487

return r;

3488

}

3489

3490

#endif /* GL_EXT_index_func */

3491

3492

#ifdef GL_EXT_index_material

3493

3494

static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT)

3495

{

3496

GLboolean r = GL_FALSE;

3497

3498

r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r;

3499

3500

return r;

3501

}

3502

3503

#endif /* GL_EXT_index_material */

3504

3505

#ifdef GL_EXT_index_texture

3506

3507

#endif /* GL_EXT_index_texture */

3508

3509

#ifdef GL_EXT_light_texture

3510

3511

static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT)

3512

{

3513

GLboolean r = GL_FALSE;

3514

3515

r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r;

3516

r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r;

3517

r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r;

3518

3519

return r;

3520

}

3521

3522

#endif /* GL_EXT_light_texture */

3523

3524

#ifdef GL_EXT_misc_attribute

3525

3526

#endif /* GL_EXT_misc_attribute */

3527

3528

#ifdef GL_EXT_multi_draw_arrays

3529

3530

static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

3531

{

3532

GLboolean r = GL_FALSE;

3533

3534

r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r;

3535

r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r;

3536

3537

return r;

3538

}

3539

3540

#endif /* GL_EXT_multi_draw_arrays */

3541

3542

#ifdef GL_EXT_multisample

3543

3544

static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

3545

{

3546

GLboolean r = GL_FALSE;

3547

3548

r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r;

3549

r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r;

3550

3551

return r;

3552

}

3553

3554

#endif /* GL_EXT_multisample */

3555

3556

#ifdef GL_EXT_packed_depth_stencil

3557

3558

#endif /* GL_EXT_packed_depth_stencil */

3559

3560

#ifdef GL_EXT_packed_float

3561

3562

#endif /* GL_EXT_packed_float */

3563

3564

#ifdef GL_EXT_packed_pixels

3565

3566

#endif /* GL_EXT_packed_pixels */

3567

3568

#ifdef GL_EXT_paletted_texture

3569

3570

static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT)

3571

{

3572

GLboolean r = GL_FALSE;

3573

3574

r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r;

3575

r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r;

3576

r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r;

3577

r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r;

3578

3579

return r;

3580

}

3581

3582

#endif /* GL_EXT_paletted_texture */

3583

3584

#ifdef GL_EXT_pixel_buffer_object

3585

3586

#endif /* GL_EXT_pixel_buffer_object */

3587

3588

#ifdef GL_EXT_pixel_transform

3589

3590

static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT)

3591

{

3592

GLboolean r = GL_FALSE;

3593

3594

r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r;

3595

r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r;

3596

r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r;

3597

r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r;

3598

r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r;

3599

r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r;

3600

3601

return r;

3602

}

3603

3604

#endif /* GL_EXT_pixel_transform */

3605

3606

#ifdef GL_EXT_pixel_transform_color_table

3607

3608

#endif /* GL_EXT_pixel_transform_color_table */

3609

3610

#ifdef GL_EXT_point_parameters

3611

3612

static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

3613

{

3614

GLboolean r = GL_FALSE;

3615

3616

r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;

3617

r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;

3618

3619

return r;

3620

}

3621

3622

#endif /* GL_EXT_point_parameters */

3623

3624

#ifdef GL_EXT_polygon_offset

3625

3626

static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)

3627

{

3628

GLboolean r = GL_FALSE;

3629

3630

r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r;

3631

3632

return r;

3633

}

3634

3635

#endif /* GL_EXT_polygon_offset */

3636

3637

#ifdef GL_EXT_rescale_normal

3638

3639

#endif /* GL_EXT_rescale_normal */

3640

3641

#ifdef GL_EXT_scene_marker

3642

3643

static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT)

3644

{

3645

GLboolean r = GL_FALSE;

3646

3647

r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r;

3648

r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r;

3649

3650

return r;

3651

}

3652

3653

#endif /* GL_EXT_scene_marker */

3654

3655

#ifdef GL_EXT_secondary_color

3656

3657

static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)

3658

{

3659

GLboolean r = GL_FALSE;

3660

3661

r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;

3662

r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;

3663

r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;

3664

r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;

3665

r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;

3666

r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;

3667

r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;

3668

r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;

3669

r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;

3670

r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;

3671

r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;

3672

r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;

3673

r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;

3674

r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;

3675

r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;

3676

r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;

3677

r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;

3678

3679

return r;

3680

}

3681

3682

#endif /* GL_EXT_secondary_color */

3683

3684

#ifdef GL_EXT_separate_specular_color

3685

3686

#endif /* GL_EXT_separate_specular_color */

3687

3688

#ifdef GL_EXT_shadow_funcs

3689

3690

#endif /* GL_EXT_shadow_funcs */

3691

3692

#ifdef GL_EXT_shared_texture_palette

3693

3694

#endif /* GL_EXT_shared_texture_palette */

3695

3696

#ifdef GL_EXT_stencil_clear_tag

3697

3698

#endif /* GL_EXT_stencil_clear_tag */

3699

3700

#ifdef GL_EXT_stencil_two_side

3701

3702

static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)

3703

{

3704

GLboolean r = GL_FALSE;

3705

3706

r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;

3707

3708

return r;

3709

}

3710

3711

#endif /* GL_EXT_stencil_two_side */

3712

3713

#ifdef GL_EXT_stencil_wrap

3714

3715

#endif /* GL_EXT_stencil_wrap */

3716

3717

#ifdef GL_EXT_subtexture

3718

3719

static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT)

3720

{

3721

GLboolean r = GL_FALSE;

3722

3723

r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r;

3724

r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r;

3725

r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r;

3726

3727

return r;

3728

}

3729

3730

#endif /* GL_EXT_subtexture */

3731

3732

#ifdef GL_EXT_texture

3733

3734

#endif /* GL_EXT_texture */

3735

3736

#ifdef GL_EXT_texture3D

3737

3738

static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT)

3739

{

3740

GLboolean r = GL_FALSE;

3741

3742

r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r;

3743

3744

return r;

3745

}

3746

3747

#endif /* GL_EXT_texture3D */

3748

3749

#ifdef GL_EXT_texture_array

3750

3751

#endif /* GL_EXT_texture_array */

3752

3753

#ifdef GL_EXT_texture_buffer_object

3754

3755

static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

3756

{

3757

GLboolean r = GL_FALSE;

3758

3759

r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r;

3760

3761

return r;

3762

}

3763

3764

#endif /* GL_EXT_texture_buffer_object */

3765

3766

#ifdef GL_EXT_texture_compression_dxt1

3767

3768

#endif /* GL_EXT_texture_compression_dxt1 */

3769

3770

#ifdef GL_EXT_texture_compression_latc

3771

3772

#endif /* GL_EXT_texture_compression_latc */

3773

3774

#ifdef GL_EXT_texture_compression_rgtc

3775

3776

#endif /* GL_EXT_texture_compression_rgtc */

3777

3778

#ifdef GL_EXT_texture_compression_s3tc

3779

3780

#endif /* GL_EXT_texture_compression_s3tc */

3781

3782

#ifdef GL_EXT_texture_cube_map

3783

3784

#endif /* GL_EXT_texture_cube_map */

3785

3786

#ifdef GL_EXT_texture_edge_clamp

3787

3788

#endif /* GL_EXT_texture_edge_clamp */

3789

3790

#ifdef GL_EXT_texture_env

3791

3792

#endif /* GL_EXT_texture_env */

3793

3794

#ifdef GL_EXT_texture_env_add

3795

3796

#endif /* GL_EXT_texture_env_add */

3797

3798

#ifdef GL_EXT_texture_env_combine

3799

3800

#endif /* GL_EXT_texture_env_combine */

3801

3802

#ifdef GL_EXT_texture_env_dot3

3803

3804

#endif /* GL_EXT_texture_env_dot3 */

3805

3806

#ifdef GL_EXT_texture_filter_anisotropic

3807

3808

#endif /* GL_EXT_texture_filter_anisotropic */

3809

3810

#ifdef GL_EXT_texture_integer

3811

3812

static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT)

3813

{

3814

GLboolean r = GL_FALSE;

3815

3816

r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r;

3817

r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r;

3818

r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r;

3819

r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r;

3820

r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r;

3821

r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r;

3822

3823

return r;

3824

}

3825

3826

#endif /* GL_EXT_texture_integer */

3827

3828

#ifdef GL_EXT_texture_lod_bias

3829

3830

#endif /* GL_EXT_texture_lod_bias */

3831

3832

#ifdef GL_EXT_texture_mirror_clamp

3833

3834

#endif /* GL_EXT_texture_mirror_clamp */

3835

3836

#ifdef GL_EXT_texture_object

3837

3838

static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT)

3839

{

3840

GLboolean r = GL_FALSE;

3841

3842

r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r;

3843

r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r;

3844

r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r;

3845

r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;

3846

r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;

3847

r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;

3848

3849

return r;

3850

}

3851

3852

#endif /* GL_EXT_texture_object */

3853

3854

#ifdef GL_EXT_texture_perturb_normal

3855

3856

static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT)

3857

{

3858

GLboolean r = GL_FALSE;

3859

3860

r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;

3861

3862

return r;

3863

}

3864

3865

#endif /* GL_EXT_texture_perturb_normal */

3866

3867

#ifdef GL_EXT_texture_rectangle

3868

3869

#endif /* GL_EXT_texture_rectangle */

3870

3871

#ifdef GL_EXT_texture_sRGB

3872

3873

#endif /* GL_EXT_texture_sRGB */

3874

3875

#ifdef GL_EXT_texture_shared_exponent

3876

3877

#endif /* GL_EXT_texture_shared_exponent */

3878

3879

#ifdef GL_EXT_timer_query

3880

3881

static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)

3882

{

3883

GLboolean r = GL_FALSE;

3884

3885

r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r;

3886

r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r;

3887

3888

return r;

3889

}

3890

3891

#endif /* GL_EXT_timer_query */

3892

3893

#ifdef GL_EXT_vertex_array

3894

3895

static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)

3896

{

3897

GLboolean r = GL_FALSE;

3898

3899

r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;

3900

r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;

3901

r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;

3902

r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;

3903

r = ((glGetPointervEXT = (PFNGLGETPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointervEXT")) == NULL) || r;

3904

r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;

3905

r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;

3906

r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;

3907

r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;

3908

3909

return r;

3910

}

3911

3912

#endif /* GL_EXT_vertex_array */

3913

3914

#ifdef GL_EXT_vertex_shader

3915

3916

static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)

3917

{

3918

GLboolean r = GL_FALSE;

3919

3920

r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;

3921

r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;

3922

r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;

3923

r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;

3924

r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;

3925

r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;

3926

r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;

3927

r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;

3928

r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;

3929

r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;

3930

r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;

3931

r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;

3932

r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;

3933

r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;

3934

r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;

3935

r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;

3936

r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;

3937

r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;

3938

r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;

3939

r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;

3940

r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;

3941

r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;

3942

r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;

3943

r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;

3944

r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;

3945

r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;

3946

r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;

3947

r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;

3948

r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;

3949

r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;

3950

r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;

3951

r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;

3952

r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;

3953

r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;

3954

r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;

3955

r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;

3956

r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;

3957

r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;

3958

r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;

3959

r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;

3960

r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;

3961

r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;

3962

3963

return r;

3964

}

3965

3966

#endif /* GL_EXT_vertex_shader */

3967

3968

#ifdef GL_EXT_vertex_weighting

3969

3970

static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT)

3971

{

3972

GLboolean r = GL_FALSE;

3973

3974

r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;

3975

r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;

3976

r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;

3977

3978

return r;

3979

}

3980

3981

#endif /* GL_EXT_vertex_weighting */

3982

3983

#ifdef GL_GREMEDY_frame_terminator

3984

3985

static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT)

3986

{

3987

GLboolean r = GL_FALSE;

3988

3989

r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r;

3990

3991

return r;

3992

}

3993

3994

#endif /* GL_GREMEDY_frame_terminator */

3995

3996

#ifdef GL_GREMEDY_string_marker

3997

3998

static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT)

3999

{

4000

GLboolean r = GL_FALSE;

4001

4002

r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r;

4003

4004

return r;

4005

}

4006

4007

#endif /* GL_GREMEDY_string_marker */

4008

4009

#ifdef GL_HP_convolution_border_modes

4010

4011

#endif /* GL_HP_convolution_border_modes */

4012

4013

#ifdef GL_HP_image_transform

4014

4015

static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT)

4016

{

4017

GLboolean r = GL_FALSE;

4018

4019

r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;

4020

r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;

4021

r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;

4022

r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;

4023

r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;

4024

r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;

4025

4026

return r;

4027

}

4028

4029

#endif /* GL_HP_image_transform */

4030

4031

#ifdef GL_HP_occlusion_test

4032

4033

#endif /* GL_HP_occlusion_test */

4034

4035

#ifdef GL_HP_texture_lighting

4036

4037

#endif /* GL_HP_texture_lighting */

4038

4039

#ifdef GL_IBM_cull_vertex

4040

4041

#endif /* GL_IBM_cull_vertex */

4042

4043

#ifdef GL_IBM_multimode_draw_arrays

4044

4045

static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

4046

{

4047

GLboolean r = GL_FALSE;

4048

4049

r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;

4050

r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;

4051

4052

return r;

4053

}

4054

4055

#endif /* GL_IBM_multimode_draw_arrays */

4056

4057

#ifdef GL_IBM_rasterpos_clip

4058

4059

#endif /* GL_IBM_rasterpos_clip */

4060

4061

#ifdef GL_IBM_static_data

4062

4063

#endif /* GL_IBM_static_data */

4064

4065

#ifdef GL_IBM_texture_mirrored_repeat

4066

4067

#endif /* GL_IBM_texture_mirrored_repeat */

4068

4069

#ifdef GL_IBM_vertex_array_lists

4070

4071

static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT)

4072

{

4073

GLboolean r = GL_FALSE;

4074

4075

r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;

4076

r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;

4077

r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;

4078

r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;

4079

r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;

4080

r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;

4081

r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;

4082

r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;

4083

4084

return r;

4085

}

4086

4087

#endif /* GL_IBM_vertex_array_lists */

4088

4089

#ifdef GL_INGR_color_clamp

4090

4091

#endif /* GL_INGR_color_clamp */

4092

4093

#ifdef GL_INGR_interlace_read

4094

4095

#endif /* GL_INGR_interlace_read */

4096

4097

#ifdef GL_INTEL_parallel_arrays

4098

4099

static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

4100

{

4101

GLboolean r = GL_FALSE;

4102

4103

r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;

4104

r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;

4105

r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;

4106

r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;

4107

4108

return r;

4109

}

4110

4111

#endif /* GL_INTEL_parallel_arrays */

4112

4113

#ifdef GL_INTEL_texture_scissor

4114

4115

static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT)

4116

{

4117

GLboolean r = GL_FALSE;

4118

4119

r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;

4120

r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;

4121

4122

return r;

4123

}

4124

4125

#endif /* GL_INTEL_texture_scissor */

4126

4127

#ifdef GL_KTX_buffer_region

4128

4129

static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT)

4130

{

4131

GLboolean r = GL_FALSE;

4132

4133

r = ((glBufferRegionEnabledEXT = (PFNGLBUFFERREGIONENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabledEXT")) == NULL) || r;

4134

r = ((glDeleteBufferRegionEXT = (PFNGLDELETEBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegionEXT")) == NULL) || r;

4135

r = ((glDrawBufferRegionEXT = (PFNGLDRAWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegionEXT")) == NULL) || r;

4136

r = ((glNewBufferRegionEXT = (PFNGLNEWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegionEXT")) == NULL) || r;

4137

r = ((glReadBufferRegionEXT = (PFNGLREADBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegionEXT")) == NULL) || r;

4138

4139

return r;

4140

}

4141

4142

#endif /* GL_KTX_buffer_region */

4143

4144

#ifdef GL_MESAX_texture_stack

4145

4146

#endif /* GL_MESAX_texture_stack */

4147

4148

#ifdef GL_MESA_pack_invert

4149

4150

#endif /* GL_MESA_pack_invert */

4151

4152

#ifdef GL_MESA_resize_buffers

4153

4154

static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

4155

{

4156

GLboolean r = GL_FALSE;

4157

4158

r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;

4159

4160

return r;

4161

}

4162

4163

#endif /* GL_MESA_resize_buffers */

4164

4165

#ifdef GL_MESA_window_pos

4166

4167

static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)

4168

{

4169

GLboolean r = GL_FALSE;

4170

4171

r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;

4172

r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;

4173

r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;

4174

r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;

4175

r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;

4176

r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;

4177

r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;

4178

r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;

4179

r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;

4180

r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;

4181

r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;

4182

r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;

4183

r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;

4184

r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;

4185

r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;

4186

r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;

4187

r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;

4188

r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;

4189

r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;

4190

r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;

4191

r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;

4192

r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;

4193

r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;

4194

r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;

4195

4196

return r;

4197

}

4198

4199

#endif /* GL_MESA_window_pos */

4200

4201

#ifdef GL_MESA_ycbcr_texture

4202

4203

#endif /* GL_MESA_ycbcr_texture */

4204

4205

#ifdef GL_NV_blend_square

4206

4207

#endif /* GL_NV_blend_square */

4208

4209

#ifdef GL_NV_copy_depth_to_color

4210

4211

#endif /* GL_NV_copy_depth_to_color */

4212

4213

#ifdef GL_NV_depth_buffer_float

4214

4215

static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)

4216

{

4217

GLboolean r = GL_FALSE;

4218

4219

r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r;

4220

r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r;

4221

r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r;

4222

4223

return r;

4224

}

4225

4226

#endif /* GL_NV_depth_buffer_float */

4227

4228

#ifdef GL_NV_depth_clamp

4229

4230

#endif /* GL_NV_depth_clamp */

4231

4232

#ifdef GL_NV_depth_range_unclamped

4233

4234

#endif /* GL_NV_depth_range_unclamped */

4235

4236

#ifdef GL_NV_evaluators

4237

4238

static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)

4239

{

4240

GLboolean r = GL_FALSE;

4241

4242

r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;

4243

r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;

4244

r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;

4245

r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;

4246

r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;

4247

r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;

4248

r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;

4249

r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;

4250

r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;

4251

4252

return r;

4253

}

4254

4255

#endif /* GL_NV_evaluators */

4256

4257

#ifdef GL_NV_fence

4258

4259

static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT)

4260

{

4261

GLboolean r = GL_FALSE;

4262

4263

r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;

4264

r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;

4265

r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;

4266

r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;

4267

r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;

4268

r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;

4269

r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;

4270

4271

return r;

4272

}

4273

4274

#endif /* GL_NV_fence */

4275

4276

#ifdef GL_NV_float_buffer

4277

4278

#endif /* GL_NV_float_buffer */

4279

4280

#ifdef GL_NV_fog_distance

4281

4282

#endif /* GL_NV_fog_distance */

4283

4284

#ifdef GL_NV_fragment_program

4285

4286

static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)

4287

{

4288

GLboolean r = GL_FALSE;

4289

4290

r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;

4291

r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;

4292

r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;

4293

r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;

4294

r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;

4295

r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;

4296

4297

return r;

4298

}

4299

4300

#endif /* GL_NV_fragment_program */

4301

4302

#ifdef GL_NV_fragment_program2

4303

4304

#endif /* GL_NV_fragment_program2 */

4305

4306

#ifdef GL_NV_fragment_program4

4307

4308

#endif /* GL_NV_fragment_program4 */

4309

4310

#ifdef GL_NV_fragment_program_option

4311

4312

#endif /* GL_NV_fragment_program_option */

4313

4314

#ifdef GL_NV_framebuffer_multisample_coverage

4315

4316

static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT)

4317

{

4318

GLboolean r = GL_FALSE;

4319

4320

r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r;

4321

4322

return r;

4323

}

4324

4325

#endif /* GL_NV_framebuffer_multisample_coverage */

4326

4327

#ifdef GL_NV_geometry_program4

4328

4329

static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT)

4330

{

4331

GLboolean r = GL_FALSE;

4332

4333

r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r;

4334

4335

return r;

4336

}

4337

4338

#endif /* GL_NV_geometry_program4 */

4339

4340

#ifdef GL_NV_geometry_shader4

4341

4342

#endif /* GL_NV_geometry_shader4 */

4343

4344

#ifdef GL_NV_gpu_program4

4345

4346

static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT)

4347

{

4348

GLboolean r = GL_FALSE;

4349

4350

r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r;

4351

r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r;

4352

r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r;

4353

r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r;

4354

r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r;

4355

r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r;

4356

r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r;

4357

r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r;

4358

r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r;

4359

r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r;

4360

r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r;

4361

r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r;

4362

4363

return r;

4364

}

4365

4366

#endif /* GL_NV_gpu_program4 */

4367

4368

#ifdef GL_NV_half_float

4369

4370

static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)

4371

{

4372

GLboolean r = GL_FALSE;

4373

4374

r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;

4375

r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;

4376

r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;

4377

r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;

4378

r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;

4379

r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;

4380

r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;

4381

r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;

4382

r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;

4383

r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;

4384

r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;

4385

r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;

4386

r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;

4387

r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;

4388

r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;

4389

r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;

4390

r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;

4391

r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;

4392

r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;

4393

r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;

4394

r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;

4395

r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;

4396

r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;

4397

r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;

4398

r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;

4399

r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;

4400

r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;

4401

r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;

4402

r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;

4403

r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;

4404

r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;

4405

r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;

4406

r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;

4407

r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;

4408

r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;

4409

r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;

4410

r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;

4411

r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;

4412

r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;

4413

r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;

4414

r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;

4415

r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;

4416

r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;

4417

r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;

4418

r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;

4419

r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;

4420

4421

return r;

4422

}

4423

4424

#endif /* GL_NV_half_float */

4425

4426

#ifdef GL_NV_light_max_exponent

4427

4428

#endif /* GL_NV_light_max_exponent */

4429

4430

#ifdef GL_NV_multisample_filter_hint

4431

4432

#endif /* GL_NV_multisample_filter_hint */

4433

4434

#ifdef GL_NV_occlusion_query

4435

4436

static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)

4437

{

4438

GLboolean r = GL_FALSE;

4439

4440

r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;

4441

r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;

4442

r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;

4443

r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;

4444

r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;

4445

r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;

4446

r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;

4447

4448

return r;

4449

}

4450

4451

#endif /* GL_NV_occlusion_query */

4452

4453

#ifdef GL_NV_packed_depth_stencil

4454

4455

#endif /* GL_NV_packed_depth_stencil */

4456

4457

#ifdef GL_NV_parameter_buffer_object

4458

4459

static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

4460

{

4461

GLboolean r = GL_FALSE;

4462

4463

r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r;

4464

r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r;

4465

r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r;

4466

4467

return r;

4468

}

4469

4470

#endif /* GL_NV_parameter_buffer_object */

4471

4472

#ifdef GL_NV_pixel_data_range

4473

4474

static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)

4475

{

4476

GLboolean r = GL_FALSE;

4477

4478

r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;

4479

r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;

4480

4481

return r;

4482

}

4483

4484

#endif /* GL_NV_pixel_data_range */

4485

4486

#ifdef GL_NV_point_sprite

4487

4488

static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT)

4489

{

4490

GLboolean r = GL_FALSE;

4491

4492

r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;

4493

r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;

4494

4495

return r;

4496

}

4497

4498

#endif /* GL_NV_point_sprite */

4499

4500

#ifdef GL_NV_primitive_restart

4501

4502

static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT)

4503

{

4504

GLboolean r = GL_FALSE;

4505

4506

r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;

4507

r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;

4508

4509

return r;

4510

}

4511

4512

#endif /* GL_NV_primitive_restart */

4513

4514

#ifdef GL_NV_register_combiners

4515

4516

static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)

4517

{

4518

GLboolean r = GL_FALSE;

4519

4520

r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;

4521

r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;

4522

r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;

4523

r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;

4524

r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;

4525

r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;

4526

r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;

4527

r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;

4528

r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;

4529

r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;

4530

r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;

4531

r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;

4532

r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;

4533

4534

return r;

4535

}

4536

4537

#endif /* GL_NV_register_combiners */

4538

4539

#ifdef GL_NV_register_combiners2

4540

4541

static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)

4542

{

4543

GLboolean r = GL_FALSE;

4544

4545

r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;

4546

r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;

4547

4548

return r;

4549

}

4550

4551

#endif /* GL_NV_register_combiners2 */

4552

4553

#ifdef GL_NV_texgen_emboss

4554

4555

#endif /* GL_NV_texgen_emboss */

4556

4557

#ifdef GL_NV_texgen_reflection

4558

4559

#endif /* GL_NV_texgen_reflection */

4560

4561

#ifdef GL_NV_texture_compression_vtc

4562

4563

#endif /* GL_NV_texture_compression_vtc */

4564

4565

#ifdef GL_NV_texture_env_combine4

4566

4567

#endif /* GL_NV_texture_env_combine4 */

4568

4569

#ifdef GL_NV_texture_expand_normal

4570

4571

#endif /* GL_NV_texture_expand_normal */

4572

4573

#ifdef GL_NV_texture_rectangle

4574

4575

#endif /* GL_NV_texture_rectangle */

4576

4577

#ifdef GL_NV_texture_shader

4578

4579

#endif /* GL_NV_texture_shader */

4580

4581

#ifdef GL_NV_texture_shader2

4582

4583

#endif /* GL_NV_texture_shader2 */

4584

4585

#ifdef GL_NV_texture_shader3

4586

4587

#endif /* GL_NV_texture_shader3 */

4588

4589

#ifdef GL_NV_transform_feedback

4590

4591

static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)

4592

{

4593

GLboolean r = GL_FALSE;

4594

4595

r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r;

4596

r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r;

4597

r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r;

4598

r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r;

4599

r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r;

4600

r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r;

4601

r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r;

4602

r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r;

4603

r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r;

4604

r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r;

4605

r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r;

4606

4607

return r;

4608

}

4609

4610

#endif /* GL_NV_transform_feedback */

4611

4612

#ifdef GL_NV_vertex_array_range

4613

4614

static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)

4615

{

4616

GLboolean r = GL_FALSE;

4617

4618

r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;

4619

r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;

4620

4621

return r;

4622

}

4623

4624

#endif /* GL_NV_vertex_array_range */

4625

4626

#ifdef GL_NV_vertex_array_range2

4627

4628

#endif /* GL_NV_vertex_array_range2 */

4629

4630

#ifdef GL_NV_vertex_program

4631

4632

static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)

4633

{

4634

GLboolean r = GL_FALSE;

4635

4636

r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;

4637

r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;

4638

r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;

4639

r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;

4640

r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;

4641

r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;

4642

r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;

4643

r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;

4644

r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;

4645

r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;

4646

r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;

4647

r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;

4648

r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;

4649

r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;

4650

r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;

4651

r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;

4652

r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;

4653

r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;

4654

r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;

4655

r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;

4656

r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;

4657

r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;

4658

r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;

4659

r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;

4660

r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;

4661

r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;

4662

r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;

4663

r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;

4664

r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;

4665

r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;

4666

r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;

4667

r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;

4668

r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;

4669

r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;

4670

r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;

4671

r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;

4672

r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;

4673

r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;

4674

r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;

4675

r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;

4676

r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;

4677

r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;

4678

r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;

4679

r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;

4680

r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;

4681

r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;

4682

r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;

4683

r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;

4684

r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;

4685

r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;

4686

r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;

4687

r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;

4688

r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;

4689

r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;

4690

r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;

4691

r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;

4692

r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;

4693

r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;

4694

r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;

4695

r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;

4696

r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;

4697

r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;

4698

r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;

4699

r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;

4700

4701

return r;

4702

}

4703

4704

#endif /* GL_NV_vertex_program */

4705

4706

#ifdef GL_NV_vertex_program1_1

4707

4708

#endif /* GL_NV_vertex_program1_1 */

4709

4710

#ifdef GL_NV_vertex_program2

4711

4712

#endif /* GL_NV_vertex_program2 */

4713

4714

#ifdef GL_NV_vertex_program2_option

4715

4716

#endif /* GL_NV_vertex_program2_option */

4717

4718

#ifdef GL_NV_vertex_program3

4719

4720

#endif /* GL_NV_vertex_program3 */

4721

4722

#ifdef GL_NV_vertex_program4

4723

4724

#endif /* GL_NV_vertex_program4 */

4725

4726

#ifdef GL_OES_byte_coordinates

4727

4728

#endif /* GL_OES_byte_coordinates */

4729

4730

#ifdef GL_OES_compressed_paletted_texture

4731

4732

#endif /* GL_OES_compressed_paletted_texture */

4733

4734

#ifdef GL_OES_read_format

4735

4736

#endif /* GL_OES_read_format */

4737

4738

#ifdef GL_OES_single_precision

4739

4740

static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT)

4741

{

4742

GLboolean r = GL_FALSE;

4743

4744

r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r;

4745

r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r;

4746

r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r;

4747

r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r;

4748

r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r;

4749

r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r;

4750

4751

return r;

4752

}

4753

4754

#endif /* GL_OES_single_precision */

4755

4756

#ifdef GL_OML_interlace

4757

4758

#endif /* GL_OML_interlace */

4759

4760

#ifdef GL_OML_resample

4761

4762

#endif /* GL_OML_resample */

4763

4764

#ifdef GL_OML_subsample

4765

4766

#endif /* GL_OML_subsample */

4767

4768

#ifdef GL_PGI_misc_hints

4769

4770

#endif /* GL_PGI_misc_hints */

4771

4772

#ifdef GL_PGI_vertex_hints

4773

4774

#endif /* GL_PGI_vertex_hints */

4775

4776

#ifdef GL_REND_screen_coordinates

4777

4778

#endif /* GL_REND_screen_coordinates */

4779

4780

#ifdef GL_S3_s3tc

4781

4782

#endif /* GL_S3_s3tc */

4783

4784

#ifdef GL_SGIS_color_range

4785

4786

#endif /* GL_SGIS_color_range */

4787

4788

#ifdef GL_SGIS_detail_texture

4789

4790

static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4791

{

4792

GLboolean r = GL_FALSE;

4793

4794

r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;

4795

r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;

4796

4797

return r;

4798

}

4799

4800

#endif /* GL_SGIS_detail_texture */

4801

4802

#ifdef GL_SGIS_fog_function

4803

4804

static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT)

4805

{

4806

GLboolean r = GL_FALSE;

4807

4808

r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;

4809

r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;

4810

4811

return r;

4812

}

4813

4814

#endif /* GL_SGIS_fog_function */

4815

4816

#ifdef GL_SGIS_generate_mipmap

4817

4818

#endif /* GL_SGIS_generate_mipmap */

4819

4820

#ifdef GL_SGIS_multisample

4821

4822

static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

4823

{

4824

GLboolean r = GL_FALSE;

4825

4826

r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;

4827

r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;

4828

4829

return r;

4830

}

4831

4832

#endif /* GL_SGIS_multisample */

4833

4834

#ifdef GL_SGIS_pixel_texture

4835

4836

#endif /* GL_SGIS_pixel_texture */

4837

4838

#ifdef GL_SGIS_sharpen_texture

4839

4840

static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4841

{

4842

GLboolean r = GL_FALSE;

4843

4844

r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;

4845

r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;

4846

4847

return r;

4848

}

4849

4850

#endif /* GL_SGIS_sharpen_texture */

4851

4852

#ifdef GL_SGIS_texture4D

4853

4854

static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT)

4855

{

4856

GLboolean r = GL_FALSE;

4857

4858

r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;

4859

r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;

4860

4861

return r;

4862

}

4863

4864

#endif /* GL_SGIS_texture4D */

4865

4866

#ifdef GL_SGIS_texture_border_clamp

4867

4868

#endif /* GL_SGIS_texture_border_clamp */

4869

4870

#ifdef GL_SGIS_texture_edge_clamp

4871

4872

#endif /* GL_SGIS_texture_edge_clamp */

4873

4874

#ifdef GL_SGIS_texture_filter4

4875

4876

static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT)

4877

{

4878

GLboolean r = GL_FALSE;

4879

4880

r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;

4881

r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;

4882

4883

return r;

4884

}

4885

4886

#endif /* GL_SGIS_texture_filter4 */

4887

4888

#ifdef GL_SGIS_texture_lod

4889

4890

#endif /* GL_SGIS_texture_lod */

4891

4892

#ifdef GL_SGIS_texture_select

4893

4894

#endif /* GL_SGIS_texture_select */

4895

4896

#ifdef GL_SGIX_async

4897

4898

static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT)

4899

{

4900

GLboolean r = GL_FALSE;

4901

4902

r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;

4903

r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;

4904

r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;

4905

r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;

4906

r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;

4907

r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;

4908

4909

return r;

4910

}

4911

4912

#endif /* GL_SGIX_async */

4913

4914

#ifdef GL_SGIX_async_histogram

4915

4916

#endif /* GL_SGIX_async_histogram */

4917

4918

#ifdef GL_SGIX_async_pixel

4919

4920

#endif /* GL_SGIX_async_pixel */

4921

4922

#ifdef GL_SGIX_blend_alpha_minmax

4923

4924

#endif /* GL_SGIX_blend_alpha_minmax */

4925

4926

#ifdef GL_SGIX_clipmap

4927

4928

#endif /* GL_SGIX_clipmap */

4929

4930

#ifdef GL_SGIX_depth_texture

4931

4932

#endif /* GL_SGIX_depth_texture */

4933

4934

#ifdef GL_SGIX_flush_raster

4935

4936

static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT)

4937

{

4938

GLboolean r = GL_FALSE;

4939

4940

r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;

4941

4942

return r;

4943

}

4944

4945

#endif /* GL_SGIX_flush_raster */

4946

4947

#ifdef GL_SGIX_fog_offset

4948

4949

#endif /* GL_SGIX_fog_offset */

4950

4951

#ifdef GL_SGIX_fog_texture

4952

4953

static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4954

{

4955

GLboolean r = GL_FALSE;

4956

4957

r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;

4958

4959

return r;

4960

}

4961

4962

#endif /* GL_SGIX_fog_texture */

4963

4964

#ifdef GL_SGIX_fragment_specular_lighting

4965

4966

static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT)

4967

{

4968

GLboolean r = GL_FALSE;

4969

4970

r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;

4971

r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;

4972

r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;

4973

r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;

4974

r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;

4975

r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;

4976

r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;

4977

r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;

4978

r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;

4979

r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;

4980

r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;

4981

r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;

4982

r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;

4983

r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;

4984

r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;

4985

r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;

4986

r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;

4987

4988

return r;

4989

}

4990

4991

#endif /* GL_SGIX_fragment_specular_lighting */

4992

4993

#ifdef GL_SGIX_framezoom

4994

4995

static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT)

4996

{

4997

GLboolean r = GL_FALSE;

4998

4999

r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;

5000

5001

return r;

5002

}

5003

5004

#endif /* GL_SGIX_framezoom */

5005

5006

#ifdef GL_SGIX_interlace

5007

5008

#endif /* GL_SGIX_interlace */

5009

5010

#ifdef GL_SGIX_ir_instrument1

5011

5012

#endif /* GL_SGIX_ir_instrument1 */

5013

5014

#ifdef GL_SGIX_list_priority

5015

5016

#endif /* GL_SGIX_list_priority */

5017

5018

#ifdef GL_SGIX_pixel_texture

5019

5020

static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT)

5021

{

5022

GLboolean r = GL_FALSE;

5023

5024

r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;

5025

5026

return r;

5027

}

5028

5029

#endif /* GL_SGIX_pixel_texture */

5030

5031

#ifdef GL_SGIX_pixel_texture_bits

5032

5033

#endif /* GL_SGIX_pixel_texture_bits */

5034

5035

#ifdef GL_SGIX_reference_plane

5036

5037

static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT)

5038

{

5039

GLboolean r = GL_FALSE;

5040

5041

r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;

5042

5043

return r;

5044

}

5045

5046

#endif /* GL_SGIX_reference_plane */

5047

5048

#ifdef GL_SGIX_resample

5049

5050

#endif /* GL_SGIX_resample */

5051

5052

#ifdef GL_SGIX_shadow

5053

5054

#endif /* GL_SGIX_shadow */

5055

5056

#ifdef GL_SGIX_shadow_ambient

5057

5058

#endif /* GL_SGIX_shadow_ambient */

5059

5060

#ifdef GL_SGIX_sprite

5061

5062

static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT)

5063

{

5064

GLboolean r = GL_FALSE;

5065

5066

r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;

5067

r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;

5068

r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;

5069

r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;

5070

5071

return r;

5072

}

5073

5074

#endif /* GL_SGIX_sprite */

5075

5076

#ifdef GL_SGIX_tag_sample_buffer

5077

5078

static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT)

5079

{

5080

GLboolean r = GL_FALSE;

5081

5082

r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;

5083

5084

return r;

5085

}

5086

5087

#endif /* GL_SGIX_tag_sample_buffer */

5088

5089

#ifdef GL_SGIX_texture_add_env

5090

5091

#endif /* GL_SGIX_texture_add_env */

5092

5093

#ifdef GL_SGIX_texture_coordinate_clamp

5094

5095

#endif /* GL_SGIX_texture_coordinate_clamp */

5096

5097

#ifdef GL_SGIX_texture_lod_bias

5098

5099

#endif /* GL_SGIX_texture_lod_bias */

5100

5101

#ifdef GL_SGIX_texture_multi_buffer

5102

5103

#endif /* GL_SGIX_texture_multi_buffer */

5104

5105

#ifdef GL_SGIX_texture_range

5106

5107

#endif /* GL_SGIX_texture_range */

5108

5109

#ifdef GL_SGIX_texture_scale_bias

5110

5111

#endif /* GL_SGIX_texture_scale_bias */

5112

5113

#ifdef GL_SGIX_vertex_preclip

5114

5115

#endif /* GL_SGIX_vertex_preclip */

5116

5117

#ifdef GL_SGIX_vertex_preclip_hint

5118

5119

#endif /* GL_SGIX_vertex_preclip_hint */

5120

5121

#ifdef GL_SGIX_ycrcb

5122

5123

#endif /* GL_SGIX_ycrcb */

5124

5125

#ifdef GL_SGI_color_matrix

5126

5127

#endif /* GL_SGI_color_matrix */

5128

5129

#ifdef GL_SGI_color_table

5130

5131

static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT)

5132

{

5133

GLboolean r = GL_FALSE;

5134

5135

r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;

5136

r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;

5137

r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;

5138

r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;

5139

r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;

5140

r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;

5141

r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;

5142

5143

return r;

5144

}

5145

5146

#endif /* GL_SGI_color_table */

5147

5148

#ifdef GL_SGI_texture_color_table

5149

5150

#endif /* GL_SGI_texture_color_table */

5151

5152

#ifdef GL_SUNX_constant_data

5153

5154

static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT)

5155

{

5156

GLboolean r = GL_FALSE;

5157

5158

r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;

5159

5160

return r;

5161

}

5162

5163

#endif /* GL_SUNX_constant_data */

5164

5165

#ifdef GL_SUN_convolution_border_modes

5166

5167

#endif /* GL_SUN_convolution_border_modes */

5168

5169

#ifdef GL_SUN_global_alpha

5170

5171

static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT)

5172

{

5173

GLboolean r = GL_FALSE;

5174

5175

r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;

5176

r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;

5177

r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;

5178

r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;

5179

r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;

5180

r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;

5181

r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;

5182

r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;

5183

5184

return r;

5185

}

5186

5187

#endif /* GL_SUN_global_alpha */

5188

5189

#ifdef GL_SUN_mesh_array

5190

5191

#endif /* GL_SUN_mesh_array */

5192

5193

#ifdef GL_SUN_read_video_pixels

5194

5195

static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT)

5196

{

5197

GLboolean r = GL_FALSE;

5198

5199

r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;

5200

5201

return r;

5202

}

5203

5204

#endif /* GL_SUN_read_video_pixels */

5205

5206

#ifdef GL_SUN_slice_accum

5207

5208

#endif /* GL_SUN_slice_accum */

5209

5210

#ifdef GL_SUN_triangle_list

5211

5212

static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT)

5213

{

5214

GLboolean r = GL_FALSE;

5215

5216

r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;

5217

r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;

5218

r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;

5219

r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;

5220

r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;

5221

r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;

5222

r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;

5223

5224

return r;

5225

}

5226

5227

#endif /* GL_SUN_triangle_list */

5228

5229

#ifdef GL_SUN_vertex

5230

5231

static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT)

5232

{

5233

GLboolean r = GL_FALSE;

5234

5235

r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;

5236

r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;

5237

r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;

5238

r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;

5239

r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;

5240

r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;

5241

r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;

5242

r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;

5243

r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;

5244

r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;

5245

r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;

5246

r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;

5247

r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;

5248

r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;

5249

r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;

5250

r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;

5251

r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;

5252

r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;

5253

r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

5254

r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

5255

r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

5256

r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

5257

r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;

5258

r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;

5259

r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;

5260

r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;

5261

r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;

5262

r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;

5263

r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

5264

r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

5265

r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;

5266

r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;

5267

r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

5268

r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

5269

r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;

5270

r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;

5271

r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;

5272

r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;

5273

r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;

5274

r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;

5275

5276

return r;

5277

}

5278

5279

#endif /* GL_SUN_vertex */

5280

5281

#ifdef GL_WIN_phong_shading

5282

5283

#endif /* GL_WIN_phong_shading */

5284

5285

#ifdef GL_WIN_specular_fog

5286

5287

#endif /* GL_WIN_specular_fog */

5288

5289

#ifdef GL_WIN_swap_hint

5290

5291

static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT)

5292

{

5293

GLboolean r = GL_FALSE;

5294

5295

r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;

5296

5297

return r;

5298

}

5299

5300

#endif /* GL_WIN_swap_hint */

5301

5302

/* ------------------------------------------------------------------------- */

5303

5304

/*

5305

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

5306

* is not sufficient because extension names can be prefixes of

5307

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

5308

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

5309

*/

5310

GLboolean glewGetExtension (const char* name)

5311

{

5312

GLubyte* p;

5313

GLubyte* end;

5314

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

5315

p = (GLubyte*)glGetString(GL_EXTENSIONS);

5316

if (0 == p) return GL_FALSE;

5317

end = p + _glewStrLen(p);

5318

while (p < end)

5319

{

5320

GLuint n = _glewStrCLen(p, ' ');

5321

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

5322

p += n+1;

5323

}

5324

return GL_FALSE;

5325

}

5326

5327

/* ------------------------------------------------------------------------- */

5328

5329

#ifndef GLEW_MX

5330

static

5331

#endif

5332

GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)

5333

{

5334

const GLubyte* s;

5335

GLuint dot, major, minor;

5336

/* query opengl version */

5337

s = glGetString(GL_VERSION);

5338

dot = _glewStrCLen(s, '.');

5339

major = dot-1;

5340

minor = dot+1;

5341

if (dot == 0 || s[minor] == '\0')

5342

return GLEW_ERROR_NO_GL_VERSION;

5343

if (s[major] == '1' && s[minor] == '0')

5344

{

5345

return GLEW_ERROR_GL_VERSION_10_ONLY;

5346

}

5347

else

5348

{

5349

CONST_CAST(GLEW_VERSION_1_1) = GL_TRUE;

5350

if (s[major] >= '2')

5351

{

5352

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

5353

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

5354

CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;

5355

CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE;

5356

CONST_CAST(GLEW_VERSION_2_0) = GL_TRUE;

5357

if (s[minor] >= '1')

5358

{

5359

CONST_CAST(GLEW_VERSION_2_1) = GL_TRUE;

5360

}

5361

}

5362

else

5363

{

5364

if (s[minor] >= '5')

5365

{

5366

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

5367

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

5368

CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;

5369

CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE;

5370

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

5371

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

5372

}

5373

if (s[minor] == '4')

5374

{

5375

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

5376

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

5377

CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;

5378

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

5379

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

5380

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

5381

}

5382

if (s[minor] == '3')

5383

{

5384

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

5385

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

5386

CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;

5387

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

5388

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

5389

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

5390

}

5391

if (s[minor] == '2')

5392

{

5393

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

5394

CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE;

5395

CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;

5396

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

5397

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

5398

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

5399

}

5400

if (s[minor] < '2')

5401

{

5402

CONST_CAST(GLEW_VERSION_1_2) = GL_FALSE;

5403

CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE;

5404

CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;

5405

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

5406

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

5407

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

5408

}

5409

}

5410

}

5411

/* initialize extensions */

5412

#ifdef GL_VERSION_1_2

5413

if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);

5414

#endif /* GL_VERSION_1_2 */

5415

#ifdef GL_VERSION_1_3

5416

if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);

5417

#endif /* GL_VERSION_1_3 */

5418

#ifdef GL_VERSION_1_4

5419

if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);

5420

#endif /* GL_VERSION_1_4 */

5421

#ifdef GL_VERSION_1_5

5422

if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);

5423

#endif /* GL_VERSION_1_5 */

5424

#ifdef GL_VERSION_2_0

5425

if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);

5426

#endif /* GL_VERSION_2_0 */

5427

#ifdef GL_VERSION_2_1

5428

if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT);

5429

#endif /* GL_VERSION_2_1 */

5430

#ifdef GL_3DFX_multisample

5431

CONST_CAST(GLEW_3DFX_multisample) = glewGetExtension("GL_3DFX_multisample");

5432

#endif /* GL_3DFX_multisample */

5433

#ifdef GL_3DFX_tbuffer

5434

CONST_CAST(GLEW_3DFX_tbuffer) = glewGetExtension("GL_3DFX_tbuffer");

5435

if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

5436

#endif /* GL_3DFX_tbuffer */

5437

#ifdef GL_3DFX_texture_compression_FXT1

5438

CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = glewGetExtension("GL_3DFX_texture_compression_FXT1");

5439

#endif /* GL_3DFX_texture_compression_FXT1 */

5440

#ifdef GL_APPLE_client_storage

5441

CONST_CAST(GLEW_APPLE_client_storage) = glewGetExtension("GL_APPLE_client_storage");

5442

#endif /* GL_APPLE_client_storage */

5443

#ifdef GL_APPLE_element_array

5444

CONST_CAST(GLEW_APPLE_element_array) = glewGetExtension("GL_APPLE_element_array");

5445

if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT);

5446

#endif /* GL_APPLE_element_array */

5447

#ifdef GL_APPLE_fence

5448

CONST_CAST(GLEW_APPLE_fence) = glewGetExtension("GL_APPLE_fence");

5449

if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT);

5450

#endif /* GL_APPLE_fence */

5451

#ifdef GL_APPLE_float_pixels

5452

CONST_CAST(GLEW_APPLE_float_pixels) = glewGetExtension("GL_APPLE_float_pixels");

5453

#endif /* GL_APPLE_float_pixels */

5454

#ifdef GL_APPLE_flush_buffer_range

5455

CONST_CAST(GLEW_APPLE_flush_buffer_range) = glewGetExtension("GL_APPLE_flush_buffer_range");

5456

if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);

5457

#endif /* GL_APPLE_flush_buffer_range */

5458

#ifdef GL_APPLE_pixel_buffer

5459

CONST_CAST(GLEW_APPLE_pixel_buffer) = glewGetExtension("GL_APPLE_pixel_buffer");

5460

#endif /* GL_APPLE_pixel_buffer */

5461

#ifdef GL_APPLE_specular_vector

5462

CONST_CAST(GLEW_APPLE_specular_vector) = glewGetExtension("GL_APPLE_specular_vector");

5463

#endif /* GL_APPLE_specular_vector */

5464

#ifdef GL_APPLE_texture_range

5465

CONST_CAST(GLEW_APPLE_texture_range) = glewGetExtension("GL_APPLE_texture_range");

5466

if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT);

5467

#endif /* GL_APPLE_texture_range */

5468

#ifdef GL_APPLE_transform_hint

5469

CONST_CAST(GLEW_APPLE_transform_hint) = glewGetExtension("GL_APPLE_transform_hint");

5470

#endif /* GL_APPLE_transform_hint */

5471

#ifdef GL_APPLE_vertex_array_object

5472

CONST_CAST(GLEW_APPLE_vertex_array_object) = glewGetExtension("GL_APPLE_vertex_array_object");

5473

if (glewExperimental || GLEW_APPLE_vertex_array_object) CONST_CAST(GLEW_APPLE_vertex_array_object) = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

5474

#endif /* GL_APPLE_vertex_array_object */

5475

#ifdef GL_APPLE_vertex_array_range

5476

CONST_CAST(GLEW_APPLE_vertex_array_range) = glewGetExtension("GL_APPLE_vertex_array_range");

5477

if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

5478

#endif /* GL_APPLE_vertex_array_range */

5479

#ifdef GL_APPLE_ycbcr_422

5480

CONST_CAST(GLEW_APPLE_ycbcr_422) = glewGetExtension("GL_APPLE_ycbcr_422");

5481

#endif /* GL_APPLE_ycbcr_422 */

5482

#ifdef GL_ARB_color_buffer_float

5483

CONST_CAST(GLEW_ARB_color_buffer_float) = glewGetExtension("GL_ARB_color_buffer_float");

5484

if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);

5485

#endif /* GL_ARB_color_buffer_float */

5486

#ifdef GL_ARB_depth_texture

5487

CONST_CAST(GLEW_ARB_depth_texture) = glewGetExtension("GL_ARB_depth_texture");

5488

#endif /* GL_ARB_depth_texture */

5489

#ifdef GL_ARB_draw_buffers

5490

CONST_CAST(GLEW_ARB_draw_buffers) = glewGetExtension("GL_ARB_draw_buffers");

5491

if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

5492

#endif /* GL_ARB_draw_buffers */

5493

#ifdef GL_ARB_fragment_program

5494

CONST_CAST(GLEW_ARB_fragment_program) = glewGetExtension("GL_ARB_fragment_program");

5495

#endif /* GL_ARB_fragment_program */

5496

#ifdef GL_ARB_fragment_program_shadow

5497

CONST_CAST(GLEW_ARB_fragment_program_shadow) = glewGetExtension("GL_ARB_fragment_program_shadow");

5498

#endif /* GL_ARB_fragment_program_shadow */

5499

#ifdef GL_ARB_fragment_shader

5500

CONST_CAST(GLEW_ARB_fragment_shader) = glewGetExtension("GL_ARB_fragment_shader");

5501

#endif /* GL_ARB_fragment_shader */

5502

#ifdef GL_ARB_half_float_pixel

5503

CONST_CAST(GLEW_ARB_half_float_pixel) = glewGetExtension("GL_ARB_half_float_pixel");

5504

#endif /* GL_ARB_half_float_pixel */

5505

#ifdef GL_ARB_imaging

5506

CONST_CAST(GLEW_ARB_imaging) = glewGetExtension("GL_ARB_imaging");

5507

if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT);

5508

#endif /* GL_ARB_imaging */

5509

#ifdef GL_ARB_matrix_palette

5510

CONST_CAST(GLEW_ARB_matrix_palette) = glewGetExtension("GL_ARB_matrix_palette");

5511

if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT);

5512

#endif /* GL_ARB_matrix_palette */

5513

#ifdef GL_ARB_multisample

5514

CONST_CAST(GLEW_ARB_multisample) = glewGetExtension("GL_ARB_multisample");

5515

if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

5516

#endif /* GL_ARB_multisample */

5517

#ifdef GL_ARB_multitexture

5518

CONST_CAST(GLEW_ARB_multitexture) = glewGetExtension("GL_ARB_multitexture");

5519

if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);

5520

#endif /* GL_ARB_multitexture */

5521

#ifdef GL_ARB_occlusion_query

5522

CONST_CAST(GLEW_ARB_occlusion_query) = glewGetExtension("GL_ARB_occlusion_query");

5523

if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);

5524

#endif /* GL_ARB_occlusion_query */

5525

#ifdef GL_ARB_pixel_buffer_object

5526

CONST_CAST(GLEW_ARB_pixel_buffer_object) = glewGetExtension("GL_ARB_pixel_buffer_object");

5527

#endif /* GL_ARB_pixel_buffer_object */

5528

#ifdef GL_ARB_point_parameters

5529

CONST_CAST(GLEW_ARB_point_parameters) = glewGetExtension("GL_ARB_point_parameters");

5530

if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

5531

#endif /* GL_ARB_point_parameters */

5532

#ifdef GL_ARB_point_sprite

5533

CONST_CAST(GLEW_ARB_point_sprite) = glewGetExtension("GL_ARB_point_sprite");

5534

#endif /* GL_ARB_point_sprite */

5535

#ifdef GL_ARB_shader_objects

5536

CONST_CAST(GLEW_ARB_shader_objects) = glewGetExtension("GL_ARB_shader_objects");

5537

if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);

5538

#endif /* GL_ARB_shader_objects */

5539

#ifdef GL_ARB_shading_language_100

5540

CONST_CAST(GLEW_ARB_shading_language_100) = glewGetExtension("GL_ARB_shading_language_100");

5541

#endif /* GL_ARB_shading_language_100 */

5542

#ifdef GL_ARB_shadow

5543

CONST_CAST(GLEW_ARB_shadow) = glewGetExtension("GL_ARB_shadow");

5544

#endif /* GL_ARB_shadow */

5545

#ifdef GL_ARB_shadow_ambient

5546

CONST_CAST(GLEW_ARB_shadow_ambient) = glewGetExtension("GL_ARB_shadow_ambient");

5547

#endif /* GL_ARB_shadow_ambient */

5548

#ifdef GL_ARB_texture_border_clamp

5549

CONST_CAST(GLEW_ARB_texture_border_clamp) = glewGetExtension("GL_ARB_texture_border_clamp");

5550

#endif /* GL_ARB_texture_border_clamp */

5551

#ifdef GL_ARB_texture_compression

5552

CONST_CAST(GLEW_ARB_texture_compression) = glewGetExtension("GL_ARB_texture_compression");

5553

if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);

5554

#endif /* GL_ARB_texture_compression */

5555

#ifdef GL_ARB_texture_cube_map

5556

CONST_CAST(GLEW_ARB_texture_cube_map) = glewGetExtension("GL_ARB_texture_cube_map");

5557

#endif /* GL_ARB_texture_cube_map */

5558

#ifdef GL_ARB_texture_env_add

5559

CONST_CAST(GLEW_ARB_texture_env_add) = glewGetExtension("GL_ARB_texture_env_add");

5560

#endif /* GL_ARB_texture_env_add */

5561

#ifdef GL_ARB_texture_env_combine

5562

CONST_CAST(GLEW_ARB_texture_env_combine) = glewGetExtension("GL_ARB_texture_env_combine");

5563

#endif /* GL_ARB_texture_env_combine */

5564

#ifdef GL_ARB_texture_env_crossbar

5565

CONST_CAST(GLEW_ARB_texture_env_crossbar) = glewGetExtension("GL_ARB_texture_env_crossbar");

5566

#endif /* GL_ARB_texture_env_crossbar */

5567

#ifdef GL_ARB_texture_env_dot3

5568

CONST_CAST(GLEW_ARB_texture_env_dot3) = glewGetExtension("GL_ARB_texture_env_dot3");

5569

#endif /* GL_ARB_texture_env_dot3 */

5570

#ifdef GL_ARB_texture_float

5571

CONST_CAST(GLEW_ARB_texture_float) = glewGetExtension("GL_ARB_texture_float");

5572

#endif /* GL_ARB_texture_float */

5573

#ifdef GL_ARB_texture_mirrored_repeat

5574

CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = glewGetExtension("GL_ARB_texture_mirrored_repeat");

5575

#endif /* GL_ARB_texture_mirrored_repeat */

5576

#ifdef GL_ARB_texture_non_power_of_two

5577

CONST_CAST(GLEW_ARB_texture_non_power_of_two) = glewGetExtension("GL_ARB_texture_non_power_of_two");

5578

#endif /* GL_ARB_texture_non_power_of_two */

5579

#ifdef GL_ARB_texture_rectangle

5580

CONST_CAST(GLEW_ARB_texture_rectangle) = glewGetExtension("GL_ARB_texture_rectangle");

5581

#endif /* GL_ARB_texture_rectangle */

5582

#ifdef GL_ARB_transpose_matrix

5583

CONST_CAST(GLEW_ARB_transpose_matrix) = glewGetExtension("GL_ARB_transpose_matrix");

5584

if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT);

5585

#endif /* GL_ARB_transpose_matrix */

5586

#ifdef GL_ARB_vertex_blend

5587

CONST_CAST(GLEW_ARB_vertex_blend) = glewGetExtension("GL_ARB_vertex_blend");

5588

if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT);

5589

#endif /* GL_ARB_vertex_blend */

5590

#ifdef GL_ARB_vertex_buffer_object

5591

CONST_CAST(GLEW_ARB_vertex_buffer_object) = glewGetExtension("GL_ARB_vertex_buffer_object");

5592

if (glewExperimental || GLEW_ARB_vertex_buffer_object) CONST_CAST(GLEW_ARB_vertex_buffer_object) = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

5593

#endif /* GL_ARB_vertex_buffer_object */

5594

#ifdef GL_ARB_vertex_program

5595

CONST_CAST(GLEW_ARB_vertex_program) = glewGetExtension("GL_ARB_vertex_program");

5596

if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);

5597

#endif /* GL_ARB_vertex_program */

5598

#ifdef GL_ARB_vertex_shader

5599

CONST_CAST(GLEW_ARB_vertex_shader) = glewGetExtension("GL_ARB_vertex_shader");

5600

if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);

5601

#endif /* GL_ARB_vertex_shader */

5602

#ifdef GL_ARB_window_pos

5603

CONST_CAST(GLEW_ARB_window_pos) = glewGetExtension("GL_ARB_window_pos");

5604

if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);

5605

#endif /* GL_ARB_window_pos */

5606

#ifdef GL_ATIX_point_sprites

5607

CONST_CAST(GLEW_ATIX_point_sprites) = glewGetExtension("GL_ATIX_point_sprites");

5608

#endif /* GL_ATIX_point_sprites */

5609

#ifdef GL_ATIX_texture_env_combine3

5610

CONST_CAST(GLEW_ATIX_texture_env_combine3) = glewGetExtension("GL_ATIX_texture_env_combine3");

5611

#endif /* GL_ATIX_texture_env_combine3 */

5612

#ifdef GL_ATIX_texture_env_route

5613

CONST_CAST(GLEW_ATIX_texture_env_route) = glewGetExtension("GL_ATIX_texture_env_route");

5614

#endif /* GL_ATIX_texture_env_route */

5615

#ifdef GL_ATIX_vertex_shader_output_point_size

5616

CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = glewGetExtension("GL_ATIX_vertex_shader_output_point_size");

5617

#endif /* GL_ATIX_vertex_shader_output_point_size */

5618

#ifdef GL_ATI_draw_buffers

5619

CONST_CAST(GLEW_ATI_draw_buffers) = glewGetExtension("GL_ATI_draw_buffers");

5620

if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

5621

#endif /* GL_ATI_draw_buffers */

5622

#ifdef GL_ATI_element_array

5623

CONST_CAST(GLEW_ATI_element_array) = glewGetExtension("GL_ATI_element_array");

5624

if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT);

5625

#endif /* GL_ATI_element_array */

5626

#ifdef GL_ATI_envmap_bumpmap

5627

CONST_CAST(GLEW_ATI_envmap_bumpmap) = glewGetExtension("GL_ATI_envmap_bumpmap");

5628

if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT);

5629

#endif /* GL_ATI_envmap_bumpmap */

5630

#ifdef GL_ATI_fragment_shader

5631

CONST_CAST(GLEW_ATI_fragment_shader) = glewGetExtension("GL_ATI_fragment_shader");

5632

if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);

5633

#endif /* GL_ATI_fragment_shader */

5634

#ifdef GL_ATI_map_object_buffer

5635

CONST_CAST(GLEW_ATI_map_object_buffer) = glewGetExtension("GL_ATI_map_object_buffer");

5636

if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

5637

#endif /* GL_ATI_map_object_buffer */

5638

#ifdef GL_ATI_pn_triangles

5639

CONST_CAST(GLEW_ATI_pn_triangles) = glewGetExtension("GL_ATI_pn_triangles");

5640

if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);

5641

#endif /* GL_ATI_pn_triangles */

5642

#ifdef GL_ATI_separate_stencil

5643

CONST_CAST(GLEW_ATI_separate_stencil) = glewGetExtension("GL_ATI_separate_stencil");

5644

if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT);

5645

#endif /* GL_ATI_separate_stencil */

5646

#ifdef GL_ATI_shader_texture_lod

5647

CONST_CAST(GLEW_ATI_shader_texture_lod) = glewGetExtension("GL_ATI_shader_texture_lod");

5648

#endif /* GL_ATI_shader_texture_lod */

5649

#ifdef GL_ATI_text_fragment_shader

5650

CONST_CAST(GLEW_ATI_text_fragment_shader) = glewGetExtension("GL_ATI_text_fragment_shader");

5651

#endif /* GL_ATI_text_fragment_shader */

5652

#ifdef GL_ATI_texture_compression_3dc

5653

CONST_CAST(GLEW_ATI_texture_compression_3dc) = glewGetExtension("GL_ATI_texture_compression_3dc");

5654

#endif /* GL_ATI_texture_compression_3dc */

5655

#ifdef GL_ATI_texture_env_combine3

5656

CONST_CAST(GLEW_ATI_texture_env_combine3) = glewGetExtension("GL_ATI_texture_env_combine3");

5657

#endif /* GL_ATI_texture_env_combine3 */

5658

#ifdef GL_ATI_texture_float

5659

CONST_CAST(GLEW_ATI_texture_float) = glewGetExtension("GL_ATI_texture_float");

5660

#endif /* GL_ATI_texture_float */

5661

#ifdef GL_ATI_texture_mirror_once

5662

CONST_CAST(GLEW_ATI_texture_mirror_once) = glewGetExtension("GL_ATI_texture_mirror_once");

5663

#endif /* GL_ATI_texture_mirror_once */

5664

#ifdef GL_ATI_vertex_array_object

5665

CONST_CAST(GLEW_ATI_vertex_array_object) = glewGetExtension("GL_ATI_vertex_array_object");

5666

if (glewExperimental || GLEW_ATI_vertex_array_object) CONST_CAST(GLEW_ATI_vertex_array_object) = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

5667

#endif /* GL_ATI_vertex_array_object */

5668

#ifdef GL_ATI_vertex_attrib_array_object

5669

CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = glewGetExtension("GL_ATI_vertex_attrib_array_object");

5670

if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

5671

#endif /* GL_ATI_vertex_attrib_array_object */

5672

#ifdef GL_ATI_vertex_streams

5673

CONST_CAST(GLEW_ATI_vertex_streams) = glewGetExtension("GL_ATI_vertex_streams");

5674

if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT);

5675

#endif /* GL_ATI_vertex_streams */

5676

#ifdef GL_EXT_422_pixels

5677

CONST_CAST(GLEW_EXT_422_pixels) = glewGetExtension("GL_EXT_422_pixels");

5678

#endif /* GL_EXT_422_pixels */

5679

#ifdef GL_EXT_Cg_shader

5680

CONST_CAST(GLEW_EXT_Cg_shader) = glewGetExtension("GL_EXT_Cg_shader");

5681

#endif /* GL_EXT_Cg_shader */

5682

#ifdef GL_EXT_abgr

5683

CONST_CAST(GLEW_EXT_abgr) = glewGetExtension("GL_EXT_abgr");

5684

#endif /* GL_EXT_abgr */

5685

#ifdef GL_EXT_bgra

5686

CONST_CAST(GLEW_EXT_bgra) = glewGetExtension("GL_EXT_bgra");

5687

#endif /* GL_EXT_bgra */

5688

#ifdef GL_EXT_bindable_uniform

5689

CONST_CAST(GLEW_EXT_bindable_uniform) = glewGetExtension("GL_EXT_bindable_uniform");

5690

if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT);

5691

#endif /* GL_EXT_bindable_uniform */

5692

#ifdef GL_EXT_blend_color

5693

CONST_CAST(GLEW_EXT_blend_color) = glewGetExtension("GL_EXT_blend_color");

5694

if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT);

5695

#endif /* GL_EXT_blend_color */

5696

#ifdef GL_EXT_blend_equation_separate

5697

CONST_CAST(GLEW_EXT_blend_equation_separate) = glewGetExtension("GL_EXT_blend_equation_separate");

5698

if (glewExperimental || GLEW_EXT_blend_equation_separate) CONST_CAST(GLEW_EXT_blend_equation_separate) = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT);

5699

#endif /* GL_EXT_blend_equation_separate */

5700

#ifdef GL_EXT_blend_func_separate

5701

CONST_CAST(GLEW_EXT_blend_func_separate) = glewGetExtension("GL_EXT_blend_func_separate");

5702

if (glewExperimental || GLEW_EXT_blend_func_separate) CONST_CAST(GLEW_EXT_blend_func_separate) = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT);

5703

#endif /* GL_EXT_blend_func_separate */

5704

#ifdef GL_EXT_blend_logic_op

5705

CONST_CAST(GLEW_EXT_blend_logic_op) = glewGetExtension("GL_EXT_blend_logic_op");

5706

#endif /* GL_EXT_blend_logic_op */

5707

#ifdef GL_EXT_blend_minmax

5708

CONST_CAST(GLEW_EXT_blend_minmax) = glewGetExtension("GL_EXT_blend_minmax");

5709

if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT);

5710

#endif /* GL_EXT_blend_minmax */

5711

#ifdef GL_EXT_blend_subtract

5712

CONST_CAST(GLEW_EXT_blend_subtract) = glewGetExtension("GL_EXT_blend_subtract");

5713

#endif /* GL_EXT_blend_subtract */

5714

#ifdef GL_EXT_clip_volume_hint

5715

CONST_CAST(GLEW_EXT_clip_volume_hint) = glewGetExtension("GL_EXT_clip_volume_hint");

5716

#endif /* GL_EXT_clip_volume_hint */

5717

#ifdef GL_EXT_cmyka

5718

CONST_CAST(GLEW_EXT_cmyka) = glewGetExtension("GL_EXT_cmyka");

5719

#endif /* GL_EXT_cmyka */

5720

#ifdef GL_EXT_color_subtable

5721

CONST_CAST(GLEW_EXT_color_subtable) = glewGetExtension("GL_EXT_color_subtable");

5722

if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT);

5723

#endif /* GL_EXT_color_subtable */

5724

#ifdef GL_EXT_compiled_vertex_array

5725

CONST_CAST(GLEW_EXT_compiled_vertex_array) = glewGetExtension("GL_EXT_compiled_vertex_array");

5726

if (glewExperimental || GLEW_EXT_compiled_vertex_array) CONST_CAST(GLEW_EXT_compiled_vertex_array) = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);

5727

#endif /* GL_EXT_compiled_vertex_array */

5728

#ifdef GL_EXT_convolution

5729

CONST_CAST(GLEW_EXT_convolution) = glewGetExtension("GL_EXT_convolution");

5730

if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT);

5731

#endif /* GL_EXT_convolution */

5732

#ifdef GL_EXT_coordinate_frame

5733

CONST_CAST(GLEW_EXT_coordinate_frame) = glewGetExtension("GL_EXT_coordinate_frame");

5734

if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT);

5735

#endif /* GL_EXT_coordinate_frame */

5736

#ifdef GL_EXT_copy_texture

5737

CONST_CAST(GLEW_EXT_copy_texture) = glewGetExtension("GL_EXT_copy_texture");

5738

if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5739

#endif /* GL_EXT_copy_texture */

5740

#ifdef GL_EXT_cull_vertex

5741

CONST_CAST(GLEW_EXT_cull_vertex) = glewGetExtension("GL_EXT_cull_vertex");

5742

if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT);

5743

#endif /* GL_EXT_cull_vertex */

5744

#ifdef GL_EXT_depth_bounds_test

5745

CONST_CAST(GLEW_EXT_depth_bounds_test) = glewGetExtension("GL_EXT_depth_bounds_test");

5746

if (glewExperimental || GLEW_EXT_depth_bounds_test) CONST_CAST(GLEW_EXT_depth_bounds_test) = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT);

5747

#endif /* GL_EXT_depth_bounds_test */

5748

#ifdef GL_EXT_draw_buffers2

5749

CONST_CAST(GLEW_EXT_draw_buffers2) = glewGetExtension("GL_EXT_draw_buffers2");

5750

if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT);

5751

#endif /* GL_EXT_draw_buffers2 */

5752

#ifdef GL_EXT_draw_instanced

5753

CONST_CAST(GLEW_EXT_draw_instanced) = glewGetExtension("GL_EXT_draw_instanced");

5754

if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);

5755

#endif /* GL_EXT_draw_instanced */

5756

#ifdef GL_EXT_draw_range_elements

5757

CONST_CAST(GLEW_EXT_draw_range_elements) = glewGetExtension("GL_EXT_draw_range_elements");

5758

if (glewExperimental || GLEW_EXT_draw_range_elements) CONST_CAST(GLEW_EXT_draw_range_elements) = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT);

5759

#endif /* GL_EXT_draw_range_elements */

5760

#ifdef GL_EXT_fog_coord

5761

CONST_CAST(GLEW_EXT_fog_coord) = glewGetExtension("GL_EXT_fog_coord");

5762

if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT);

5763

#endif /* GL_EXT_fog_coord */

5764

#ifdef GL_EXT_fragment_lighting

5765

CONST_CAST(GLEW_EXT_fragment_lighting) = glewGetExtension("GL_EXT_fragment_lighting");

5766

if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT);

5767

#endif /* GL_EXT_fragment_lighting */

5768

#ifdef GL_EXT_framebuffer_blit

5769

CONST_CAST(GLEW_EXT_framebuffer_blit) = glewGetExtension("GL_EXT_framebuffer_blit");

5770

if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT);

5771

#endif /* GL_EXT_framebuffer_blit */

5772

#ifdef GL_EXT_framebuffer_multisample

5773

CONST_CAST(GLEW_EXT_framebuffer_multisample) = glewGetExtension("GL_EXT_framebuffer_multisample");

5774

if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

5775

#endif /* GL_EXT_framebuffer_multisample */

5776

#ifdef GL_EXT_framebuffer_object

5777

CONST_CAST(GLEW_EXT_framebuffer_object) = glewGetExtension("GL_EXT_framebuffer_object");

5778

if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

5779

#endif /* GL_EXT_framebuffer_object */

5780

#ifdef GL_EXT_framebuffer_sRGB

5781

CONST_CAST(GLEW_EXT_framebuffer_sRGB) = glewGetExtension("GL_EXT_framebuffer_sRGB");

5782

#endif /* GL_EXT_framebuffer_sRGB */

5783

#ifdef GL_EXT_geometry_shader4

5784

CONST_CAST(GLEW_EXT_geometry_shader4) = glewGetExtension("GL_EXT_geometry_shader4");

5785

if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);

5786

#endif /* GL_EXT_geometry_shader4 */

5787

#ifdef GL_EXT_gpu_program_parameters

5788

CONST_CAST(GLEW_EXT_gpu_program_parameters) = glewGetExtension("GL_EXT_gpu_program_parameters");

5789

if (glewExperimental || GLEW_EXT_gpu_program_parameters) CONST_CAST(GLEW_EXT_gpu_program_parameters) = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

5790

#endif /* GL_EXT_gpu_program_parameters */

5791

#ifdef GL_EXT_gpu_shader4

5792

CONST_CAST(GLEW_EXT_gpu_shader4) = glewGetExtension("GL_EXT_gpu_shader4");

5793

if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT);

5794

#endif /* GL_EXT_gpu_shader4 */

5795

#ifdef GL_EXT_histogram

5796

CONST_CAST(GLEW_EXT_histogram) = glewGetExtension("GL_EXT_histogram");

5797

if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT);

5798

#endif /* GL_EXT_histogram */

5799

#ifdef GL_EXT_index_array_formats

5800

CONST_CAST(GLEW_EXT_index_array_formats) = glewGetExtension("GL_EXT_index_array_formats");

5801

#endif /* GL_EXT_index_array_formats */

5802

#ifdef GL_EXT_index_func

5803

CONST_CAST(GLEW_EXT_index_func) = glewGetExtension("GL_EXT_index_func");

5804

if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT);

5805

#endif /* GL_EXT_index_func */

5806

#ifdef GL_EXT_index_material

5807

CONST_CAST(GLEW_EXT_index_material) = glewGetExtension("GL_EXT_index_material");

5808

if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT);

5809

#endif /* GL_EXT_index_material */

5810

#ifdef GL_EXT_index_texture

5811

CONST_CAST(GLEW_EXT_index_texture) = glewGetExtension("GL_EXT_index_texture");

5812

#endif /* GL_EXT_index_texture */

5813

#ifdef GL_EXT_light_texture

5814

CONST_CAST(GLEW_EXT_light_texture) = glewGetExtension("GL_EXT_light_texture");

5815

if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5816

#endif /* GL_EXT_light_texture */

5817

#ifdef GL_EXT_misc_attribute

5818

CONST_CAST(GLEW_EXT_misc_attribute) = glewGetExtension("GL_EXT_misc_attribute");

5819

#endif /* GL_EXT_misc_attribute */

5820

#ifdef GL_EXT_multi_draw_arrays

5821

CONST_CAST(GLEW_EXT_multi_draw_arrays) = glewGetExtension("GL_EXT_multi_draw_arrays");

5822

if (glewExperimental || GLEW_EXT_multi_draw_arrays) CONST_CAST(GLEW_EXT_multi_draw_arrays) = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

5823

#endif /* GL_EXT_multi_draw_arrays */

5824

#ifdef GL_EXT_multisample

5825

CONST_CAST(GLEW_EXT_multisample) = glewGetExtension("GL_EXT_multisample");

5826

if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

5827

#endif /* GL_EXT_multisample */

5828

#ifdef GL_EXT_packed_depth_stencil

5829

CONST_CAST(GLEW_EXT_packed_depth_stencil) = glewGetExtension("GL_EXT_packed_depth_stencil");

5830

#endif /* GL_EXT_packed_depth_stencil */

5831

#ifdef GL_EXT_packed_float

5832

CONST_CAST(GLEW_EXT_packed_float) = glewGetExtension("GL_EXT_packed_float");

5833

#endif /* GL_EXT_packed_float */

5834

#ifdef GL_EXT_packed_pixels

5835

CONST_CAST(GLEW_EXT_packed_pixels) = glewGetExtension("GL_EXT_packed_pixels");

5836

#endif /* GL_EXT_packed_pixels */

5837

#ifdef GL_EXT_paletted_texture

5838

CONST_CAST(GLEW_EXT_paletted_texture) = glewGetExtension("GL_EXT_paletted_texture");

5839

if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5840

#endif /* GL_EXT_paletted_texture */

5841

#ifdef GL_EXT_pixel_buffer_object

5842

CONST_CAST(GLEW_EXT_pixel_buffer_object) = glewGetExtension("GL_EXT_pixel_buffer_object");

5843

#endif /* GL_EXT_pixel_buffer_object */

5844

#ifdef GL_EXT_pixel_transform

5845

CONST_CAST(GLEW_EXT_pixel_transform) = glewGetExtension("GL_EXT_pixel_transform");

5846

if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT);

5847

#endif /* GL_EXT_pixel_transform */

5848

#ifdef GL_EXT_pixel_transform_color_table

5849

CONST_CAST(GLEW_EXT_pixel_transform_color_table) = glewGetExtension("GL_EXT_pixel_transform_color_table");

5850

#endif /* GL_EXT_pixel_transform_color_table */

5851

#ifdef GL_EXT_point_parameters

5852

CONST_CAST(GLEW_EXT_point_parameters) = glewGetExtension("GL_EXT_point_parameters");

5853

if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

5854

#endif /* GL_EXT_point_parameters */

5855

#ifdef GL_EXT_polygon_offset

5856

CONST_CAST(GLEW_EXT_polygon_offset) = glewGetExtension("GL_EXT_polygon_offset");

5857

if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);

5858

#endif /* GL_EXT_polygon_offset */

5859

#ifdef GL_EXT_rescale_normal

5860

CONST_CAST(GLEW_EXT_rescale_normal) = glewGetExtension("GL_EXT_rescale_normal");

5861

#endif /* GL_EXT_rescale_normal */

5862

#ifdef GL_EXT_scene_marker

5863

CONST_CAST(GLEW_EXT_scene_marker) = glewGetExtension("GL_EXT_scene_marker");

5864

if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT);

5865

#endif /* GL_EXT_scene_marker */

5866

#ifdef GL_EXT_secondary_color

5867

CONST_CAST(GLEW_EXT_secondary_color) = glewGetExtension("GL_EXT_secondary_color");

5868

if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);

5869

#endif /* GL_EXT_secondary_color */

5870

#ifdef GL_EXT_separate_specular_color

5871

CONST_CAST(GLEW_EXT_separate_specular_color) = glewGetExtension("GL_EXT_separate_specular_color");

5872

#endif /* GL_EXT_separate_specular_color */

5873

#ifdef GL_EXT_shadow_funcs

5874

CONST_CAST(GLEW_EXT_shadow_funcs) = glewGetExtension("GL_EXT_shadow_funcs");

5875

#endif /* GL_EXT_shadow_funcs */

5876

#ifdef GL_EXT_shared_texture_palette

5877

CONST_CAST(GLEW_EXT_shared_texture_palette) = glewGetExtension("GL_EXT_shared_texture_palette");

5878

#endif /* GL_EXT_shared_texture_palette */

5879

#ifdef GL_EXT_stencil_clear_tag

5880

CONST_CAST(GLEW_EXT_stencil_clear_tag) = glewGetExtension("GL_EXT_stencil_clear_tag");

5881

#endif /* GL_EXT_stencil_clear_tag */

5882

#ifdef GL_EXT_stencil_two_side

5883

CONST_CAST(GLEW_EXT_stencil_two_side) = glewGetExtension("GL_EXT_stencil_two_side");

5884

if (glewExperimental || GLEW_EXT_stencil_two_side) CONST_CAST(GLEW_EXT_stencil_two_side) = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT);

5885

#endif /* GL_EXT_stencil_two_side */

5886

#ifdef GL_EXT_stencil_wrap

5887

CONST_CAST(GLEW_EXT_stencil_wrap) = glewGetExtension("GL_EXT_stencil_wrap");

5888

#endif /* GL_EXT_stencil_wrap */

5889

#ifdef GL_EXT_subtexture

5890

CONST_CAST(GLEW_EXT_subtexture) = glewGetExtension("GL_EXT_subtexture");

5891

if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT);

5892

#endif /* GL_EXT_subtexture */

5893

#ifdef GL_EXT_texture

5894

CONST_CAST(GLEW_EXT_texture) = glewGetExtension("GL_EXT_texture");

5895

#endif /* GL_EXT_texture */

5896

#ifdef GL_EXT_texture3D

5897

CONST_CAST(GLEW_EXT_texture3D) = glewGetExtension("GL_EXT_texture3D");

5898

if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT);

5899

#endif /* GL_EXT_texture3D */

5900

#ifdef GL_EXT_texture_array

5901

CONST_CAST(GLEW_EXT_texture_array) = glewGetExtension("GL_EXT_texture_array");

5902

#endif /* GL_EXT_texture_array */

5903

#ifdef GL_EXT_texture_buffer_object

5904

CONST_CAST(GLEW_EXT_texture_buffer_object) = glewGetExtension("GL_EXT_texture_buffer_object");

5905

if (glewExperimental || GLEW_EXT_texture_buffer_object) CONST_CAST(GLEW_EXT_texture_buffer_object) = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

5906

#endif /* GL_EXT_texture_buffer_object */

5907

#ifdef GL_EXT_texture_compression_dxt1

5908

CONST_CAST(GLEW_EXT_texture_compression_dxt1) = glewGetExtension("GL_EXT_texture_compression_dxt1");

5909

#endif /* GL_EXT_texture_compression_dxt1 */

5910

#ifdef GL_EXT_texture_compression_latc

5911

CONST_CAST(GLEW_EXT_texture_compression_latc) = glewGetExtension("GL_EXT_texture_compression_latc");

5912

#endif /* GL_EXT_texture_compression_latc */

5913

#ifdef GL_EXT_texture_compression_rgtc

5914

CONST_CAST(GLEW_EXT_texture_compression_rgtc) = glewGetExtension("GL_EXT_texture_compression_rgtc");

5915

#endif /* GL_EXT_texture_compression_rgtc */

5916

#ifdef GL_EXT_texture_compression_s3tc

5917

CONST_CAST(GLEW_EXT_texture_compression_s3tc) = glewGetExtension("GL_EXT_texture_compression_s3tc");

5918

#endif /* GL_EXT_texture_compression_s3tc */

5919

#ifdef GL_EXT_texture_cube_map

5920

CONST_CAST(GLEW_EXT_texture_cube_map) = glewGetExtension("GL_EXT_texture_cube_map");

5921

#endif /* GL_EXT_texture_cube_map */

5922

#ifdef GL_EXT_texture_edge_clamp

5923

CONST_CAST(GLEW_EXT_texture_edge_clamp) = glewGetExtension("GL_EXT_texture_edge_clamp");

5924

#endif /* GL_EXT_texture_edge_clamp */

5925

#ifdef GL_EXT_texture_env

5926

CONST_CAST(GLEW_EXT_texture_env) = glewGetExtension("GL_EXT_texture_env");

5927

#endif /* GL_EXT_texture_env */

5928

#ifdef GL_EXT_texture_env_add

5929

CONST_CAST(GLEW_EXT_texture_env_add) = glewGetExtension("GL_EXT_texture_env_add");

5930

#endif /* GL_EXT_texture_env_add */

5931

#ifdef GL_EXT_texture_env_combine

5932

CONST_CAST(GLEW_EXT_texture_env_combine) = glewGetExtension("GL_EXT_texture_env_combine");

5933

#endif /* GL_EXT_texture_env_combine */

5934

#ifdef GL_EXT_texture_env_dot3

5935

CONST_CAST(GLEW_EXT_texture_env_dot3) = glewGetExtension("GL_EXT_texture_env_dot3");

5936

#endif /* GL_EXT_texture_env_dot3 */

5937

#ifdef GL_EXT_texture_filter_anisotropic

5938

CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = glewGetExtension("GL_EXT_texture_filter_anisotropic");

5939

#endif /* GL_EXT_texture_filter_anisotropic */

5940

#ifdef GL_EXT_texture_integer

5941

CONST_CAST(GLEW_EXT_texture_integer) = glewGetExtension("GL_EXT_texture_integer");

5942

if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT);

5943

#endif /* GL_EXT_texture_integer */

5944

#ifdef GL_EXT_texture_lod_bias

5945

CONST_CAST(GLEW_EXT_texture_lod_bias) = glewGetExtension("GL_EXT_texture_lod_bias");

5946

#endif /* GL_EXT_texture_lod_bias */

5947

#ifdef GL_EXT_texture_mirror_clamp

5948

CONST_CAST(GLEW_EXT_texture_mirror_clamp) = glewGetExtension("GL_EXT_texture_mirror_clamp");

5949

#endif /* GL_EXT_texture_mirror_clamp */

5950

#ifdef GL_EXT_texture_object

5951

CONST_CAST(GLEW_EXT_texture_object) = glewGetExtension("GL_EXT_texture_object");

5952

if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT);

5953

#endif /* GL_EXT_texture_object */

5954

#ifdef GL_EXT_texture_perturb_normal

5955

CONST_CAST(GLEW_EXT_texture_perturb_normal) = glewGetExtension("GL_EXT_texture_perturb_normal");

5956

if (glewExperimental || GLEW_EXT_texture_perturb_normal) CONST_CAST(GLEW_EXT_texture_perturb_normal) = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT);

5957

#endif /* GL_EXT_texture_perturb_normal */

5958

#ifdef GL_EXT_texture_rectangle

5959

CONST_CAST(GLEW_EXT_texture_rectangle) = glewGetExtension("GL_EXT_texture_rectangle");

5960

#endif /* GL_EXT_texture_rectangle */

5961

#ifdef GL_EXT_texture_sRGB

5962

CONST_CAST(GLEW_EXT_texture_sRGB) = glewGetExtension("GL_EXT_texture_sRGB");

5963

#endif /* GL_EXT_texture_sRGB */

5964

#ifdef GL_EXT_texture_shared_exponent

5965

CONST_CAST(GLEW_EXT_texture_shared_exponent) = glewGetExtension("GL_EXT_texture_shared_exponent");

5966

#endif /* GL_EXT_texture_shared_exponent */

5967

#ifdef GL_EXT_timer_query

5968

CONST_CAST(GLEW_EXT_timer_query) = glewGetExtension("GL_EXT_timer_query");

5969

if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);

5970

#endif /* GL_EXT_timer_query */

5971

#ifdef GL_EXT_vertex_array

5972

CONST_CAST(GLEW_EXT_vertex_array) = glewGetExtension("GL_EXT_vertex_array");

5973

if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);

5974

#endif /* GL_EXT_vertex_array */

5975

#ifdef GL_EXT_vertex_shader

5976

CONST_CAST(GLEW_EXT_vertex_shader) = glewGetExtension("GL_EXT_vertex_shader");

5977

if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);

5978

#endif /* GL_EXT_vertex_shader */

5979

#ifdef GL_EXT_vertex_weighting

5980

CONST_CAST(GLEW_EXT_vertex_weighting) = glewGetExtension("GL_EXT_vertex_weighting");

5981

if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT);

5982

#endif /* GL_EXT_vertex_weighting */

5983

#ifdef GL_GREMEDY_frame_terminator

5984

CONST_CAST(GLEW_GREMEDY_frame_terminator) = glewGetExtension("GL_GREMEDY_frame_terminator");

5985

if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT);

5986

#endif /* GL_GREMEDY_frame_terminator */

5987

#ifdef GL_GREMEDY_string_marker

5988

CONST_CAST(GLEW_GREMEDY_string_marker) = glewGetExtension("GL_GREMEDY_string_marker");

5989

if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT);

5990

#endif /* GL_GREMEDY_string_marker */

5991

#ifdef GL_HP_convolution_border_modes

5992

CONST_CAST(GLEW_HP_convolution_border_modes) = glewGetExtension("GL_HP_convolution_border_modes");

5993

#endif /* GL_HP_convolution_border_modes */

5994

#ifdef GL_HP_image_transform

5995

CONST_CAST(GLEW_HP_image_transform) = glewGetExtension("GL_HP_image_transform");

5996

if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT);

5997

#endif /* GL_HP_image_transform */

5998

#ifdef GL_HP_occlusion_test

5999

CONST_CAST(GLEW_HP_occlusion_test) = glewGetExtension("GL_HP_occlusion_test");

6000

#endif /* GL_HP_occlusion_test */

6001

#ifdef GL_HP_texture_lighting

6002

CONST_CAST(GLEW_HP_texture_lighting) = glewGetExtension("GL_HP_texture_lighting");

6003

#endif /* GL_HP_texture_lighting */

6004

#ifdef GL_IBM_cull_vertex

6005

CONST_CAST(GLEW_IBM_cull_vertex) = glewGetExtension("GL_IBM_cull_vertex");

6006

#endif /* GL_IBM_cull_vertex */

6007

#ifdef GL_IBM_multimode_draw_arrays

6008

CONST_CAST(GLEW_IBM_multimode_draw_arrays) = glewGetExtension("GL_IBM_multimode_draw_arrays");

6009

if (glewExperimental || GLEW_IBM_multimode_draw_arrays) CONST_CAST(GLEW_IBM_multimode_draw_arrays) = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

6010

#endif /* GL_IBM_multimode_draw_arrays */

6011

#ifdef GL_IBM_rasterpos_clip

6012

CONST_CAST(GLEW_IBM_rasterpos_clip) = glewGetExtension("GL_IBM_rasterpos_clip");

6013

#endif /* GL_IBM_rasterpos_clip */

6014

#ifdef GL_IBM_static_data

6015

CONST_CAST(GLEW_IBM_static_data) = glewGetExtension("GL_IBM_static_data");

6016

#endif /* GL_IBM_static_data */

6017

#ifdef GL_IBM_texture_mirrored_repeat

6018

CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = glewGetExtension("GL_IBM_texture_mirrored_repeat");

6019

#endif /* GL_IBM_texture_mirrored_repeat */

6020

#ifdef GL_IBM_vertex_array_lists

6021

CONST_CAST(GLEW_IBM_vertex_array_lists) = glewGetExtension("GL_IBM_vertex_array_lists");

6022

if (glewExperimental || GLEW_IBM_vertex_array_lists) CONST_CAST(GLEW_IBM_vertex_array_lists) = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT);

6023

#endif /* GL_IBM_vertex_array_lists */

6024

#ifdef GL_INGR_color_clamp

6025

CONST_CAST(GLEW_INGR_color_clamp) = glewGetExtension("GL_INGR_color_clamp");

6026

#endif /* GL_INGR_color_clamp */

6027

#ifdef GL_INGR_interlace_read

6028

CONST_CAST(GLEW_INGR_interlace_read) = glewGetExtension("GL_INGR_interlace_read");

6029

#endif /* GL_INGR_interlace_read */

6030

#ifdef GL_INTEL_parallel_arrays

6031

CONST_CAST(GLEW_INTEL_parallel_arrays) = glewGetExtension("GL_INTEL_parallel_arrays");

6032

if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

6033

#endif /* GL_INTEL_parallel_arrays */

6034

#ifdef GL_INTEL_texture_scissor

6035

CONST_CAST(GLEW_INTEL_texture_scissor) = glewGetExtension("GL_INTEL_texture_scissor");

6036

if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT);

6037

#endif /* GL_INTEL_texture_scissor */

6038

#ifdef GL_KTX_buffer_region

6039

CONST_CAST(GLEW_KTX_buffer_region) = glewGetExtension("GL_KTX_buffer_region");

6040

if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);

6041

#endif /* GL_KTX_buffer_region */

6042

#ifdef GL_MESAX_texture_stack

6043

CONST_CAST(GLEW_MESAX_texture_stack) = glewGetExtension("GL_MESAX_texture_stack");

6044

#endif /* GL_MESAX_texture_stack */

6045

#ifdef GL_MESA_pack_invert

6046

CONST_CAST(GLEW_MESA_pack_invert) = glewGetExtension("GL_MESA_pack_invert");

6047

#endif /* GL_MESA_pack_invert */

6048

#ifdef GL_MESA_resize_buffers

6049

CONST_CAST(GLEW_MESA_resize_buffers) = glewGetExtension("GL_MESA_resize_buffers");

6050

if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

6051

#endif /* GL_MESA_resize_buffers */

6052

#ifdef GL_MESA_window_pos

6053

CONST_CAST(GLEW_MESA_window_pos) = glewGetExtension("GL_MESA_window_pos");

6054

if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);

6055

#endif /* GL_MESA_window_pos */

6056

#ifdef GL_MESA_ycbcr_texture

6057

CONST_CAST(GLEW_MESA_ycbcr_texture) = glewGetExtension("GL_MESA_ycbcr_texture");

6058

#endif /* GL_MESA_ycbcr_texture */

6059

#ifdef GL_NV_blend_square

6060

CONST_CAST(GLEW_NV_blend_square) = glewGetExtension("GL_NV_blend_square");

6061

#endif /* GL_NV_blend_square */

6062

#ifdef GL_NV_copy_depth_to_color

6063

CONST_CAST(GLEW_NV_copy_depth_to_color) = glewGetExtension("GL_NV_copy_depth_to_color");

6064

#endif /* GL_NV_copy_depth_to_color */

6065

#ifdef GL_NV_depth_buffer_float

6066

CONST_CAST(GLEW_NV_depth_buffer_float) = glewGetExtension("GL_NV_depth_buffer_float");

6067

if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);

6068

#endif /* GL_NV_depth_buffer_float */

6069

#ifdef GL_NV_depth_clamp

6070

CONST_CAST(GLEW_NV_depth_clamp) = glewGetExtension("GL_NV_depth_clamp");

6071

#endif /* GL_NV_depth_clamp */

6072

#ifdef GL_NV_depth_range_unclamped

6073

CONST_CAST(GLEW_NV_depth_range_unclamped) = glewGetExtension("GL_NV_depth_range_unclamped");

6074

#endif /* GL_NV_depth_range_unclamped */

6075

#ifdef GL_NV_evaluators

6076

CONST_CAST(GLEW_NV_evaluators) = glewGetExtension("GL_NV_evaluators");

6077

if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);

6078

#endif /* GL_NV_evaluators */

6079

#ifdef GL_NV_fence

6080

CONST_CAST(GLEW_NV_fence) = glewGetExtension("GL_NV_fence");

6081

if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT);

6082

#endif /* GL_NV_fence */

6083

#ifdef GL_NV_float_buffer

6084

CONST_CAST(GLEW_NV_float_buffer) = glewGetExtension("GL_NV_float_buffer");

6085

#endif /* GL_NV_float_buffer */

6086

#ifdef GL_NV_fog_distance

6087

CONST_CAST(GLEW_NV_fog_distance) = glewGetExtension("GL_NV_fog_distance");

6088

#endif /* GL_NV_fog_distance */

6089

#ifdef GL_NV_fragment_program

6090

CONST_CAST(GLEW_NV_fragment_program) = glewGetExtension("GL_NV_fragment_program");

6091

if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);

6092

#endif /* GL_NV_fragment_program */

6093

#ifdef GL_NV_fragment_program2

6094

CONST_CAST(GLEW_NV_fragment_program2) = glewGetExtension("GL_NV_fragment_program2");

6095

#endif /* GL_NV_fragment_program2 */

6096

#ifdef GL_NV_fragment_program4

6097

CONST_CAST(GLEW_NV_fragment_program4) = glewGetExtension("GL_NV_fragment_program4");

6098

#endif /* GL_NV_fragment_program4 */

6099

#ifdef GL_NV_fragment_program_option

6100

CONST_CAST(GLEW_NV_fragment_program_option) = glewGetExtension("GL_NV_fragment_program_option");

6101

#endif /* GL_NV_fragment_program_option */

6102

#ifdef GL_NV_framebuffer_multisample_coverage

6103

CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = glewGetExtension("GL_NV_framebuffer_multisample_coverage");

6104

if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT);

6105

#endif /* GL_NV_framebuffer_multisample_coverage */

6106

#ifdef GL_NV_geometry_program4

6107

CONST_CAST(GLEW_NV_geometry_program4) = glewGetExtension("GL_NV_geometry_program4");

6108

if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT);

6109

#endif /* GL_NV_geometry_program4 */

6110

#ifdef GL_NV_geometry_shader4

6111

CONST_CAST(GLEW_NV_geometry_shader4) = glewGetExtension("GL_NV_geometry_shader4");

6112

#endif /* GL_NV_geometry_shader4 */

6113

#ifdef GL_NV_gpu_program4

6114

CONST_CAST(GLEW_NV_gpu_program4) = glewGetExtension("GL_NV_gpu_program4");

6115

if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT);

6116

#endif /* GL_NV_gpu_program4 */

6117

#ifdef GL_NV_half_float

6118

CONST_CAST(GLEW_NV_half_float) = glewGetExtension("GL_NV_half_float");

6119

if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);

6120

#endif /* GL_NV_half_float */

6121

#ifdef GL_NV_light_max_exponent

6122

CONST_CAST(GLEW_NV_light_max_exponent) = glewGetExtension("GL_NV_light_max_exponent");

6123

#endif /* GL_NV_light_max_exponent */

6124

#ifdef GL_NV_multisample_filter_hint

6125

CONST_CAST(GLEW_NV_multisample_filter_hint) = glewGetExtension("GL_NV_multisample_filter_hint");

6126

#endif /* GL_NV_multisample_filter_hint */

6127

#ifdef GL_NV_occlusion_query

6128

CONST_CAST(GLEW_NV_occlusion_query) = glewGetExtension("GL_NV_occlusion_query");

6129

if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);

6130

#endif /* GL_NV_occlusion_query */

6131

#ifdef GL_NV_packed_depth_stencil

6132

CONST_CAST(GLEW_NV_packed_depth_stencil) = glewGetExtension("GL_NV_packed_depth_stencil");

6133

#endif /* GL_NV_packed_depth_stencil */

6134

#ifdef GL_NV_parameter_buffer_object

6135

CONST_CAST(GLEW_NV_parameter_buffer_object) = glewGetExtension("GL_NV_parameter_buffer_object");

6136

if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

6137

#endif /* GL_NV_parameter_buffer_object */

6138

#ifdef GL_NV_pixel_data_range

6139

CONST_CAST(GLEW_NV_pixel_data_range) = glewGetExtension("GL_NV_pixel_data_range");

6140

if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT);

6141

#endif /* GL_NV_pixel_data_range */

6142

#ifdef GL_NV_point_sprite

6143

CONST_CAST(GLEW_NV_point_sprite) = glewGetExtension("GL_NV_point_sprite");

6144

if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT);

6145

#endif /* GL_NV_point_sprite */

6146

#ifdef GL_NV_primitive_restart

6147

CONST_CAST(GLEW_NV_primitive_restart) = glewGetExtension("GL_NV_primitive_restart");

6148

if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT);

6149

#endif /* GL_NV_primitive_restart */

6150

#ifdef GL_NV_register_combiners

6151

CONST_CAST(GLEW_NV_register_combiners) = glewGetExtension("GL_NV_register_combiners");

6152

if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);

6153

#endif /* GL_NV_register_combiners */

6154

#ifdef GL_NV_register_combiners2

6155

CONST_CAST(GLEW_NV_register_combiners2) = glewGetExtension("GL_NV_register_combiners2");

6156

if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);

6157

#endif /* GL_NV_register_combiners2 */

6158

#ifdef GL_NV_texgen_emboss

6159

CONST_CAST(GLEW_NV_texgen_emboss) = glewGetExtension("GL_NV_texgen_emboss");

6160

#endif /* GL_NV_texgen_emboss */

6161

#ifdef GL_NV_texgen_reflection

6162

CONST_CAST(GLEW_NV_texgen_reflection) = glewGetExtension("GL_NV_texgen_reflection");

6163

#endif /* GL_NV_texgen_reflection */

6164

#ifdef GL_NV_texture_compression_vtc

6165

CONST_CAST(GLEW_NV_texture_compression_vtc) = glewGetExtension("GL_NV_texture_compression_vtc");

6166

#endif /* GL_NV_texture_compression_vtc */

6167

#ifdef GL_NV_texture_env_combine4

6168

CONST_CAST(GLEW_NV_texture_env_combine4) = glewGetExtension("GL_NV_texture_env_combine4");

6169

#endif /* GL_NV_texture_env_combine4 */

6170

#ifdef GL_NV_texture_expand_normal

6171

CONST_CAST(GLEW_NV_texture_expand_normal) = glewGetExtension("GL_NV_texture_expand_normal");

6172

#endif /* GL_NV_texture_expand_normal */

6173

#ifdef GL_NV_texture_rectangle

6174

CONST_CAST(GLEW_NV_texture_rectangle) = glewGetExtension("GL_NV_texture_rectangle");

6175

#endif /* GL_NV_texture_rectangle */

6176

#ifdef GL_NV_texture_shader

6177

CONST_CAST(GLEW_NV_texture_shader) = glewGetExtension("GL_NV_texture_shader");

6178

#endif /* GL_NV_texture_shader */

6179

#ifdef GL_NV_texture_shader2

6180

CONST_CAST(GLEW_NV_texture_shader2) = glewGetExtension("GL_NV_texture_shader2");

6181

#endif /* GL_NV_texture_shader2 */

6182

#ifdef GL_NV_texture_shader3

6183

CONST_CAST(GLEW_NV_texture_shader3) = glewGetExtension("GL_NV_texture_shader3");

6184

#endif /* GL_NV_texture_shader3 */

6185

#ifdef GL_NV_transform_feedback

6186

CONST_CAST(GLEW_NV_transform_feedback) = glewGetExtension("GL_NV_transform_feedback");

6187

if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);

6188

#endif /* GL_NV_transform_feedback */

6189

#ifdef GL_NV_vertex_array_range

6190

CONST_CAST(GLEW_NV_vertex_array_range) = glewGetExtension("GL_NV_vertex_array_range");

6191

if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

6192

#endif /* GL_NV_vertex_array_range */

6193

#ifdef GL_NV_vertex_array_range2

6194

CONST_CAST(GLEW_NV_vertex_array_range2) = glewGetExtension("GL_NV_vertex_array_range2");

6195

#endif /* GL_NV_vertex_array_range2 */

6196

#ifdef GL_NV_vertex_program

6197

CONST_CAST(GLEW_NV_vertex_program) = glewGetExtension("GL_NV_vertex_program");

6198

if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);

6199

#endif /* GL_NV_vertex_program */

6200

#ifdef GL_NV_vertex_program1_1

6201

CONST_CAST(GLEW_NV_vertex_program1_1) = glewGetExtension("GL_NV_vertex_program1_1");

6202

#endif /* GL_NV_vertex_program1_1 */

6203

#ifdef GL_NV_vertex_program2

6204

CONST_CAST(GLEW_NV_vertex_program2) = glewGetExtension("GL_NV_vertex_program2");

6205

#endif /* GL_NV_vertex_program2 */

6206

#ifdef GL_NV_vertex_program2_option

6207

CONST_CAST(GLEW_NV_vertex_program2_option) = glewGetExtension("GL_NV_vertex_program2_option");

6208

#endif /* GL_NV_vertex_program2_option */

6209

#ifdef GL_NV_vertex_program3

6210

CONST_CAST(GLEW_NV_vertex_program3) = glewGetExtension("GL_NV_vertex_program3");

6211

#endif /* GL_NV_vertex_program3 */

6212

#ifdef GL_NV_vertex_program4

6213

CONST_CAST(GLEW_NV_vertex_program4) = glewGetExtension("GL_NV_vertex_program4");

6214

#endif /* GL_NV_vertex_program4 */

6215

#ifdef GL_OES_byte_coordinates

6216

CONST_CAST(GLEW_OES_byte_coordinates) = glewGetExtension("GL_OES_byte_coordinates");

6217

#endif /* GL_OES_byte_coordinates */

6218

#ifdef GL_OES_compressed_paletted_texture

6219

CONST_CAST(GLEW_OES_compressed_paletted_texture) = glewGetExtension("GL_OES_compressed_paletted_texture");

6220

#endif /* GL_OES_compressed_paletted_texture */

6221

#ifdef GL_OES_read_format

6222

CONST_CAST(GLEW_OES_read_format) = glewGetExtension("GL_OES_read_format");

6223

#endif /* GL_OES_read_format */

6224

#ifdef GL_OES_single_precision

6225

CONST_CAST(GLEW_OES_single_precision) = glewGetExtension("GL_OES_single_precision");

6226

if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT);

6227

#endif /* GL_OES_single_precision */

6228

#ifdef GL_OML_interlace

6229

CONST_CAST(GLEW_OML_interlace) = glewGetExtension("GL_OML_interlace");

6230

#endif /* GL_OML_interlace */

6231

#ifdef GL_OML_resample

6232

CONST_CAST(GLEW_OML_resample) = glewGetExtension("GL_OML_resample");

6233

#endif /* GL_OML_resample */

6234

#ifdef GL_OML_subsample

6235

CONST_CAST(GLEW_OML_subsample) = glewGetExtension("GL_OML_subsample");

6236

#endif /* GL_OML_subsample */

6237

#ifdef GL_PGI_misc_hints

6238

CONST_CAST(GLEW_PGI_misc_hints) = glewGetExtension("GL_PGI_misc_hints");

6239

#endif /* GL_PGI_misc_hints */

6240

#ifdef GL_PGI_vertex_hints

6241

CONST_CAST(GLEW_PGI_vertex_hints) = glewGetExtension("GL_PGI_vertex_hints");

6242

#endif /* GL_PGI_vertex_hints */

6243

#ifdef GL_REND_screen_coordinates

6244

CONST_CAST(GLEW_REND_screen_coordinates) = glewGetExtension("GL_REND_screen_coordinates");

6245

#endif /* GL_REND_screen_coordinates */

6246

#ifdef GL_S3_s3tc

6247

CONST_CAST(GLEW_S3_s3tc) = glewGetExtension("GL_S3_s3tc");

6248

#endif /* GL_S3_s3tc */

6249

#ifdef GL_SGIS_color_range

6250

CONST_CAST(GLEW_SGIS_color_range) = glewGetExtension("GL_SGIS_color_range");

6251

#endif /* GL_SGIS_color_range */

6252

#ifdef GL_SGIS_detail_texture

6253

CONST_CAST(GLEW_SGIS_detail_texture) = glewGetExtension("GL_SGIS_detail_texture");

6254

if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6255

#endif /* GL_SGIS_detail_texture */

6256

#ifdef GL_SGIS_fog_function

6257

CONST_CAST(GLEW_SGIS_fog_function) = glewGetExtension("GL_SGIS_fog_function");

6258

if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT);

6259

#endif /* GL_SGIS_fog_function */

6260

#ifdef GL_SGIS_generate_mipmap

6261

CONST_CAST(GLEW_SGIS_generate_mipmap) = glewGetExtension("GL_SGIS_generate_mipmap");

6262

#endif /* GL_SGIS_generate_mipmap */

6263

#ifdef GL_SGIS_multisample

6264

CONST_CAST(GLEW_SGIS_multisample) = glewGetExtension("GL_SGIS_multisample");

6265

if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

6266

#endif /* GL_SGIS_multisample */

6267

#ifdef GL_SGIS_pixel_texture

6268

CONST_CAST(GLEW_SGIS_pixel_texture) = glewGetExtension("GL_SGIS_pixel_texture");

6269

#endif /* GL_SGIS_pixel_texture */

6270

#ifdef GL_SGIS_sharpen_texture

6271

CONST_CAST(GLEW_SGIS_sharpen_texture) = glewGetExtension("GL_SGIS_sharpen_texture");

6272

if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6273

#endif /* GL_SGIS_sharpen_texture */

6274

#ifdef GL_SGIS_texture4D

6275

CONST_CAST(GLEW_SGIS_texture4D) = glewGetExtension("GL_SGIS_texture4D");

6276

if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT);

6277

#endif /* GL_SGIS_texture4D */

6278

#ifdef GL_SGIS_texture_border_clamp

6279

CONST_CAST(GLEW_SGIS_texture_border_clamp) = glewGetExtension("GL_SGIS_texture_border_clamp");

6280

#endif /* GL_SGIS_texture_border_clamp */

6281

#ifdef GL_SGIS_texture_edge_clamp

6282

CONST_CAST(GLEW_SGIS_texture_edge_clamp) = glewGetExtension("GL_SGIS_texture_edge_clamp");

6283

#endif /* GL_SGIS_texture_edge_clamp */

6284

#ifdef GL_SGIS_texture_filter4

6285

CONST_CAST(GLEW_SGIS_texture_filter4) = glewGetExtension("GL_SGIS_texture_filter4");

6286

if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT);

6287

#endif /* GL_SGIS_texture_filter4 */

6288

#ifdef GL_SGIS_texture_lod

6289

CONST_CAST(GLEW_SGIS_texture_lod) = glewGetExtension("GL_SGIS_texture_lod");

6290

#endif /* GL_SGIS_texture_lod */

6291

#ifdef GL_SGIS_texture_select

6292

CONST_CAST(GLEW_SGIS_texture_select) = glewGetExtension("GL_SGIS_texture_select");

6293

#endif /* GL_SGIS_texture_select */

6294

#ifdef GL_SGIX_async

6295

CONST_CAST(GLEW_SGIX_async) = glewGetExtension("GL_SGIX_async");

6296

if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT);

6297

#endif /* GL_SGIX_async */

6298

#ifdef GL_SGIX_async_histogram

6299

CONST_CAST(GLEW_SGIX_async_histogram) = glewGetExtension("GL_SGIX_async_histogram");

6300

#endif /* GL_SGIX_async_histogram */

6301

#ifdef GL_SGIX_async_pixel

6302

CONST_CAST(GLEW_SGIX_async_pixel) = glewGetExtension("GL_SGIX_async_pixel");

6303

#endif /* GL_SGIX_async_pixel */

6304

#ifdef GL_SGIX_blend_alpha_minmax

6305

CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = glewGetExtension("GL_SGIX_blend_alpha_minmax");

6306

#endif /* GL_SGIX_blend_alpha_minmax */

6307

#ifdef GL_SGIX_clipmap

6308

CONST_CAST(GLEW_SGIX_clipmap) = glewGetExtension("GL_SGIX_clipmap");

6309

#endif /* GL_SGIX_clipmap */

6310

#ifdef GL_SGIX_depth_texture

6311

CONST_CAST(GLEW_SGIX_depth_texture) = glewGetExtension("GL_SGIX_depth_texture");

6312

#endif /* GL_SGIX_depth_texture */

6313

#ifdef GL_SGIX_flush_raster

6314

CONST_CAST(GLEW_SGIX_flush_raster) = glewGetExtension("GL_SGIX_flush_raster");

6315

if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT);

6316

#endif /* GL_SGIX_flush_raster */

6317

#ifdef GL_SGIX_fog_offset

6318

CONST_CAST(GLEW_SGIX_fog_offset) = glewGetExtension("GL_SGIX_fog_offset");

6319

#endif /* GL_SGIX_fog_offset */

6320

#ifdef GL_SGIX_fog_texture

6321

CONST_CAST(GLEW_SGIX_fog_texture) = glewGetExtension("GL_SGIX_fog_texture");

6322

if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6323

#endif /* GL_SGIX_fog_texture */

6324

#ifdef GL_SGIX_fragment_specular_lighting

6325

CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = glewGetExtension("GL_SGIX_fragment_specular_lighting");

6326

if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT);

6327

#endif /* GL_SGIX_fragment_specular_lighting */

6328

#ifdef GL_SGIX_framezoom

6329

CONST_CAST(GLEW_SGIX_framezoom) = glewGetExtension("GL_SGIX_framezoom");

6330

if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT);

6331

#endif /* GL_SGIX_framezoom */

6332

#ifdef GL_SGIX_interlace

6333

CONST_CAST(GLEW_SGIX_interlace) = glewGetExtension("GL_SGIX_interlace");

6334

#endif /* GL_SGIX_interlace */

6335

#ifdef GL_SGIX_ir_instrument1

6336

CONST_CAST(GLEW_SGIX_ir_instrument1) = glewGetExtension("GL_SGIX_ir_instrument1");

6337

#endif /* GL_SGIX_ir_instrument1 */

6338

#ifdef GL_SGIX_list_priority

6339

CONST_CAST(GLEW_SGIX_list_priority) = glewGetExtension("GL_SGIX_list_priority");

6340

#endif /* GL_SGIX_list_priority */

6341

#ifdef GL_SGIX_pixel_texture

6342

CONST_CAST(GLEW_SGIX_pixel_texture) = glewGetExtension("GL_SGIX_pixel_texture");

6343

if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6344

#endif /* GL_SGIX_pixel_texture */

6345

#ifdef GL_SGIX_pixel_texture_bits

6346

CONST_CAST(GLEW_SGIX_pixel_texture_bits) = glewGetExtension("GL_SGIX_pixel_texture_bits");

6347

#endif /* GL_SGIX_pixel_texture_bits */

6348

#ifdef GL_SGIX_reference_plane

6349

CONST_CAST(GLEW_SGIX_reference_plane) = glewGetExtension("GL_SGIX_reference_plane");

6350

if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT);

6351

#endif /* GL_SGIX_reference_plane */

6352

#ifdef GL_SGIX_resample

6353

CONST_CAST(GLEW_SGIX_resample) = glewGetExtension("GL_SGIX_resample");

6354

#endif /* GL_SGIX_resample */

6355

#ifdef GL_SGIX_shadow

6356

CONST_CAST(GLEW_SGIX_shadow) = glewGetExtension("GL_SGIX_shadow");

6357

#endif /* GL_SGIX_shadow */

6358

#ifdef GL_SGIX_shadow_ambient

6359

CONST_CAST(GLEW_SGIX_shadow_ambient) = glewGetExtension("GL_SGIX_shadow_ambient");

6360

#endif /* GL_SGIX_shadow_ambient */

6361

#ifdef GL_SGIX_sprite

6362

CONST_CAST(GLEW_SGIX_sprite) = glewGetExtension("GL_SGIX_sprite");

6363

if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT);

6364

#endif /* GL_SGIX_sprite */

6365

#ifdef GL_SGIX_tag_sample_buffer

6366

CONST_CAST(GLEW_SGIX_tag_sample_buffer) = glewGetExtension("GL_SGIX_tag_sample_buffer");

6367

if (glewExperimental || GLEW_SGIX_tag_sample_buffer) CONST_CAST(GLEW_SGIX_tag_sample_buffer) = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

6368

#endif /* GL_SGIX_tag_sample_buffer */

6369

#ifdef GL_SGIX_texture_add_env

6370

CONST_CAST(GLEW_SGIX_texture_add_env) = glewGetExtension("GL_SGIX_texture_add_env");

6371

#endif /* GL_SGIX_texture_add_env */

6372

#ifdef GL_SGIX_texture_coordinate_clamp

6373

CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = glewGetExtension("GL_SGIX_texture_coordinate_clamp");

6374

#endif /* GL_SGIX_texture_coordinate_clamp */

6375

#ifdef GL_SGIX_texture_lod_bias

6376

CONST_CAST(GLEW_SGIX_texture_lod_bias) = glewGetExtension("GL_SGIX_texture_lod_bias");

6377

#endif /* GL_SGIX_texture_lod_bias */

6378

#ifdef GL_SGIX_texture_multi_buffer

6379

CONST_CAST(GLEW_SGIX_texture_multi_buffer) = glewGetExtension("GL_SGIX_texture_multi_buffer");

6380

#endif /* GL_SGIX_texture_multi_buffer */

6381

#ifdef GL_SGIX_texture_range

6382

CONST_CAST(GLEW_SGIX_texture_range) = glewGetExtension("GL_SGIX_texture_range");

6383

#endif /* GL_SGIX_texture_range */

6384

#ifdef GL_SGIX_texture_scale_bias

6385

CONST_CAST(GLEW_SGIX_texture_scale_bias) = glewGetExtension("GL_SGIX_texture_scale_bias");

6386

#endif /* GL_SGIX_texture_scale_bias */

6387

#ifdef GL_SGIX_vertex_preclip

6388

CONST_CAST(GLEW_SGIX_vertex_preclip) = glewGetExtension("GL_SGIX_vertex_preclip");

6389

#endif /* GL_SGIX_vertex_preclip */

6390

#ifdef GL_SGIX_vertex_preclip_hint

6391

CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = glewGetExtension("GL_SGIX_vertex_preclip_hint");

6392

#endif /* GL_SGIX_vertex_preclip_hint */

6393

#ifdef GL_SGIX_ycrcb

6394

CONST_CAST(GLEW_SGIX_ycrcb) = glewGetExtension("GL_SGIX_ycrcb");

6395

#endif /* GL_SGIX_ycrcb */

6396

#ifdef GL_SGI_color_matrix

6397

CONST_CAST(GLEW_SGI_color_matrix) = glewGetExtension("GL_SGI_color_matrix");

6398

#endif /* GL_SGI_color_matrix */

6399

#ifdef GL_SGI_color_table

6400

CONST_CAST(GLEW_SGI_color_table) = glewGetExtension("GL_SGI_color_table");

6401

if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT);

6402

#endif /* GL_SGI_color_table */

6403

#ifdef GL_SGI_texture_color_table

6404

CONST_CAST(GLEW_SGI_texture_color_table) = glewGetExtension("GL_SGI_texture_color_table");

6405

#endif /* GL_SGI_texture_color_table */

6406

#ifdef GL_SUNX_constant_data

6407

CONST_CAST(GLEW_SUNX_constant_data) = glewGetExtension("GL_SUNX_constant_data");

6408

if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT);

6409

#endif /* GL_SUNX_constant_data */

6410

#ifdef GL_SUN_convolution_border_modes

6411

CONST_CAST(GLEW_SUN_convolution_border_modes) = glewGetExtension("GL_SUN_convolution_border_modes");

6412

#endif /* GL_SUN_convolution_border_modes */

6413

#ifdef GL_SUN_global_alpha

6414

CONST_CAST(GLEW_SUN_global_alpha) = glewGetExtension("GL_SUN_global_alpha");

6415

if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT);

6416

#endif /* GL_SUN_global_alpha */

6417

#ifdef GL_SUN_mesh_array

6418

CONST_CAST(GLEW_SUN_mesh_array) = glewGetExtension("GL_SUN_mesh_array");

6419

#endif /* GL_SUN_mesh_array */

6420

#ifdef GL_SUN_read_video_pixels

6421

CONST_CAST(GLEW_SUN_read_video_pixels) = glewGetExtension("GL_SUN_read_video_pixels");

6422

if (glewExperimental || GLEW_SUN_read_video_pixels) CONST_CAST(GLEW_SUN_read_video_pixels) = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT);

6423

#endif /* GL_SUN_read_video_pixels */

6424

#ifdef GL_SUN_slice_accum

6425

CONST_CAST(GLEW_SUN_slice_accum) = glewGetExtension("GL_SUN_slice_accum");

6426

#endif /* GL_SUN_slice_accum */

6427

#ifdef GL_SUN_triangle_list

6428

CONST_CAST(GLEW_SUN_triangle_list) = glewGetExtension("GL_SUN_triangle_list");

6429

if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT);

6430

#endif /* GL_SUN_triangle_list */

6431

#ifdef GL_SUN_vertex

6432

CONST_CAST(GLEW_SUN_vertex) = glewGetExtension("GL_SUN_vertex");

6433

if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT);

6434

#endif /* GL_SUN_vertex */

6435

#ifdef GL_WIN_phong_shading

6436

CONST_CAST(GLEW_WIN_phong_shading) = glewGetExtension("GL_WIN_phong_shading");

6437

#endif /* GL_WIN_phong_shading */

6438

#ifdef GL_WIN_specular_fog

6439

CONST_CAST(GLEW_WIN_specular_fog) = glewGetExtension("GL_WIN_specular_fog");

6440

#endif /* GL_WIN_specular_fog */

6441

#ifdef GL_WIN_swap_hint

6442

CONST_CAST(GLEW_WIN_swap_hint) = glewGetExtension("GL_WIN_swap_hint");

6443

if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT);

6444

#endif /* GL_WIN_swap_hint */

6445

6446

return GLEW_OK;

6447

}

6448

6449

6450

#if defined(_WIN32)

6451

6452

#if !defined(GLEW_MX)

6453

6454

PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;

6455

6456

PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;

6457

PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;

6458

PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;

6459

PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;

6460

6461

PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;

6462

6463

PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;

6464

PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;

6465

6466

PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;

6467

PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;

6468

PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;

6469

PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;

6470

PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;

6471

6472

PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;

6473

PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;

6474

PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;

6475

6476

PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;

6477

PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;

6478

PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;

6479

6480

PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;

6481

PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;

6482

PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;

6483

PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;

6484

6485

PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;

6486

6487

PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;

6488

PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;

6489

6490

PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;

6491

PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;

6492

PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;

6493

PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;

6494

PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;

6495

6496

PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;

6497

PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;

6498

PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;

6499

6500

PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;

6501

PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;

6502

6503

PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;

6504

PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;

6505

6506

PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;

6507

PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;

6508

PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;

6509

PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;

6510

6511

PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;

6512

PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;

6513

PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;

6514

PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;

6515

PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;

6516

PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;

6517

PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;

6518

PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;

6519

PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;

6520

PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;

6521

PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;

6522

PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;

6523

6524

PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;

6525

PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;

6526

PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;

6527

PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;

6528

6529

PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;

6530

PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;

6531

PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;

6532

PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;

6533

6534

PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;

6535

PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;

6536

PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;

6537

PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;

6538

6539

PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;

6540

PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;

6541

PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;

6542

PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL;

6543

PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL;

6544

6545

PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;

6546

PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;

6547

6548

PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;

6549

PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;

6550

PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;

6551

PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;

6552

PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;

6553

PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;

6554

GLboolean __WGLEW_3DFX_multisample = GL_FALSE;

6555

GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;

6556

GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;

6557

GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;

6558

GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;

6559

GLboolean __WGLEW_ARB_multisample = GL_FALSE;

6560

GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;

6561

GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;

6562

GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;

6563

GLboolean __WGLEW_ARB_render_texture = GL_FALSE;

6564

GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;

6565

GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;

6566

GLboolean __WGLEW_EXT_depth_float = GL_FALSE;

6567

GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;

6568

GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;

6569

GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE;

6570

GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;

6571

GLboolean __WGLEW_EXT_multisample = GL_FALSE;

6572

GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;

6573

GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;

6574

GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE;

6575

GLboolean __WGLEW_EXT_swap_control = GL_FALSE;

6576

GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;

6577

GLboolean __WGLEW_I3D_gamma = GL_FALSE;

6578

GLboolean __WGLEW_I3D_genlock = GL_FALSE;

6579

GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;

6580

GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;

6581

GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;

6582

GLboolean __WGLEW_NV_float_buffer = GL_FALSE;

6583

GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;

6584

GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;

6585

GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;

6586

GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;

6587

GLboolean __WGLEW_OML_sync_control = GL_FALSE;

6588

6589

#endif /* !GLEW_MX */

6590

6591

#ifdef WGL_3DFX_multisample

6592

6593

#endif /* WGL_3DFX_multisample */

6594

6595

#ifdef WGL_3DL_stereo_control

6596

6597

static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT)

6598

{

6599

GLboolean r = GL_FALSE;

6600

6601

r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r;

6602

6603

return r;

6604

}

6605

6606

#endif /* WGL_3DL_stereo_control */

6607

6608

#ifdef WGL_ARB_buffer_region

6609

6610

static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)

6611

{

6612

GLboolean r = GL_FALSE;

6613

6614

r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;

6615

r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;

6616

r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;

6617

r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;

6618

6619

return r;

6620

}

6621

6622

#endif /* WGL_ARB_buffer_region */

6623

6624

#ifdef WGL_ARB_extensions_string

6625

6626

static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)

6627

{

6628

GLboolean r = GL_FALSE;

6629

6630

r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;

6631

6632

return r;

6633

}

6634

6635

#endif /* WGL_ARB_extensions_string */

6636

6637

#ifdef WGL_ARB_make_current_read

6638

6639

static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)

6640

{

6641

GLboolean r = GL_FALSE;

6642

6643

r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;

6644

r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;

6645

6646

return r;

6647

}

6648

6649

#endif /* WGL_ARB_make_current_read */

6650

6651

#ifdef WGL_ARB_multisample

6652

6653

#endif /* WGL_ARB_multisample */

6654

6655

#ifdef WGL_ARB_pbuffer

6656

6657

static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)

6658

{

6659

GLboolean r = GL_FALSE;

6660

6661

r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;

6662

r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;

6663

r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;

6664

r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;

6665

r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;

6666

6667

return r;

6668

}

6669

6670

#endif /* WGL_ARB_pbuffer */

6671

6672

#ifdef WGL_ARB_pixel_format

6673

6674

static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)

6675

{

6676

GLboolean r = GL_FALSE;

6677

6678

r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;

6679

r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;

6680

r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;

6681

6682

return r;

6683

}

6684

6685

#endif /* WGL_ARB_pixel_format */

6686

6687

#ifdef WGL_ARB_pixel_format_float

6688

6689

#endif /* WGL_ARB_pixel_format_float */

6690

6691

#ifdef WGL_ARB_render_texture

6692

6693

static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)

6694

{

6695

GLboolean r = GL_FALSE;

6696

6697

r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;

6698

r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;

6699

r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;

6700

6701

return r;

6702

}

6703

6704

#endif /* WGL_ARB_render_texture */

6705

6706

#ifdef WGL_ATI_pixel_format_float

6707

6708

#endif /* WGL_ATI_pixel_format_float */

6709

6710

#ifdef WGL_ATI_render_texture_rectangle

6711

6712

#endif /* WGL_ATI_render_texture_rectangle */

6713

6714

#ifdef WGL_EXT_depth_float

6715

6716

#endif /* WGL_EXT_depth_float */

6717

6718

#ifdef WGL_EXT_display_color_table

6719

6720

static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT)

6721

{

6722

GLboolean r = GL_FALSE;

6723

6724

r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;

6725

r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;

6726

r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;

6727

r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;

6728

6729

return r;

6730

}

6731

6732

#endif /* WGL_EXT_display_color_table */

6733

6734

#ifdef WGL_EXT_extensions_string

6735

6736

static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)

6737

{

6738

GLboolean r = GL_FALSE;

6739

6740

r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;

6741

6742

return r;

6743

}

6744

6745

#endif /* WGL_EXT_extensions_string */

6746

6747

#ifdef WGL_EXT_framebuffer_sRGB

6748

6749

#endif /* WGL_EXT_framebuffer_sRGB */

6750

6751

#ifdef WGL_EXT_make_current_read

6752

6753

static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)

6754

{

6755

GLboolean r = GL_FALSE;

6756

6757

r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;

6758

r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;

6759

6760

return r;

6761

}

6762

6763

#endif /* WGL_EXT_make_current_read */

6764

6765

#ifdef WGL_EXT_multisample

6766

6767

#endif /* WGL_EXT_multisample */

6768

6769

#ifdef WGL_EXT_pbuffer

6770

6771

static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)

6772

{

6773

GLboolean r = GL_FALSE;

6774

6775

r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;

6776

r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;

6777

r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;

6778

r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;

6779

r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;

6780

6781

return r;

6782

}

6783

6784

#endif /* WGL_EXT_pbuffer */

6785

6786

#ifdef WGL_EXT_pixel_format

6787

6788

static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)

6789

{

6790

GLboolean r = GL_FALSE;

6791

6792

r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;

6793

r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;

6794

r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;

6795

6796

return r;

6797

}

6798

6799

#endif /* WGL_EXT_pixel_format */

6800

6801

#ifdef WGL_EXT_pixel_format_packed_float

6802

6803

#endif /* WGL_EXT_pixel_format_packed_float */

6804

6805

#ifdef WGL_EXT_swap_control

6806

6807

static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)

6808

{

6809

GLboolean r = GL_FALSE;

6810

6811

r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;

6812

r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;

6813

6814

return r;

6815

}

6816

6817

#endif /* WGL_EXT_swap_control */

6818

6819

#ifdef WGL_I3D_digital_video_control

6820

6821

static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT)

6822

{

6823

GLboolean r = GL_FALSE;

6824

6825

r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;

6826

r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;

6827

6828

return r;

6829

}

6830

6831

#endif /* WGL_I3D_digital_video_control */

6832

6833

#ifdef WGL_I3D_gamma

6834

6835

static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT)

6836

{

6837

GLboolean r = GL_FALSE;

6838

6839

r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;

6840

r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;

6841

r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;

6842

r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;

6843

6844

return r;

6845

}

6846

6847

#endif /* WGL_I3D_gamma */

6848

6849

#ifdef WGL_I3D_genlock

6850

6851

static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT)

6852

{

6853

GLboolean r = GL_FALSE;

6854

6855

r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;

6856

r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;

6857

r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;

6858

r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;

6859

r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;

6860

r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;

6861

r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;

6862

r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;

6863

r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;

6864

r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;

6865

r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;

6866

r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;

6867

6868

return r;

6869

}

6870

6871

#endif /* WGL_I3D_genlock */

6872

6873

#ifdef WGL_I3D_image_buffer

6874

6875

static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT)

6876

{

6877

GLboolean r = GL_FALSE;

6878

6879

r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;

6880

r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;

6881

r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;

6882

r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;

6883

6884

return r;

6885

}

6886

6887

#endif /* WGL_I3D_image_buffer */

6888

6889

#ifdef WGL_I3D_swap_frame_lock

6890

6891

static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT)

6892

{

6893

GLboolean r = GL_FALSE;

6894

6895

r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;

6896

r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;

6897

r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;

6898

r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;

6899

6900

return r;

6901

}

6902

6903

#endif /* WGL_I3D_swap_frame_lock */

6904

6905

#ifdef WGL_I3D_swap_frame_usage

6906

6907

static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)

6908

{

6909

GLboolean r = GL_FALSE;

6910

6911

r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;

6912

r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;

6913

r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;

6914

r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;

6915

6916

return r;

6917

}

6918

6919

#endif /* WGL_I3D_swap_frame_usage */

6920

6921

#ifdef WGL_NV_float_buffer

6922

6923

#endif /* WGL_NV_float_buffer */

6924

6925

#ifdef WGL_NV_gpu_affinity

6926

6927

static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT)

6928

{

6929

GLboolean r = GL_FALSE;

6930

6931

r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r;

6932

r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r;

6933

r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r;

6934

r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r;

6935

r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r;

6936

6937

return r;

6938

}

6939

6940

#endif /* WGL_NV_gpu_affinity */

6941

6942

#ifdef WGL_NV_render_depth_texture

6943

6944

#endif /* WGL_NV_render_depth_texture */

6945

6946

#ifdef WGL_NV_render_texture_rectangle

6947

6948

#endif /* WGL_NV_render_texture_rectangle */

6949

6950

#ifdef WGL_NV_vertex_array_range

6951

6952

static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT)

6953

{

6954

GLboolean r = GL_FALSE;

6955

6956

r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;

6957

r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;

6958

6959

return r;

6960

}

6961

6962

#endif /* WGL_NV_vertex_array_range */

6963

6964

#ifdef WGL_OML_sync_control

6965

6966

static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT)

6967

{

6968

GLboolean r = GL_FALSE;

6969

6970

r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;

6971

r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;

6972

r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;

6973

r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;

6974

r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;

6975

r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;

6976

6977

return r;

6978

}

6979

6980

#endif /* WGL_OML_sync_control */

6981

6982

/* ------------------------------------------------------------------------- */

6983

6984

static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;

6985

static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;

6986

6987

GLboolean wglewGetExtension (const char* name)

6988

{

6989

GLubyte* p;

6990

GLubyte* end;

6991

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

6992

if (_wglewGetExtensionsStringARB == NULL)

6993

if (_wglewGetExtensionsStringEXT == NULL)

6994

return GL_FALSE;

6995

else

6996

p = (GLubyte*)_wglewGetExtensionsStringEXT();

6997

else

6998

p = (GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());

6999

if (0 == p) return GL_FALSE;

7000

end = p + _glewStrLen(p);

7001

while (p < end)

7002

{

7003

GLuint n = _glewStrCLen(p, ' ');

7004

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

7005

p += n+1;

7006

}

7007

return GL_FALSE;

7008

}

7009

7010

GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)

7011

{

7012

GLboolean crippled;

7013

/* find wgl extension string query functions */

7014

_wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");

7015

_wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");

7016

/* initialize extensions */

7017

crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;

7018

#ifdef WGL_3DFX_multisample

7019

CONST_CAST(WGLEW_3DFX_multisample) = wglewGetExtension("WGL_3DFX_multisample");

7020

#endif /* WGL_3DFX_multisample */

7021

#ifdef WGL_3DL_stereo_control

7022

CONST_CAST(WGLEW_3DL_stereo_control) = wglewGetExtension("WGL_3DL_stereo_control");

7023

if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT);

7024

#endif /* WGL_3DL_stereo_control */

7025

#ifdef WGL_ARB_buffer_region

7026

CONST_CAST(WGLEW_ARB_buffer_region) = wglewGetExtension("WGL_ARB_buffer_region");

7027

if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);

7028

#endif /* WGL_ARB_buffer_region */

7029

#ifdef WGL_ARB_extensions_string

7030

CONST_CAST(WGLEW_ARB_extensions_string) = wglewGetExtension("WGL_ARB_extensions_string");

7031

if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);

7032

#endif /* WGL_ARB_extensions_string */

7033

#ifdef WGL_ARB_make_current_read

7034

CONST_CAST(WGLEW_ARB_make_current_read) = wglewGetExtension("WGL_ARB_make_current_read");

7035

if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) CONST_CAST(WGLEW_ARB_make_current_read)= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

7036

#endif /* WGL_ARB_make_current_read */

7037

#ifdef WGL_ARB_multisample

7038

CONST_CAST(WGLEW_ARB_multisample) = wglewGetExtension("WGL_ARB_multisample");

7039

#endif /* WGL_ARB_multisample */

7040

#ifdef WGL_ARB_pbuffer

7041

CONST_CAST(WGLEW_ARB_pbuffer) = wglewGetExtension("WGL_ARB_pbuffer");

7042

if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

7043

#endif /* WGL_ARB_pbuffer */

7044

#ifdef WGL_ARB_pixel_format

7045

CONST_CAST(WGLEW_ARB_pixel_format) = wglewGetExtension("WGL_ARB_pixel_format");

7046

if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);

7047

#endif /* WGL_ARB_pixel_format */

7048

#ifdef WGL_ARB_pixel_format_float

7049

CONST_CAST(WGLEW_ARB_pixel_format_float) = wglewGetExtension("WGL_ARB_pixel_format_float");

7050

#endif /* WGL_ARB_pixel_format_float */

7051

#ifdef WGL_ARB_render_texture

7052

CONST_CAST(WGLEW_ARB_render_texture) = wglewGetExtension("WGL_ARB_render_texture");

7053

if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);

7054

#endif /* WGL_ARB_render_texture */

7055

#ifdef WGL_ATI_pixel_format_float

7056

CONST_CAST(WGLEW_ATI_pixel_format_float) = wglewGetExtension("WGL_ATI_pixel_format_float");

7057

#endif /* WGL_ATI_pixel_format_float */

7058

#ifdef WGL_ATI_render_texture_rectangle

7059

CONST_CAST(WGLEW_ATI_render_texture_rectangle) = wglewGetExtension("WGL_ATI_render_texture_rectangle");

7060

#endif /* WGL_ATI_render_texture_rectangle */

7061

#ifdef WGL_EXT_depth_float

7062

CONST_CAST(WGLEW_EXT_depth_float) = wglewGetExtension("WGL_EXT_depth_float");

7063

#endif /* WGL_EXT_depth_float */

7064

#ifdef WGL_EXT_display_color_table

7065

CONST_CAST(WGLEW_EXT_display_color_table) = wglewGetExtension("WGL_EXT_display_color_table");

7066

if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) CONST_CAST(WGLEW_EXT_display_color_table)= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT);

7067

#endif /* WGL_EXT_display_color_table */

7068

#ifdef WGL_EXT_extensions_string

7069

CONST_CAST(WGLEW_EXT_extensions_string) = wglewGetExtension("WGL_EXT_extensions_string");

7070

if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);

7071

#endif /* WGL_EXT_extensions_string */

7072

#ifdef WGL_EXT_framebuffer_sRGB

7073

CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = wglewGetExtension("WGL_EXT_framebuffer_sRGB");

7074

#endif /* WGL_EXT_framebuffer_sRGB */

7075

#ifdef WGL_EXT_make_current_read

7076

CONST_CAST(WGLEW_EXT_make_current_read) = wglewGetExtension("WGL_EXT_make_current_read");

7077

if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) CONST_CAST(WGLEW_EXT_make_current_read)= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

7078

#endif /* WGL_EXT_make_current_read */

7079

#ifdef WGL_EXT_multisample

7080

CONST_CAST(WGLEW_EXT_multisample) = wglewGetExtension("WGL_EXT_multisample");

7081

#endif /* WGL_EXT_multisample */

7082

#ifdef WGL_EXT_pbuffer

7083

CONST_CAST(WGLEW_EXT_pbuffer) = wglewGetExtension("WGL_EXT_pbuffer");

7084

if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

7085

#endif /* WGL_EXT_pbuffer */

7086

#ifdef WGL_EXT_pixel_format

7087

CONST_CAST(WGLEW_EXT_pixel_format) = wglewGetExtension("WGL_EXT_pixel_format");

7088

if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);

7089

#endif /* WGL_EXT_pixel_format */

7090

#ifdef WGL_EXT_pixel_format_packed_float

7091

CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = wglewGetExtension("WGL_EXT_pixel_format_packed_float");

7092

#endif /* WGL_EXT_pixel_format_packed_float */

7093

#ifdef WGL_EXT_swap_control

7094

CONST_CAST(WGLEW_EXT_swap_control) = wglewGetExtension("WGL_EXT_swap_control");

7095

if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);

7096

#endif /* WGL_EXT_swap_control */

7097

#ifdef WGL_I3D_digital_video_control

7098

CONST_CAST(WGLEW_I3D_digital_video_control) = wglewGetExtension("WGL_I3D_digital_video_control");

7099

if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) CONST_CAST(WGLEW_I3D_digital_video_control)= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT);

7100

#endif /* WGL_I3D_digital_video_control */

7101

#ifdef WGL_I3D_gamma

7102

CONST_CAST(WGLEW_I3D_gamma) = wglewGetExtension("WGL_I3D_gamma");

7103

if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT);

7104

#endif /* WGL_I3D_gamma */

7105

#ifdef WGL_I3D_genlock

7106

CONST_CAST(WGLEW_I3D_genlock) = wglewGetExtension("WGL_I3D_genlock");

7107

if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT);

7108

#endif /* WGL_I3D_genlock */

7109

#ifdef WGL_I3D_image_buffer

7110

CONST_CAST(WGLEW_I3D_image_buffer) = wglewGetExtension("WGL_I3D_image_buffer");

7111

if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

7112

#endif /* WGL_I3D_image_buffer */

7113

#ifdef WGL_I3D_swap_frame_lock

7114

CONST_CAST(WGLEW_I3D_swap_frame_lock) = wglewGetExtension("WGL_I3D_swap_frame_lock");

7115

if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_lock)= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT);

7116

#endif /* WGL_I3D_swap_frame_lock */

7117

#ifdef WGL_I3D_swap_frame_usage

7118

CONST_CAST(WGLEW_I3D_swap_frame_usage) = wglewGetExtension("WGL_I3D_swap_frame_usage");

7119

if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT);

7120

#endif /* WGL_I3D_swap_frame_usage */

7121

#ifdef WGL_NV_float_buffer

7122

CONST_CAST(WGLEW_NV_float_buffer) = wglewGetExtension("WGL_NV_float_buffer");

7123

#endif /* WGL_NV_float_buffer */

7124

#ifdef WGL_NV_gpu_affinity

7125

CONST_CAST(WGLEW_NV_gpu_affinity) = wglewGetExtension("WGL_NV_gpu_affinity");

7126

if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT);

7127

#endif /* WGL_NV_gpu_affinity */

7128

#ifdef WGL_NV_render_depth_texture

7129

CONST_CAST(WGLEW_NV_render_depth_texture) = wglewGetExtension("WGL_NV_render_depth_texture");

7130

#endif /* WGL_NV_render_depth_texture */

7131

#ifdef WGL_NV_render_texture_rectangle

7132

CONST_CAST(WGLEW_NV_render_texture_rectangle) = wglewGetExtension("WGL_NV_render_texture_rectangle");

7133

#endif /* WGL_NV_render_texture_rectangle */

7134

#ifdef WGL_NV_vertex_array_range

7135

CONST_CAST(WGLEW_NV_vertex_array_range) = wglewGetExtension("WGL_NV_vertex_array_range");

7136

if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) CONST_CAST(WGLEW_NV_vertex_array_range)= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

7137

#endif /* WGL_NV_vertex_array_range */

7138

#ifdef WGL_OML_sync_control

7139

CONST_CAST(WGLEW_OML_sync_control) = wglewGetExtension("WGL_OML_sync_control");

7140

if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);

7141

#endif /* WGL_OML_sync_control */

7142

7143

return GLEW_OK;

7144

}

7145

7146

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

7147

7148

PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;

7149

7150

PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;

7151

PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;

7152

PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;

7153

PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;

7154

PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;

7155

PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;

7156

PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;

7157

PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;

7158

PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;

7159

PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;

7160

PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;

7161

PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;

7162

PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;

7163

PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;

7164

PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;

7165

PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;

7166

PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;

7167

7168

PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;

7169

PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;

7170

PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;

7171

7172

PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;

7173

PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;

7174

PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;

7175

PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;

7176

7177

PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;

7178

PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;

7179

7180

PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;

7181

7182

PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;

7183

7184

PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;

7185

7186

PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;

7187

7188

PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;

7189

7190

PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;

7191

PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;

7192

7193

#ifdef GLX_OML_sync_control

7194

PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;

7195

PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;

7196

PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;

7197

PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;

7198

PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;

7199

#endif

7200

7201

PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;

7202

PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;

7203

PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;

7204

PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;

7205

PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;

7206

PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;

7207

7208

PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL;

7209

PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL;

7210

PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL;

7211

PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL;

7212

PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL;

7213

PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL;

7214

PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL;

7215

PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL;

7216

7217

PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;

7218

PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;

7219

PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;

7220

PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;

7221

PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;

7222

7223

PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;

7224

PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;

7225

7226

PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;

7227

7228

PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;

7229

PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;

7230

PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;

7231

PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;

7232

PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;

7233

7234

PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;

7235

7236

PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;

7237

PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;

7238

7239

PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;

7240

7241

PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;

7242

PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;

7243

7244

PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;

7245

7246

PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;

7247

PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;

7248

7249

#if !defined(GLEW_MX)

7250

7251

GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;

7252

GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;

7253

GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;

7254

GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;

7255

GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;

7256

GLboolean __GLXEW_3DFX_multisample = GL_FALSE;

7257

GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;

7258

GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;

7259

GLboolean __GLXEW_ARB_multisample = GL_FALSE;

7260

GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;

7261

GLboolean __GLXEW_ATI_render_texture = GL_FALSE;

7262

GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;

7263

GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;

7264

GLboolean __GLXEW_EXT_import_context = GL_FALSE;

7265

GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;

7266

GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;

7267

GLboolean __GLXEW_EXT_visual_info = GL_FALSE;

7268

GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;

7269

GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;

7270

GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;

7271

GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;

7272

GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;

7273

GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;

7274

GLboolean __GLXEW_NV_float_buffer = GL_FALSE;

7275

GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;

7276

GLboolean __GLXEW_OML_swap_method = GL_FALSE;

7277

#ifdef GLX_OML_sync_control

7278

GLboolean __GLXEW_OML_sync_control = GL_FALSE;

7279

#endif

7280

GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;

7281

GLboolean __GLXEW_SGIS_color_range = GL_FALSE;

7282

GLboolean __GLXEW_SGIS_multisample = GL_FALSE;

7283

GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;

7284

GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;

7285

GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE;

7286

GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;

7287

GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;

7288

GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;

7289

GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;

7290

GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;

7291

GLboolean __GLXEW_SGI_cushion = GL_FALSE;

7292

GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;

7293

GLboolean __GLXEW_SGI_swap_control = GL_FALSE;

7294

GLboolean __GLXEW_SGI_video_sync = GL_FALSE;

7295

GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;

7296

GLboolean __GLXEW_SUN_video_resize = GL_FALSE;

7297

7298

#endif /* !GLEW_MX */

7299

7300

#ifdef GLX_VERSION_1_2

7301

7302

static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT)

7303

{

7304

GLboolean r = GL_FALSE;

7305

7306

r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;

7307

7308

return r;

7309

}

7310

7311

#endif /* GLX_VERSION_1_2 */

7312

7313

#ifdef GLX_VERSION_1_3

7314

7315

static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT)

7316

{

7317

GLboolean r = GL_FALSE;

7318

7319

r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;

7320

r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;

7321

r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;

7322

r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;

7323

r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;

7324

r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;

7325

r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;

7326

r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;

7327

r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;

7328

r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;

7329

r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;

7330

r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;

7331

r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;

7332

r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;

7333

r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;

7334

r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;

7335

r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;

7336

7337

return r;

7338

}

7339

7340

#endif /* GLX_VERSION_1_3 */

7341

7342

#ifdef GLX_VERSION_1_4

7343

7344

#endif /* GLX_VERSION_1_4 */

7345

7346

#ifdef GLX_3DFX_multisample

7347

7348

#endif /* GLX_3DFX_multisample */

7349

7350

#ifdef GLX_ARB_fbconfig_float

7351

7352

#endif /* GLX_ARB_fbconfig_float */

7353

7354

#ifdef GLX_ARB_get_proc_address

7355

7356

#endif /* GLX_ARB_get_proc_address */

7357

7358

#ifdef GLX_ARB_multisample

7359

7360

#endif /* GLX_ARB_multisample */

7361

7362

#ifdef GLX_ATI_pixel_format_float

7363

7364

#endif /* GLX_ATI_pixel_format_float */

7365

7366

#ifdef GLX_ATI_render_texture

7367

7368

static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT)

7369

{

7370

GLboolean r = GL_FALSE;

7371

7372

r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;

7373

r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;

7374

r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;

7375

7376

return r;

7377

}

7378

7379

#endif /* GLX_ATI_render_texture */

7380

7381

#ifdef GLX_EXT_fbconfig_packed_float

7382

7383

#endif /* GLX_EXT_fbconfig_packed_float */

7384

7385

#ifdef GLX_EXT_framebuffer_sRGB

7386

7387

#endif /* GLX_EXT_framebuffer_sRGB */

7388

7389

#ifdef GLX_EXT_import_context

7390

7391

static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)

7392

{

7393

GLboolean r = GL_FALSE;

7394

7395

r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;

7396

r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;

7397

r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;

7398

r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;

7399

7400

return r;

7401

}

7402

7403

#endif /* GLX_EXT_import_context */

7404

7405

#ifdef GLX_EXT_scene_marker

7406

7407

#endif /* GLX_EXT_scene_marker */

7408

7409

#ifdef GLX_EXT_texture_from_pixmap

7410

7411

static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT)

7412

{

7413

GLboolean r = GL_FALSE;

7414

7415

r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r;

7416

r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r;

7417

7418

return r;

7419

}

7420

7421

#endif /* GLX_EXT_texture_from_pixmap */

7422

7423

#ifdef GLX_EXT_visual_info

7424

7425

#endif /* GLX_EXT_visual_info */

7426

7427

#ifdef GLX_EXT_visual_rating

7428

7429

#endif /* GLX_EXT_visual_rating */

7430

7431

#ifdef GLX_MESA_agp_offset

7432

7433

static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)

7434

{

7435

GLboolean r = GL_FALSE;

7436

7437

r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;

7438

7439

return r;

7440

}

7441

7442

#endif /* GLX_MESA_agp_offset */

7443

7444

#ifdef GLX_MESA_copy_sub_buffer

7445

7446

static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT)

7447

{

7448

GLboolean r = GL_FALSE;

7449

7450

r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;

7451

7452

return r;

7453

}

7454

7455

#endif /* GLX_MESA_copy_sub_buffer */

7456

7457

#ifdef GLX_MESA_pixmap_colormap

7458

7459

static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT)

7460

{

7461

GLboolean r = GL_FALSE;

7462

7463

r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;

7464

7465

return r;

7466

}

7467

7468

#endif /* GLX_MESA_pixmap_colormap */

7469

7470

#ifdef GLX_MESA_release_buffers

7471

7472

static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT)

7473

{

7474

GLboolean r = GL_FALSE;

7475

7476

r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;

7477

7478

return r;

7479

}

7480

7481

#endif /* GLX_MESA_release_buffers */

7482

7483

#ifdef GLX_MESA_set_3dfx_mode

7484

7485

static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)

7486

{

7487

GLboolean r = GL_FALSE;

7488

7489

r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;

7490

7491

return r;

7492

}

7493

7494

#endif /* GLX_MESA_set_3dfx_mode */

7495

7496

#ifdef GLX_NV_float_buffer

7497

7498

#endif /* GLX_NV_float_buffer */

7499

7500

#ifdef GLX_NV_vertex_array_range

7501

7502

static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT)

7503

{

7504

GLboolean r = GL_FALSE;

7505

7506

r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;

7507

r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;

7508

7509

return r;

7510

}

7511

7512

#endif /* GLX_NV_vertex_array_range */

7513

7514

#ifdef GLX_OML_swap_method

7515

7516

#endif /* GLX_OML_swap_method */

7517

7518

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

7519

#include <inttypes.h>

7520

7521

static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT)

7522

{

7523

GLboolean r = GL_FALSE;

7524

7525

r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;

7526

r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;

7527

r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;

7528

r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;

7529

r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;

7530

7531

return r;

7532

}

7533

7534

#endif /* GLX_OML_sync_control */

7535

7536

#ifdef GLX_SGIS_blended_overlay

7537

7538

#endif /* GLX_SGIS_blended_overlay */

7539

7540

#ifdef GLX_SGIS_color_range

7541

7542

#endif /* GLX_SGIS_color_range */

7543

7544

#ifdef GLX_SGIS_multisample

7545

7546

#endif /* GLX_SGIS_multisample */

7547

7548

#ifdef GLX_SGIS_shared_multisample

7549

7550

#endif /* GLX_SGIS_shared_multisample */

7551

7552

#ifdef GLX_SGIX_fbconfig

7553

7554

static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT)

7555

{

7556

GLboolean r = GL_FALSE;

7557

7558

r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;

7559

r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;

7560

r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;

7561

r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;

7562

r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;

7563

r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;

7564

7565

return r;

7566

}

7567

7568

#endif /* GLX_SGIX_fbconfig */

7569

7570

#ifdef GLX_SGIX_hyperpipe

7571

7572

static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT)

7573

{

7574

GLboolean r = GL_FALSE;

7575

7576

r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r;

7577

r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r;

7578

r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r;

7579

r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r;

7580

r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r;

7581

r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r;

7582

r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r;

7583

r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r;

7584

7585

return r;

7586

}

7587

7588

#endif /* GLX_SGIX_hyperpipe */

7589

7590

#ifdef GLX_SGIX_pbuffer

7591

7592

static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT)

7593

{

7594

GLboolean r = GL_FALSE;

7595

7596

r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;

7597

r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;

7598

r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;

7599

r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;

7600

r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;

7601

7602

return r;

7603

}

7604

7605

#endif /* GLX_SGIX_pbuffer */

7606

7607

#ifdef GLX_SGIX_swap_barrier

7608

7609

static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT)

7610

{

7611

GLboolean r = GL_FALSE;

7612

7613

r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;

7614

r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;

7615

7616

return r;

7617

}

7618

7619

#endif /* GLX_SGIX_swap_barrier */

7620

7621

#ifdef GLX_SGIX_swap_group

7622

7623

static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)

7624

{

7625

GLboolean r = GL_FALSE;

7626

7627

r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;

7628

7629

return r;

7630

}

7631

7632

#endif /* GLX_SGIX_swap_group */

7633

7634

#ifdef GLX_SGIX_video_resize

7635

7636

static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)

7637

{

7638

GLboolean r = GL_FALSE;

7639

7640

r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;

7641

r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;

7642

r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;

7643

r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;

7644

r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;

7645

7646

return r;

7647

}

7648

7649

#endif /* GLX_SGIX_video_resize */

7650

7651

#ifdef GLX_SGIX_visual_select_group

7652

7653

#endif /* GLX_SGIX_visual_select_group */

7654

7655

#ifdef GLX_SGI_cushion

7656

7657

static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT)

7658

{

7659

GLboolean r = GL_FALSE;

7660

7661

r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;

7662

7663

return r;

7664

}

7665

7666

#endif /* GLX_SGI_cushion */

7667

7668

#ifdef GLX_SGI_make_current_read

7669

7670

static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT)

7671

{

7672

GLboolean r = GL_FALSE;

7673

7674

r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;

7675

r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;

7676

7677

return r;

7678

}

7679

7680

#endif /* GLX_SGI_make_current_read */

7681

7682

#ifdef GLX_SGI_swap_control

7683

7684

static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)

7685

{

7686

GLboolean r = GL_FALSE;

7687

7688

r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;

7689

7690

return r;

7691

}

7692

7693

#endif /* GLX_SGI_swap_control */

7694

7695

#ifdef GLX_SGI_video_sync

7696

7697

static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT)

7698

{

7699

GLboolean r = GL_FALSE;

7700

7701

r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;

7702

r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;

7703

7704

return r;

7705

}

7706

7707

#endif /* GLX_SGI_video_sync */

7708

7709

#ifdef GLX_SUN_get_transparent_index

7710

7711

static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT)

7712

{

7713

GLboolean r = GL_FALSE;

7714

7715

r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;

7716

7717

return r;

7718

}

7719

7720

#endif /* GLX_SUN_get_transparent_index */

7721

7722

#ifdef GLX_SUN_video_resize

7723

7724

static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)

7725

{

7726

GLboolean r = GL_FALSE;

7727

7728

r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;

7729

r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;

7730

7731

return r;

7732

}

7733

7734

#endif /* GLX_SUN_video_resize */

7735

7736

/* ------------------------------------------------------------------------ */

7737

7738

GLboolean glxewGetExtension (const char* name)

7739

{

7740

GLubyte* p;

7741

GLubyte* end;

7742

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

7743

/* if (glXQueryExtensionsString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE; */

7744

/* p = (GLubyte*)glXQueryExtensionsString(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay())); */

7745

if (glXGetClientString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE;

7746

p = (GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);

7747

if (0 == p) return GL_FALSE;

7748

end = p + _glewStrLen(p);

7749

while (p < end)

7750

{

7751

GLuint n = _glewStrCLen(p, ' ');

7752

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

7753

p += n+1;

7754

}

7755

return GL_FALSE;

7756

}

7757

7758

GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)

7759

{

7760

int major, minor;

7761

/* initialize core GLX 1.2 */

7762

if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY;

7763

/* initialize flags */

7764

CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE;

7765

CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE;

7766

CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE;

7767

CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE;

7768

CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE;

7769

/* query GLX version */

7770

glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);

7771

if (major == 1 && minor <= 3)

7772

{

7773

switch (minor)

7774

{

7775

case 3:

7776

CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;

7777

break;

7778

case 2:

7779

CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;

7780

CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE;

7781

break;

7782

default:

7783

return GLEW_ERROR_GLX_VERSION_11_ONLY;

7784

break;

7785

}

7786

}

7787

/* initialize extensions */

7788

#ifdef GLX_VERSION_1_3

7789

if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);

7790

#endif /* GLX_VERSION_1_3 */

7791

#ifdef GLX_3DFX_multisample

7792

CONST_CAST(GLXEW_3DFX_multisample) = glxewGetExtension("GLX_3DFX_multisample");

7793

#endif /* GLX_3DFX_multisample */

7794

#ifdef GLX_ARB_fbconfig_float

7795

CONST_CAST(GLXEW_ARB_fbconfig_float) = glxewGetExtension("GLX_ARB_fbconfig_float");

7796

#endif /* GLX_ARB_fbconfig_float */

7797

#ifdef GLX_ARB_get_proc_address

7798

CONST_CAST(GLXEW_ARB_get_proc_address) = glxewGetExtension("GLX_ARB_get_proc_address");

7799

#endif /* GLX_ARB_get_proc_address */

7800

#ifdef GLX_ARB_multisample

7801

CONST_CAST(GLXEW_ARB_multisample) = glxewGetExtension("GLX_ARB_multisample");

7802

#endif /* GLX_ARB_multisample */

7803

#ifdef GLX_ATI_pixel_format_float

7804

CONST_CAST(GLXEW_ATI_pixel_format_float) = glxewGetExtension("GLX_ATI_pixel_format_float");

7805

#endif /* GLX_ATI_pixel_format_float */

7806

#ifdef GLX_ATI_render_texture

7807

CONST_CAST(GLXEW_ATI_render_texture) = glxewGetExtension("GLX_ATI_render_texture");

7808

if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);

7809

#endif /* GLX_ATI_render_texture */

7810

#ifdef GLX_EXT_fbconfig_packed_float

7811

CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = glxewGetExtension("GLX_EXT_fbconfig_packed_float");

7812

#endif /* GLX_EXT_fbconfig_packed_float */

7813

#ifdef GLX_EXT_framebuffer_sRGB

7814

CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = glxewGetExtension("GLX_EXT_framebuffer_sRGB");

7815

#endif /* GLX_EXT_framebuffer_sRGB */

7816

#ifdef GLX_EXT_import_context

7817

CONST_CAST(GLXEW_EXT_import_context) = glxewGetExtension("GLX_EXT_import_context");

7818

if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT);

7819

#endif /* GLX_EXT_import_context */

7820

#ifdef GLX_EXT_scene_marker

7821

CONST_CAST(GLXEW_EXT_scene_marker) = glxewGetExtension("GLX_EXT_scene_marker");

7822

#endif /* GLX_EXT_scene_marker */

7823

#ifdef GLX_EXT_texture_from_pixmap

7824

CONST_CAST(GLXEW_EXT_texture_from_pixmap) = glxewGetExtension("GLX_EXT_texture_from_pixmap");

7825

if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT);

7826

#endif /* GLX_EXT_texture_from_pixmap */

7827

#ifdef GLX_EXT_visual_info

7828

CONST_CAST(GLXEW_EXT_visual_info) = glxewGetExtension("GLX_EXT_visual_info");

7829

#endif /* GLX_EXT_visual_info */

7830

#ifdef GLX_EXT_visual_rating

7831

CONST_CAST(GLXEW_EXT_visual_rating) = glxewGetExtension("GLX_EXT_visual_rating");

7832

#endif /* GLX_EXT_visual_rating */

7833

#ifdef GLX_MESA_agp_offset

7834

CONST_CAST(GLXEW_MESA_agp_offset) = glxewGetExtension("GLX_MESA_agp_offset");

7835

if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);

7836

#endif /* GLX_MESA_agp_offset */

7837

#ifdef GLX_MESA_copy_sub_buffer

7838

CONST_CAST(GLXEW_MESA_copy_sub_buffer) = glxewGetExtension("GLX_MESA_copy_sub_buffer");

7839

if (glewExperimental || GLXEW_MESA_copy_sub_buffer) CONST_CAST(GLXEW_MESA_copy_sub_buffer) = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

7840

#endif /* GLX_MESA_copy_sub_buffer */

7841

#ifdef GLX_MESA_pixmap_colormap

7842

CONST_CAST(GLXEW_MESA_pixmap_colormap) = glxewGetExtension("GLX_MESA_pixmap_colormap");

7843

if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT);

7844

#endif /* GLX_MESA_pixmap_colormap */

7845

#ifdef GLX_MESA_release_buffers

7846

CONST_CAST(GLXEW_MESA_release_buffers) = glxewGetExtension("GLX_MESA_release_buffers");

7847

if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

7848

#endif /* GLX_MESA_release_buffers */

7849

#ifdef GLX_MESA_set_3dfx_mode

7850

CONST_CAST(GLXEW_MESA_set_3dfx_mode) = glxewGetExtension("GLX_MESA_set_3dfx_mode");

7851

if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT);

7852

#endif /* GLX_MESA_set_3dfx_mode */

7853

#ifdef GLX_NV_float_buffer

7854

CONST_CAST(GLXEW_NV_float_buffer) = glxewGetExtension("GLX_NV_float_buffer");

7855

#endif /* GLX_NV_float_buffer */

7856

#ifdef GLX_NV_vertex_array_range

7857

CONST_CAST(GLXEW_NV_vertex_array_range) = glxewGetExtension("GLX_NV_vertex_array_range");

7858

if (glewExperimental || GLXEW_NV_vertex_array_range) CONST_CAST(GLXEW_NV_vertex_array_range) = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

7859

#endif /* GLX_NV_vertex_array_range */

7860

#ifdef GLX_OML_swap_method

7861

CONST_CAST(GLXEW_OML_swap_method) = glxewGetExtension("GLX_OML_swap_method");

7862

#endif /* GLX_OML_swap_method */

7863

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

7864

#include <inttypes.h>

7865

CONST_CAST(GLXEW_OML_sync_control) = glxewGetExtension("GLX_OML_sync_control");

7866

if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);

7867

#endif /* GLX_OML_sync_control */

7868

#ifdef GLX_SGIS_blended_overlay

7869

CONST_CAST(GLXEW_SGIS_blended_overlay) = glxewGetExtension("GLX_SGIS_blended_overlay");

7870

#endif /* GLX_SGIS_blended_overlay */

7871

#ifdef GLX_SGIS_color_range

7872

CONST_CAST(GLXEW_SGIS_color_range) = glxewGetExtension("GLX_SGIS_color_range");

7873

#endif /* GLX_SGIS_color_range */

7874

#ifdef GLX_SGIS_multisample

7875

CONST_CAST(GLXEW_SGIS_multisample) = glxewGetExtension("GLX_SGIS_multisample");

7876

#endif /* GLX_SGIS_multisample */

7877

#ifdef GLX_SGIS_shared_multisample

7878

CONST_CAST(GLXEW_SGIS_shared_multisample) = glxewGetExtension("GLX_SGIS_shared_multisample");

7879

#endif /* GLX_SGIS_shared_multisample */

7880

#ifdef GLX_SGIX_fbconfig

7881

CONST_CAST(GLXEW_SGIX_fbconfig) = glxewGetExtension("GLX_SGIX_fbconfig");

7882

if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT);

7883

#endif /* GLX_SGIX_fbconfig */

7884

#ifdef GLX_SGIX_hyperpipe

7885

CONST_CAST(GLXEW_SGIX_hyperpipe) = glxewGetExtension("GLX_SGIX_hyperpipe");

7886

if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT);

7887

#endif /* GLX_SGIX_hyperpipe */

7888

#ifdef GLX_SGIX_pbuffer

7889

CONST_CAST(GLXEW_SGIX_pbuffer) = glxewGetExtension("GLX_SGIX_pbuffer");

7890

if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

7891

#endif /* GLX_SGIX_pbuffer */

7892

#ifdef GLX_SGIX_swap_barrier

7893

CONST_CAST(GLXEW_SGIX_swap_barrier) = glxewGetExtension("GLX_SGIX_swap_barrier");

7894

if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT);

7895

#endif /* GLX_SGIX_swap_barrier */

7896

#ifdef GLX_SGIX_swap_group

7897

CONST_CAST(GLXEW_SGIX_swap_group) = glxewGetExtension("GLX_SGIX_swap_group");

7898

if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);

7899

#endif /* GLX_SGIX_swap_group */

7900

#ifdef GLX_SGIX_video_resize

7901

CONST_CAST(GLXEW_SGIX_video_resize) = glxewGetExtension("GLX_SGIX_video_resize");

7902

if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);

7903

#endif /* GLX_SGIX_video_resize */

7904

#ifdef GLX_SGIX_visual_select_group

7905

CONST_CAST(GLXEW_SGIX_visual_select_group) = glxewGetExtension("GLX_SGIX_visual_select_group");

7906

#endif /* GLX_SGIX_visual_select_group */

7907

#ifdef GLX_SGI_cushion

7908

CONST_CAST(GLXEW_SGI_cushion) = glxewGetExtension("GLX_SGI_cushion");

7909

if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT);

7910

#endif /* GLX_SGI_cushion */

7911

#ifdef GLX_SGI_make_current_read

7912

CONST_CAST(GLXEW_SGI_make_current_read) = glxewGetExtension("GLX_SGI_make_current_read");

7913

if (glewExperimental || GLXEW_SGI_make_current_read) CONST_CAST(GLXEW_SGI_make_current_read) = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

7914

#endif /* GLX_SGI_make_current_read */

7915

#ifdef GLX_SGI_swap_control

7916

CONST_CAST(GLXEW_SGI_swap_control) = glxewGetExtension("GLX_SGI_swap_control");

7917

if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);

7918

#endif /* GLX_SGI_swap_control */

7919

#ifdef GLX_SGI_video_sync

7920

CONST_CAST(GLXEW_SGI_video_sync) = glxewGetExtension("GLX_SGI_video_sync");

7921

if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT);

7922

#endif /* GLX_SGI_video_sync */

7923

#ifdef GLX_SUN_get_transparent_index

7924

CONST_CAST(GLXEW_SUN_get_transparent_index) = glxewGetExtension("GLX_SUN_get_transparent_index");

7925

if (glewExperimental || GLXEW_SUN_get_transparent_index) CONST_CAST(GLXEW_SUN_get_transparent_index) = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT);

7926

#endif /* GLX_SUN_get_transparent_index */

7927

#ifdef GLX_SUN_video_resize

7928

CONST_CAST(GLXEW_SUN_video_resize) = glxewGetExtension("GLX_SUN_video_resize");

7929

if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);

7930

#endif /* GLX_SUN_video_resize */

7931

7932

return GLEW_OK;

7933

}

7934

7935

#endif /* !__APPLE__ || GLEW_APPLE_GLX */

7936

7937

/* ------------------------------------------------------------------------ */

7938

7939

const GLubyte* glewGetErrorString (GLenum error)

7940

{

7941

static const GLubyte* _glewErrorString[] =

7942

{

7943

(const GLubyte*)"No error",

7944

(const GLubyte*)"Missing GL version",

7945

(const GLubyte*)"GL 1.1 and up are not supported",

7946

(const GLubyte*)"GLX 1.2 and up are not supported",

7947

(const GLubyte*)"Unknown error"

7948

};

7949

const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;

7950

return _glewErrorString[(int)error > max_error ? max_error : (int)error];

7951

}

7952

7953

const GLubyte* glewGetString (GLenum name)

7954

{

7955

static const GLubyte* _glewString[] =

7956

{

7957

(const GLubyte*)NULL,

7958

(const GLubyte*)"1.5.0",

7959

(const GLubyte*)"1",

7960

(const GLubyte*)"5",

7961

(const GLubyte*)"0"

7962

};

7963

const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;

7964

return _glewString[(int)name > max_string ? 0 : (int)name];

7965

}

7966

7967

/* ------------------------------------------------------------------------ */

7968

7969

GLboolean glewExperimental = GL_FALSE;

7970

7971

#if !defined(GLEW_MX)

7972

7973

#if defined(_WIN32)

7974

extern GLenum wglewContextInit (void);

7975

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

7976

extern GLenum glxewContextInit (void);

7977

#endif /* _WIN32 */

7978

7979

GLenum glewInit ()

7980

{

7981

GLenum r;

7982

if ( (r = glewContextInit()) ) return r;

7983

#if defined(_WIN32)

7984

return wglewContextInit();

7985

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

7986

return glxewContextInit();

7987

#else

7988

return r;

7989

#endif /* _WIN32 */

7990

}

7991

7992

#endif /* !GLEW_MX */

7993

#ifdef GLEW_MX

7994

GLboolean glewContextIsSupported (GLEWContext* ctx, const char* name)

7995

#else

7996

GLboolean glewIsSupported (const char* name)

7997

#endif

7998

{

7999

GLubyte* pos = (GLubyte*)name;

8000

GLuint len = _glewStrLen(pos);

8001

GLboolean ret = GL_TRUE;

8002

while (ret && len > 0)

8003

{

8004

if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))

8005

{

8006

if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

8007

{

8008

#ifdef GL_VERSION_1_2

8009

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

8010

{

8011

ret = GLEW_VERSION_1_2;

8012

continue;

8013

}

8014

#endif

8015

#ifdef GL_VERSION_1_3

8016

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

8017

{

8018

ret = GLEW_VERSION_1_3;

8019

continue;

8020

}

8021

#endif

8022

#ifdef GL_VERSION_1_4

8023

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

8024

{

8025

ret = GLEW_VERSION_1_4;

8026

continue;

8027

}

8028

#endif

8029

#ifdef GL_VERSION_1_5

8030

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))

8031

{

8032

ret = GLEW_VERSION_1_5;

8033

continue;

8034

}

8035

#endif

8036

#ifdef GL_VERSION_2_0

8037

if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))

8038

{

8039

ret = GLEW_VERSION_2_0;

8040

continue;

8041

}

8042

#endif

8043

#ifdef GL_VERSION_2_1

8044

if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3))

8045

{

8046

ret = GLEW_VERSION_2_1;

8047

continue;

8048

}

8049

#endif

8050

}

8051

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

8052

{

8053

#ifdef GL_3DFX_multisample

8054

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

8055

{

8056

ret = GLEW_3DFX_multisample;

8057

continue;

8058

}

8059

#endif

8060

#ifdef GL_3DFX_tbuffer

8061

if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))

8062

{

8063

ret = GLEW_3DFX_tbuffer;

8064

continue;

8065

}

8066

#endif

8067

#ifdef GL_3DFX_texture_compression_FXT1

8068

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))

8069

{

8070

ret = GLEW_3DFX_texture_compression_FXT1;

8071

continue;

8072

}

8073

#endif

8074

}

8075

if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))

8076

{

8077

#ifdef GL_APPLE_client_storage

8078

if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))

8079

{

8080

ret = GLEW_APPLE_client_storage;

8081

continue;

8082

}

8083

#endif

8084

#ifdef GL_APPLE_element_array

8085

if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

8086

{

8087

ret = GLEW_APPLE_element_array;

8088

continue;

8089

}

8090

#endif

8091

#ifdef GL_APPLE_fence

8092

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

8093

{

8094

ret = GLEW_APPLE_fence;

8095

continue;

8096

}

8097

#endif

8098

#ifdef GL_APPLE_float_pixels

8099

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))

8100

{

8101

ret = GLEW_APPLE_float_pixels;

8102

continue;

8103

}

8104

#endif

8105

#ifdef GL_APPLE_flush_buffer_range

8106

if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18))

8107

{

8108

ret = GLEW_APPLE_flush_buffer_range;

8109

continue;

8110

}

8111

#endif

8112

#ifdef GL_APPLE_pixel_buffer

8113

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))

8114

{

8115

ret = GLEW_APPLE_pixel_buffer;

8116

continue;

8117

}

8118

#endif

8119

#ifdef GL_APPLE_specular_vector

8120

if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))

8121

{

8122

ret = GLEW_APPLE_specular_vector;

8123

continue;

8124

}

8125

#endif

8126

#ifdef GL_APPLE_texture_range

8127

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

8128

{

8129

ret = GLEW_APPLE_texture_range;

8130

continue;

8131

}

8132

#endif

8133

#ifdef GL_APPLE_transform_hint

8134

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))

8135

{

8136

ret = GLEW_APPLE_transform_hint;

8137

continue;

8138

}

8139

#endif

8140

#ifdef GL_APPLE_vertex_array_object

8141

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

8142

{

8143

ret = GLEW_APPLE_vertex_array_object;

8144

continue;

8145

}

8146

#endif

8147

#ifdef GL_APPLE_vertex_array_range

8148

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

8149

{

8150

ret = GLEW_APPLE_vertex_array_range;

8151

continue;

8152

}

8153

#endif

8154

#ifdef GL_APPLE_ycbcr_422

8155

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))

8156

{

8157

ret = GLEW_APPLE_ycbcr_422;

8158

continue;

8159

}

8160

#endif

8161

}

8162

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

8163

{

8164

#ifdef GL_ARB_color_buffer_float

8165

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))

8166

{

8167

ret = GLEW_ARB_color_buffer_float;

8168

continue;

8169

}

8170

#endif

8171

#ifdef GL_ARB_depth_texture

8172

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

8173

{

8174

ret = GLEW_ARB_depth_texture;

8175

continue;

8176

}

8177

#endif

8178

#ifdef GL_ARB_draw_buffers

8179

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

8180

{

8181

ret = GLEW_ARB_draw_buffers;

8182

continue;

8183

}

8184

#endif

8185

#ifdef GL_ARB_fragment_program

8186

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

8187

{

8188

ret = GLEW_ARB_fragment_program;

8189

continue;

8190

}

8191

#endif

8192

#ifdef GL_ARB_fragment_program_shadow

8193

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))

8194

{

8195

ret = GLEW_ARB_fragment_program_shadow;

8196

continue;

8197

}

8198

#endif

8199

#ifdef GL_ARB_fragment_shader

8200

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

8201

{

8202

ret = GLEW_ARB_fragment_shader;

8203

continue;

8204

}

8205

#endif

8206

#ifdef GL_ARB_half_float_pixel

8207

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))

8208

{

8209

ret = GLEW_ARB_half_float_pixel;

8210

continue;

8211

}

8212

#endif

8213

#ifdef GL_ARB_imaging

8214

if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))

8215

{

8216

ret = GLEW_ARB_imaging;

8217

continue;

8218

}

8219

#endif

8220

#ifdef GL_ARB_matrix_palette

8221

if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))

8222

{

8223

ret = GLEW_ARB_matrix_palette;

8224

continue;

8225

}

8226

#endif

8227

#ifdef GL_ARB_multisample

8228

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

8229

{

8230

ret = GLEW_ARB_multisample;

8231

continue;

8232

}

8233

#endif

8234

#ifdef GL_ARB_multitexture

8235

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))

8236

{

8237

ret = GLEW_ARB_multitexture;

8238

continue;

8239

}

8240

#endif

8241

#ifdef GL_ARB_occlusion_query

8242

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

8243

{

8244

ret = GLEW_ARB_occlusion_query;

8245

continue;

8246

}

8247

#endif

8248

#ifdef GL_ARB_pixel_buffer_object

8249

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

8250

{

8251

ret = GLEW_ARB_pixel_buffer_object;

8252

continue;

8253

}

8254

#endif

8255

#ifdef GL_ARB_point_parameters

8256

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

8257

{

8258

ret = GLEW_ARB_point_parameters;

8259

continue;

8260

}

8261

#endif

8262

#ifdef GL_ARB_point_sprite

8263

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

8264

{

8265

ret = GLEW_ARB_point_sprite;

8266

continue;

8267

}

8268

#endif

8269

#ifdef GL_ARB_shader_objects

8270

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))

8271

{

8272

ret = GLEW_ARB_shader_objects;

8273

continue;

8274

}

8275

#endif

8276

#ifdef GL_ARB_shading_language_100

8277

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))

8278

{

8279

ret = GLEW_ARB_shading_language_100;

8280

continue;

8281

}

8282

#endif

8283

#ifdef GL_ARB_shadow

8284

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

8285

{

8286

ret = GLEW_ARB_shadow;

8287

continue;

8288

}

8289

#endif

8290

#ifdef GL_ARB_shadow_ambient

8291

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

8292

{

8293

ret = GLEW_ARB_shadow_ambient;

8294

continue;

8295

}

8296

#endif

8297

#ifdef GL_ARB_texture_border_clamp

8298

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

8299

{

8300

ret = GLEW_ARB_texture_border_clamp;

8301

continue;

8302

}

8303

#endif

8304

#ifdef GL_ARB_texture_compression

8305

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))

8306

{

8307

ret = GLEW_ARB_texture_compression;

8308

continue;

8309

}

8310

#endif

8311

#ifdef GL_ARB_texture_cube_map

8312

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

8313

{

8314

ret = GLEW_ARB_texture_cube_map;

8315

continue;

8316

}

8317

#endif

8318

#ifdef GL_ARB_texture_env_add

8319

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

8320

{

8321

ret = GLEW_ARB_texture_env_add;

8322

continue;

8323

}

8324

#endif

8325

#ifdef GL_ARB_texture_env_combine

8326

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

8327

{

8328

ret = GLEW_ARB_texture_env_combine;

8329

continue;

8330

}

8331

#endif

8332

#ifdef GL_ARB_texture_env_crossbar

8333

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))

8334

{

8335

ret = GLEW_ARB_texture_env_crossbar;

8336

continue;

8337

}

8338

#endif

8339

#ifdef GL_ARB_texture_env_dot3

8340

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

8341

{

8342

ret = GLEW_ARB_texture_env_dot3;

8343

continue;

8344

}

8345

#endif

8346

#ifdef GL_ARB_texture_float

8347

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

8348

{

8349

ret = GLEW_ARB_texture_float;

8350

continue;

8351

}

8352

#endif

8353

#ifdef GL_ARB_texture_mirrored_repeat

8354

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

8355

{

8356

ret = GLEW_ARB_texture_mirrored_repeat;

8357

continue;

8358

}

8359

#endif

8360

#ifdef GL_ARB_texture_non_power_of_two

8361

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))

8362

{

8363

ret = GLEW_ARB_texture_non_power_of_two;

8364

continue;

8365

}

8366

#endif

8367

#ifdef GL_ARB_texture_rectangle

8368

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

8369

{

8370

ret = GLEW_ARB_texture_rectangle;

8371

continue;

8372

}

8373

#endif

8374

#ifdef GL_ARB_transpose_matrix

8375

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))

8376

{

8377

ret = GLEW_ARB_transpose_matrix;

8378

continue;

8379

}

8380

#endif

8381

#ifdef GL_ARB_vertex_blend

8382

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))

8383

{

8384

ret = GLEW_ARB_vertex_blend;

8385

continue;

8386

}

8387

#endif

8388

#ifdef GL_ARB_vertex_buffer_object

8389

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))

8390

{

8391

ret = GLEW_ARB_vertex_buffer_object;

8392

continue;

8393

}

8394

#endif

8395

#ifdef GL_ARB_vertex_program

8396

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

8397

{

8398

ret = GLEW_ARB_vertex_program;

8399

continue;

8400

}

8401

#endif

8402

#ifdef GL_ARB_vertex_shader

8403

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

8404

{

8405

ret = GLEW_ARB_vertex_shader;

8406

continue;

8407

}

8408

#endif

8409

#ifdef GL_ARB_window_pos

8410

if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

8411

{

8412

ret = GLEW_ARB_window_pos;

8413

continue;

8414

}

8415

#endif

8416

}

8417

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))

8418

{

8419

#ifdef GL_ATIX_point_sprites

8420

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))

8421

{

8422

ret = GLEW_ATIX_point_sprites;

8423

continue;

8424

}

8425

#endif

8426

#ifdef GL_ATIX_texture_env_combine3

8427

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

8428

{

8429

ret = GLEW_ATIX_texture_env_combine3;

8430

continue;

8431

}

8432

#endif

8433

#ifdef GL_ATIX_texture_env_route

8434

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))

8435

{

8436

ret = GLEW_ATIX_texture_env_route;

8437

continue;

8438

}

8439

#endif

8440

#ifdef GL_ATIX_vertex_shader_output_point_size

8441

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))

8442

{

8443

ret = GLEW_ATIX_vertex_shader_output_point_size;

8444

continue;

8445

}

8446

#endif

8447

}

8448

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

8449

{

8450

#ifdef GL_ATI_draw_buffers

8451

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

8452

{

8453

ret = GLEW_ATI_draw_buffers;

8454

continue;

8455

}

8456

#endif

8457

#ifdef GL_ATI_element_array

8458

if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

8459

{

8460

ret = GLEW_ATI_element_array;

8461

continue;

8462

}

8463

#endif

8464

#ifdef GL_ATI_envmap_bumpmap

8465

if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))

8466

{

8467

ret = GLEW_ATI_envmap_bumpmap;

8468

continue;

8469

}

8470

#endif

8471

#ifdef GL_ATI_fragment_shader

8472

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

8473

{

8474

ret = GLEW_ATI_fragment_shader;

8475

continue;

8476

}

8477

#endif

8478

#ifdef GL_ATI_map_object_buffer

8479

if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))

8480

{

8481

ret = GLEW_ATI_map_object_buffer;

8482

continue;

8483

}

8484

#endif

8485

#ifdef GL_ATI_pn_triangles

8486

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))

8487

{

8488

ret = GLEW_ATI_pn_triangles;

8489

continue;

8490

}

8491

#endif

8492

#ifdef GL_ATI_separate_stencil

8493

if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))

8494

{

8495

ret = GLEW_ATI_separate_stencil;

8496

continue;

8497

}

8498

#endif

8499

#ifdef GL_ATI_shader_texture_lod

8500

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))

8501

{

8502

ret = GLEW_ATI_shader_texture_lod;

8503

continue;

8504

}

8505

#endif

8506

#ifdef GL_ATI_text_fragment_shader

8507

if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))

8508

{

8509

ret = GLEW_ATI_text_fragment_shader;

8510

continue;

8511

}

8512

#endif

8513

#ifdef GL_ATI_texture_compression_3dc

8514

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))

8515

{

8516

ret = GLEW_ATI_texture_compression_3dc;

8517

continue;

8518

}

8519

#endif

8520

#ifdef GL_ATI_texture_env_combine3

8521

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

8522

{

8523

ret = GLEW_ATI_texture_env_combine3;

8524

continue;

8525

}

8526

#endif

8527

#ifdef GL_ATI_texture_float

8528

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

8529

{

8530

ret = GLEW_ATI_texture_float;

8531

continue;

8532

}

8533

#endif

8534

#ifdef GL_ATI_texture_mirror_once

8535

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))

8536

{

8537

ret = GLEW_ATI_texture_mirror_once;

8538

continue;

8539

}

8540

#endif

8541

#ifdef GL_ATI_vertex_array_object

8542

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

8543

{

8544

ret = GLEW_ATI_vertex_array_object;

8545

continue;

8546

}

8547

#endif

8548

#ifdef GL_ATI_vertex_attrib_array_object

8549

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))

8550

{

8551

ret = GLEW_ATI_vertex_attrib_array_object;

8552

continue;

8553

}

8554

#endif

8555

#ifdef GL_ATI_vertex_streams

8556

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))

8557

{

8558

ret = GLEW_ATI_vertex_streams;

8559

continue;

8560

}

8561

#endif

8562

}

8563

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

8564

{

8565

#ifdef GL_EXT_422_pixels

8566

if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))

8567

{

8568

ret = GLEW_EXT_422_pixels;

8569

continue;

8570

}

8571

#endif

8572

#ifdef GL_EXT_Cg_shader

8573

if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))

8574

{

8575

ret = GLEW_EXT_Cg_shader;

8576

continue;

8577

}

8578

#endif

8579

#ifdef GL_EXT_abgr

8580

if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))

8581

{

8582

ret = GLEW_EXT_abgr;

8583

continue;

8584

}

8585

#endif

8586

#ifdef GL_EXT_bgra

8587

if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))

8588

{

8589

ret = GLEW_EXT_bgra;

8590

continue;

8591

}

8592

#endif

8593

#ifdef GL_EXT_bindable_uniform

8594

if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16))

8595

{

8596

ret = GLEW_EXT_bindable_uniform;

8597

continue;

8598

}

8599

#endif

8600

#ifdef GL_EXT_blend_color

8601

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))

8602

{

8603

ret = GLEW_EXT_blend_color;

8604

continue;

8605

}

8606

#endif

8607

#ifdef GL_EXT_blend_equation_separate

8608

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))

8609

{

8610

ret = GLEW_EXT_blend_equation_separate;

8611

continue;

8612

}

8613

#endif

8614

#ifdef GL_EXT_blend_func_separate

8615

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))

8616

{

8617

ret = GLEW_EXT_blend_func_separate;

8618

continue;

8619

}

8620

#endif

8621

#ifdef GL_EXT_blend_logic_op

8622

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))

8623

{

8624

ret = GLEW_EXT_blend_logic_op;

8625

continue;

8626

}

8627

#endif

8628

#ifdef GL_EXT_blend_minmax

8629

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))

8630

{

8631

ret = GLEW_EXT_blend_minmax;

8632

continue;

8633

}

8634

#endif

8635

#ifdef GL_EXT_blend_subtract

8636

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))

8637

{

8638

ret = GLEW_EXT_blend_subtract;

8639

continue;

8640

}

8641

#endif

8642

#ifdef GL_EXT_clip_volume_hint

8643

if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))

8644

{

8645

ret = GLEW_EXT_clip_volume_hint;

8646

continue;

8647

}

8648

#endif

8649

#ifdef GL_EXT_cmyka

8650

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))

8651

{

8652

ret = GLEW_EXT_cmyka;

8653

continue;

8654

}

8655

#endif

8656

#ifdef GL_EXT_color_subtable

8657

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))

8658

{

8659

ret = GLEW_EXT_color_subtable;

8660

continue;

8661

}

8662

#endif

8663

#ifdef GL_EXT_compiled_vertex_array

8664

if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))

8665

{

8666

ret = GLEW_EXT_compiled_vertex_array;

8667

continue;

8668

}

8669

#endif

8670

#ifdef GL_EXT_convolution

8671

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))

8672

{

8673

ret = GLEW_EXT_convolution;

8674

continue;

8675

}

8676

#endif

8677

#ifdef GL_EXT_coordinate_frame

8678

if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))

8679

{

8680

ret = GLEW_EXT_coordinate_frame;

8681

continue;

8682

}

8683

#endif

8684

#ifdef GL_EXT_copy_texture

8685

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))

8686

{

8687

ret = GLEW_EXT_copy_texture;

8688

continue;

8689

}

8690

#endif

8691

#ifdef GL_EXT_cull_vertex

8692

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

8693

{

8694

ret = GLEW_EXT_cull_vertex;

8695

continue;

8696

}

8697

#endif

8698

#ifdef GL_EXT_depth_bounds_test

8699

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))

8700

{

8701

ret = GLEW_EXT_depth_bounds_test;

8702

continue;

8703

}

8704

#endif

8705

#ifdef GL_EXT_draw_buffers2

8706

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13))

8707

{

8708

ret = GLEW_EXT_draw_buffers2;

8709

continue;

8710

}

8711

#endif

8712

#ifdef GL_EXT_draw_instanced

8713

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))

8714

{

8715

ret = GLEW_EXT_draw_instanced;

8716

continue;

8717

}

8718

#endif

8719

#ifdef GL_EXT_draw_range_elements

8720

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))

8721

{

8722

ret = GLEW_EXT_draw_range_elements;

8723

continue;

8724

}

8725

#endif

8726

#ifdef GL_EXT_fog_coord

8727

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))

8728

{

8729

ret = GLEW_EXT_fog_coord;

8730

continue;

8731

}

8732

#endif

8733

#ifdef GL_EXT_fragment_lighting

8734

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))

8735

{

8736

ret = GLEW_EXT_fragment_lighting;

8737

continue;

8738

}

8739

#endif

8740

#ifdef GL_EXT_framebuffer_blit

8741

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))

8742

{

8743

ret = GLEW_EXT_framebuffer_blit;

8744

continue;

8745

}

8746

#endif

8747

#ifdef GL_EXT_framebuffer_multisample

8748

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))

8749

{

8750

ret = GLEW_EXT_framebuffer_multisample;

8751

continue;

8752

}

8753

#endif

8754

#ifdef GL_EXT_framebuffer_object

8755

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))

8756

{

8757

ret = GLEW_EXT_framebuffer_object;

8758

continue;

8759

}

8760

#endif

8761

#ifdef GL_EXT_framebuffer_sRGB

8762

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

8763

{

8764

ret = GLEW_EXT_framebuffer_sRGB;

8765

continue;

8766

}

8767

#endif

8768

#ifdef GL_EXT_geometry_shader4

8769

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

8770

{

8771

ret = GLEW_EXT_geometry_shader4;

8772

continue;

8773

}

8774

#endif

8775

#ifdef GL_EXT_gpu_program_parameters

8776

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22))

8777

{

8778

ret = GLEW_EXT_gpu_program_parameters;

8779

continue;

8780

}

8781

#endif

8782

#ifdef GL_EXT_gpu_shader4

8783

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11))

8784

{

8785

ret = GLEW_EXT_gpu_shader4;

8786

continue;

8787

}

8788

#endif

8789

#ifdef GL_EXT_histogram

8790

if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))

8791

{

8792

ret = GLEW_EXT_histogram;

8793

continue;

8794

}

8795

#endif

8796

#ifdef GL_EXT_index_array_formats

8797

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))

8798

{

8799

ret = GLEW_EXT_index_array_formats;

8800

continue;

8801

}

8802

#endif

8803

#ifdef GL_EXT_index_func

8804

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))

8805

{

8806

ret = GLEW_EXT_index_func;

8807

continue;

8808

}

8809

#endif

8810

#ifdef GL_EXT_index_material

8811

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))

8812

{

8813

ret = GLEW_EXT_index_material;

8814

continue;

8815

}

8816

#endif

8817

#ifdef GL_EXT_index_texture

8818

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))

8819

{

8820

ret = GLEW_EXT_index_texture;

8821

continue;

8822

}

8823

#endif

8824

#ifdef GL_EXT_light_texture

8825

if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))

8826

{

8827

ret = GLEW_EXT_light_texture;

8828

continue;

8829

}

8830

#endif

8831

#ifdef GL_EXT_misc_attribute

8832

if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))

8833

{

8834

ret = GLEW_EXT_misc_attribute;

8835

continue;

8836

}

8837

#endif

8838

#ifdef GL_EXT_multi_draw_arrays

8839

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))

8840

{

8841

ret = GLEW_EXT_multi_draw_arrays;

8842

continue;

8843

}

8844

#endif

8845

#ifdef GL_EXT_multisample

8846

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

8847

{

8848

ret = GLEW_EXT_multisample;

8849

continue;

8850

}

8851

#endif

8852

#ifdef GL_EXT_packed_depth_stencil

8853

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

8854

{

8855

ret = GLEW_EXT_packed_depth_stencil;

8856

continue;

8857

}

8858

#endif

8859

#ifdef GL_EXT_packed_float

8860

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))

8861

{

8862

ret = GLEW_EXT_packed_float;

8863

continue;

8864

}

8865

#endif

8866

#ifdef GL_EXT_packed_pixels

8867

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))

8868

{

8869

ret = GLEW_EXT_packed_pixels;

8870

continue;

8871

}

8872

#endif

8873

#ifdef GL_EXT_paletted_texture

8874

if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))

8875

{

8876

ret = GLEW_EXT_paletted_texture;

8877

continue;

8878

}

8879

#endif

8880

#ifdef GL_EXT_pixel_buffer_object

8881

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

8882

{

8883

ret = GLEW_EXT_pixel_buffer_object;

8884

continue;

8885

}

8886

#endif

8887

#ifdef GL_EXT_pixel_transform

8888

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))

8889

{

8890

ret = GLEW_EXT_pixel_transform;

8891

continue;

8892

}

8893

#endif

8894

#ifdef GL_EXT_pixel_transform_color_table

8895

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))

8896

{

8897

ret = GLEW_EXT_pixel_transform_color_table;

8898

continue;

8899

}

8900

#endif

8901

#ifdef GL_EXT_point_parameters

8902

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

8903

{

8904

ret = GLEW_EXT_point_parameters;

8905

continue;

8906

}

8907

#endif

8908

#ifdef GL_EXT_polygon_offset

8909

if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))

8910

{

8911

ret = GLEW_EXT_polygon_offset;

8912

continue;

8913

}

8914

#endif

8915

#ifdef GL_EXT_rescale_normal

8916

if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))

8917

{

8918

ret = GLEW_EXT_rescale_normal;

8919

continue;

8920

}

8921

#endif

8922

#ifdef GL_EXT_scene_marker

8923

if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

8924

{

8925

ret = GLEW_EXT_scene_marker;

8926

continue;

8927

}

8928

#endif

8929

#ifdef GL_EXT_secondary_color

8930

if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))

8931

{

8932

ret = GLEW_EXT_secondary_color;

8933

continue;

8934

}

8935

#endif

8936

#ifdef GL_EXT_separate_specular_color

8937

if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))

8938

{

8939

ret = GLEW_EXT_separate_specular_color;

8940

continue;

8941

}

8942

#endif

8943

#ifdef GL_EXT_shadow_funcs

8944

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))

8945

{

8946

ret = GLEW_EXT_shadow_funcs;

8947

continue;

8948

}

8949

#endif

8950

#ifdef GL_EXT_shared_texture_palette

8951

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))

8952

{

8953

ret = GLEW_EXT_shared_texture_palette;

8954

continue;

8955

}

8956

#endif

8957

#ifdef GL_EXT_stencil_clear_tag

8958

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17))

8959

{

8960

ret = GLEW_EXT_stencil_clear_tag;

8961

continue;

8962

}

8963

#endif

8964

#ifdef GL_EXT_stencil_two_side

8965

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))

8966

{

8967

ret = GLEW_EXT_stencil_two_side;

8968

continue;

8969

}

8970

#endif

8971

#ifdef GL_EXT_stencil_wrap

8972

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))

8973

{

8974

ret = GLEW_EXT_stencil_wrap;

8975

continue;

8976

}

8977

#endif

8978

#ifdef GL_EXT_subtexture

8979

if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))

8980

{

8981

ret = GLEW_EXT_subtexture;

8982

continue;

8983

}

8984

#endif

8985

#ifdef GL_EXT_texture

8986

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))

8987

{

8988

ret = GLEW_EXT_texture;

8989

continue;

8990

}

8991

#endif

8992

#ifdef GL_EXT_texture3D

8993

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))

8994

{

8995

ret = GLEW_EXT_texture3D;

8996

continue;

8997

}

8998

#endif

8999

#ifdef GL_EXT_texture_array

9000

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))

9001

{

9002

ret = GLEW_EXT_texture_array;

9003

continue;

9004

}

9005

#endif

9006

#ifdef GL_EXT_texture_buffer_object

9007

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))

9008

{

9009

ret = GLEW_EXT_texture_buffer_object;

9010

continue;

9011

}

9012

#endif

9013

#ifdef GL_EXT_texture_compression_dxt1

9014

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))

9015

{

9016

ret = GLEW_EXT_texture_compression_dxt1;

9017

continue;

9018

}

9019

#endif

9020

#ifdef GL_EXT_texture_compression_latc

9021

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))

9022

{

9023

ret = GLEW_EXT_texture_compression_latc;

9024

continue;

9025

}

9026

#endif

9027

#ifdef GL_EXT_texture_compression_rgtc

9028

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))

9029

{

9030

ret = GLEW_EXT_texture_compression_rgtc;

9031

continue;

9032

}

9033

#endif

9034

#ifdef GL_EXT_texture_compression_s3tc

9035

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))

9036

{

9037

ret = GLEW_EXT_texture_compression_s3tc;

9038

continue;

9039

}

9040

#endif

9041

#ifdef GL_EXT_texture_cube_map

9042

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

9043

{

9044

ret = GLEW_EXT_texture_cube_map;

9045

continue;

9046

}

9047

#endif

9048

#ifdef GL_EXT_texture_edge_clamp

9049

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

9050

{

9051

ret = GLEW_EXT_texture_edge_clamp;

9052

continue;

9053

}

9054

#endif

9055

#ifdef GL_EXT_texture_env

9056

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))

9057

{

9058

ret = GLEW_EXT_texture_env;

9059

continue;

9060

}

9061

#endif

9062

#ifdef GL_EXT_texture_env_add

9063

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

9064

{

9065

ret = GLEW_EXT_texture_env_add;

9066

continue;

9067

}

9068

#endif

9069

#ifdef GL_EXT_texture_env_combine

9070

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

9071

{

9072

ret = GLEW_EXT_texture_env_combine;

9073

continue;

9074

}

9075

#endif

9076

#ifdef GL_EXT_texture_env_dot3

9077

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

9078

{

9079

ret = GLEW_EXT_texture_env_dot3;

9080

continue;

9081

}

9082

#endif

9083

#ifdef GL_EXT_texture_filter_anisotropic

9084

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))

9085

{

9086

ret = GLEW_EXT_texture_filter_anisotropic;

9087

continue;

9088

}

9089

#endif

9090

#ifdef GL_EXT_texture_integer

9091

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15))

9092

{

9093

ret = GLEW_EXT_texture_integer;

9094

continue;

9095

}

9096

#endif

9097

#ifdef GL_EXT_texture_lod_bias

9098

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

9099

{

9100

ret = GLEW_EXT_texture_lod_bias;

9101

continue;

9102

}

9103

#endif

9104

#ifdef GL_EXT_texture_mirror_clamp

9105

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))

9106

{

9107

ret = GLEW_EXT_texture_mirror_clamp;

9108

continue;

9109

}

9110

#endif

9111

#ifdef GL_EXT_texture_object

9112

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))

9113

{

9114

ret = GLEW_EXT_texture_object;

9115

continue;

9116

}

9117

#endif

9118

#ifdef GL_EXT_texture_perturb_normal

9119

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))

9120

{

9121

ret = GLEW_EXT_texture_perturb_normal;

9122

continue;

9123

}

9124

#endif

9125

#ifdef GL_EXT_texture_rectangle

9126

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

9127

{

9128

ret = GLEW_EXT_texture_rectangle;

9129

continue;

9130

}

9131

#endif

9132

#ifdef GL_EXT_texture_sRGB

9133

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12))

9134

{

9135

ret = GLEW_EXT_texture_sRGB;

9136

continue;

9137

}

9138

#endif

9139

#ifdef GL_EXT_texture_shared_exponent

9140

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23))

9141

{

9142

ret = GLEW_EXT_texture_shared_exponent;

9143

continue;

9144

}

9145

#endif

9146

#ifdef GL_EXT_timer_query

9147

if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))

9148

{

9149

ret = GLEW_EXT_timer_query;

9150

continue;

9151

}

9152

#endif

9153

#ifdef GL_EXT_vertex_array

9154

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))

9155

{

9156

ret = GLEW_EXT_vertex_array;

9157

continue;

9158

}

9159

#endif

9160

#ifdef GL_EXT_vertex_shader

9161

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

9162

{

9163

ret = GLEW_EXT_vertex_shader;

9164

continue;

9165

}

9166

#endif

9167

#ifdef GL_EXT_vertex_weighting

9168

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))

9169

{

9170

ret = GLEW_EXT_vertex_weighting;

9171

continue;

9172

}

9173

#endif

9174

}

9175

if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8))

9176

{

9177

#ifdef GL_GREMEDY_frame_terminator

9178

if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16))

9179

{

9180

ret = GLEW_GREMEDY_frame_terminator;

9181

continue;

9182

}

9183

#endif

9184

#ifdef GL_GREMEDY_string_marker

9185

if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13))

9186

{

9187

ret = GLEW_GREMEDY_string_marker;

9188

continue;

9189

}

9190

#endif

9191

}

9192

if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))

9193

{

9194

#ifdef GL_HP_convolution_border_modes

9195

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

9196

{

9197

ret = GLEW_HP_convolution_border_modes;

9198

continue;

9199

}

9200

#endif

9201

#ifdef GL_HP_image_transform

9202

if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))

9203

{

9204

ret = GLEW_HP_image_transform;

9205

continue;

9206

}

9207

#endif

9208

#ifdef GL_HP_occlusion_test

9209

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))

9210

{

9211

ret = GLEW_HP_occlusion_test;

9212

continue;

9213

}

9214

#endif

9215

#ifdef GL_HP_texture_lighting

9216

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))

9217

{

9218

ret = GLEW_HP_texture_lighting;

9219

continue;

9220

}

9221

#endif

9222

}

9223

if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))

9224

{

9225

#ifdef GL_IBM_cull_vertex

9226

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

9227

{

9228

ret = GLEW_IBM_cull_vertex;

9229

continue;

9230

}

9231

#endif

9232

#ifdef GL_IBM_multimode_draw_arrays

9233

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))

9234

{

9235

ret = GLEW_IBM_multimode_draw_arrays;

9236

continue;

9237

}

9238

#endif

9239

#ifdef GL_IBM_rasterpos_clip

9240

if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))

9241

{

9242

ret = GLEW_IBM_rasterpos_clip;

9243

continue;

9244

}

9245

#endif

9246

#ifdef GL_IBM_static_data

9247

if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))

9248

{

9249

ret = GLEW_IBM_static_data;

9250

continue;

9251

}

9252

#endif

9253

#ifdef GL_IBM_texture_mirrored_repeat

9254

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

9255

{

9256

ret = GLEW_IBM_texture_mirrored_repeat;

9257

continue;

9258

}

9259

#endif

9260

#ifdef GL_IBM_vertex_array_lists

9261

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))

9262

{

9263

ret = GLEW_IBM_vertex_array_lists;

9264

continue;

9265

}

9266

#endif

9267

}

9268

if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))

9269

{

9270

#ifdef GL_INGR_color_clamp

9271

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))

9272

{

9273

ret = GLEW_INGR_color_clamp;

9274

continue;

9275

}

9276

#endif

9277

#ifdef GL_INGR_interlace_read

9278

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))

9279

{

9280

ret = GLEW_INGR_interlace_read;

9281

continue;

9282

}

9283

#endif

9284

}

9285

if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))

9286

{

9287

#ifdef GL_INTEL_parallel_arrays

9288

if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))

9289

{

9290

ret = GLEW_INTEL_parallel_arrays;

9291

continue;

9292

}

9293

#endif

9294

#ifdef GL_INTEL_texture_scissor

9295

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))

9296

{

9297

ret = GLEW_INTEL_texture_scissor;

9298

continue;

9299

}

9300

#endif

9301

}

9302

if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))

9303

{

9304

#ifdef GL_KTX_buffer_region

9305

if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

9306

{

9307

ret = GLEW_KTX_buffer_region;

9308

continue;

9309

}

9310

#endif

9311

}

9312

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6))

9313

{

9314

#ifdef GL_MESAX_texture_stack

9315

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13))

9316

{

9317

ret = GLEW_MESAX_texture_stack;

9318

continue;

9319

}

9320

#endif

9321

}

9322

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

9323

{

9324

#ifdef GL_MESA_pack_invert

9325

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))

9326

{

9327

ret = GLEW_MESA_pack_invert;

9328

continue;

9329

}

9330

#endif

9331

#ifdef GL_MESA_resize_buffers

9332

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))

9333

{

9334

ret = GLEW_MESA_resize_buffers;

9335

continue;

9336

}

9337

#endif

9338

#ifdef GL_MESA_window_pos

9339

if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

9340

{

9341

ret = GLEW_MESA_window_pos;

9342

continue;

9343

}

9344

#endif

9345

#ifdef GL_MESA_ycbcr_texture

9346

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))

9347

{

9348

ret = GLEW_MESA_ycbcr_texture;

9349

continue;

9350

}

9351

#endif

9352

}

9353

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

9354

{

9355

#ifdef GL_NV_blend_square

9356

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))

9357

{

9358

ret = GLEW_NV_blend_square;

9359

continue;

9360

}

9361

#endif

9362

#ifdef GL_NV_copy_depth_to_color

9363

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))

9364

{

9365

ret = GLEW_NV_copy_depth_to_color;

9366

continue;

9367

}

9368

#endif

9369

#ifdef GL_NV_depth_buffer_float

9370

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))

9371

{

9372

ret = GLEW_NV_depth_buffer_float;

9373

continue;

9374

}

9375

#endif

9376

#ifdef GL_NV_depth_clamp

9377

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))

9378

{

9379

ret = GLEW_NV_depth_clamp;

9380

continue;

9381

}

9382

#endif

9383

#ifdef GL_NV_depth_range_unclamped

9384

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21))

9385

{

9386

ret = GLEW_NV_depth_range_unclamped;

9387

continue;

9388

}

9389

#endif

9390

#ifdef GL_NV_evaluators

9391

if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))

9392

{

9393

ret = GLEW_NV_evaluators;

9394

continue;

9395

}

9396

#endif

9397

#ifdef GL_NV_fence

9398

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

9399

{

9400

ret = GLEW_NV_fence;

9401

continue;

9402

}

9403

#endif

9404

#ifdef GL_NV_float_buffer

9405

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

9406

{

9407

ret = GLEW_NV_float_buffer;

9408

continue;

9409

}

9410

#endif

9411

#ifdef GL_NV_fog_distance

9412

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))

9413

{

9414

ret = GLEW_NV_fog_distance;

9415

continue;

9416

}

9417

#endif

9418

#ifdef GL_NV_fragment_program

9419

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

9420

{

9421

ret = GLEW_NV_fragment_program;

9422

continue;

9423

}

9424

#endif

9425

#ifdef GL_NV_fragment_program2

9426

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))

9427

{

9428

ret = GLEW_NV_fragment_program2;

9429

continue;

9430

}

9431

#endif

9432

#ifdef GL_NV_fragment_program4

9433

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17))

9434

{

9435

ret = GLEW_NV_fragment_program4;

9436

continue;

9437

}

9438

#endif

9439

#ifdef GL_NV_fragment_program_option

9440

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))

9441

{

9442

ret = GLEW_NV_fragment_program_option;

9443

continue;

9444

}

9445

#endif

9446

#ifdef GL_NV_framebuffer_multisample_coverage

9447

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32))

9448

{

9449

ret = GLEW_NV_framebuffer_multisample_coverage;

9450

continue;

9451

}

9452

#endif

9453

#ifdef GL_NV_geometry_program4

9454

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17))

9455

{

9456

ret = GLEW_NV_geometry_program4;

9457

continue;

9458

}

9459

#endif

9460

#ifdef GL_NV_geometry_shader4

9461

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

9462

{

9463

ret = GLEW_NV_geometry_shader4;

9464

continue;

9465

}

9466

#endif

9467

#ifdef GL_NV_gpu_program4

9468

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12))

9469

{

9470

ret = GLEW_NV_gpu_program4;

9471

continue;

9472

}

9473

#endif

9474

#ifdef GL_NV_half_float

9475

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))

9476

{

9477

ret = GLEW_NV_half_float;

9478

continue;

9479

}

9480

#endif

9481

#ifdef GL_NV_light_max_exponent

9482

if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))

9483

{

9484

ret = GLEW_NV_light_max_exponent;

9485

continue;

9486

}

9487

#endif

9488

#ifdef GL_NV_multisample_filter_hint

9489

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))

9490

{

9491

ret = GLEW_NV_multisample_filter_hint;

9492

continue;

9493

}

9494

#endif

9495

#ifdef GL_NV_occlusion_query

9496

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

9497

{

9498

ret = GLEW_NV_occlusion_query;

9499

continue;

9500

}

9501

#endif

9502

#ifdef GL_NV_packed_depth_stencil

9503

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

9504

{

9505

ret = GLEW_NV_packed_depth_stencil;

9506

continue;

9507

}

9508

#endif

9509

#ifdef GL_NV_parameter_buffer_object

9510

if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23))

9511

{

9512

ret = GLEW_NV_parameter_buffer_object;

9513

continue;

9514

}

9515

#endif

9516

#ifdef GL_NV_pixel_data_range

9517

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))

9518

{

9519

ret = GLEW_NV_pixel_data_range;

9520

continue;

9521

}

9522

#endif

9523

#ifdef GL_NV_point_sprite

9524

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

9525

{

9526

ret = GLEW_NV_point_sprite;

9527

continue;

9528

}

9529

#endif

9530

#ifdef GL_NV_primitive_restart

9531

if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))

9532

{

9533

ret = GLEW_NV_primitive_restart;

9534

continue;

9535

}

9536

#endif

9537

#ifdef GL_NV_register_combiners

9538

if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))

9539

{

9540

ret = GLEW_NV_register_combiners;

9541

continue;

9542

}

9543

#endif

9544

#ifdef GL_NV_register_combiners2

9545

if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))

9546

{

9547

ret = GLEW_NV_register_combiners2;

9548

continue;

9549

}

9550

#endif

9551

#ifdef GL_NV_texgen_emboss

9552

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))

9553

{

9554

ret = GLEW_NV_texgen_emboss;

9555

continue;

9556

}

9557

#endif

9558

#ifdef GL_NV_texgen_reflection

9559

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))

9560

{

9561

ret = GLEW_NV_texgen_reflection;

9562

continue;

9563

}

9564

#endif

9565

#ifdef GL_NV_texture_compression_vtc

9566

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))

9567

{

9568

ret = GLEW_NV_texture_compression_vtc;

9569

continue;

9570

}

9571

#endif

9572

#ifdef GL_NV_texture_env_combine4

9573

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))

9574

{

9575

ret = GLEW_NV_texture_env_combine4;

9576

continue;

9577

}

9578

#endif

9579

#ifdef GL_NV_texture_expand_normal

9580

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))

9581

{

9582

ret = GLEW_NV_texture_expand_normal;

9583

continue;

9584

}

9585

#endif

9586

#ifdef GL_NV_texture_rectangle

9587

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

9588

{

9589

ret = GLEW_NV_texture_rectangle;

9590

continue;

9591

}

9592

#endif

9593

#ifdef GL_NV_texture_shader

9594

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))

9595

{

9596

ret = GLEW_NV_texture_shader;

9597

continue;

9598

}

9599

#endif

9600

#ifdef GL_NV_texture_shader2

9601

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))

9602

{

9603

ret = GLEW_NV_texture_shader2;

9604

continue;

9605

}

9606

#endif

9607

#ifdef GL_NV_texture_shader3

9608

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))

9609

{

9610

ret = GLEW_NV_texture_shader3;

9611

continue;

9612

}

9613

#endif

9614

#ifdef GL_NV_transform_feedback

9615

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))

9616

{

9617

ret = GLEW_NV_transform_feedback;

9618

continue;

9619

}

9620

#endif

9621

#ifdef GL_NV_vertex_array_range

9622

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

9623

{

9624

ret = GLEW_NV_vertex_array_range;

9625

continue;

9626

}

9627

#endif

9628

#ifdef GL_NV_vertex_array_range2

9629

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))

9630

{

9631

ret = GLEW_NV_vertex_array_range2;

9632

continue;

9633

}

9634

#endif

9635

#ifdef GL_NV_vertex_program

9636

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

9637

{

9638

ret = GLEW_NV_vertex_program;

9639

continue;

9640

}

9641

#endif

9642

#ifdef GL_NV_vertex_program1_1

9643

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))

9644

{

9645

ret = GLEW_NV_vertex_program1_1;

9646

continue;

9647

}

9648

#endif

9649

#ifdef GL_NV_vertex_program2

9650

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))

9651

{

9652

ret = GLEW_NV_vertex_program2;

9653

continue;

9654

}

9655

#endif

9656

#ifdef GL_NV_vertex_program2_option

9657

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))

9658

{

9659

ret = GLEW_NV_vertex_program2_option;

9660

continue;

9661

}

9662

#endif

9663

#ifdef GL_NV_vertex_program3

9664

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))

9665

{

9666

ret = GLEW_NV_vertex_program3;

9667

continue;

9668

}

9669

#endif

9670

#ifdef GL_NV_vertex_program4

9671

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15))

9672

{

9673

ret = GLEW_NV_vertex_program4;

9674

continue;

9675

}

9676

#endif

9677

}

9678

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4))

9679

{

9680

#ifdef GL_OES_byte_coordinates

9681

if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16))

9682

{

9683

ret = GLEW_OES_byte_coordinates;

9684

continue;

9685

}

9686

#endif

9687

#ifdef GL_OES_compressed_paletted_texture

9688

if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27))

9689

{

9690

ret = GLEW_OES_compressed_paletted_texture;

9691

continue;

9692

}

9693

#endif

9694

#ifdef GL_OES_read_format

9695

if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11))

9696

{

9697

ret = GLEW_OES_read_format;

9698

continue;

9699

}

9700

#endif

9701

#ifdef GL_OES_single_precision

9702

if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16))

9703

{

9704

ret = GLEW_OES_single_precision;

9705

continue;

9706

}

9707

#endif

9708

}

9709

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

9710

{

9711

#ifdef GL_OML_interlace

9712

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

9713

{

9714

ret = GLEW_OML_interlace;

9715

continue;

9716

}

9717

#endif

9718

#ifdef GL_OML_resample

9719

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

9720

{

9721

ret = GLEW_OML_resample;

9722

continue;

9723

}

9724

#endif

9725

#ifdef GL_OML_subsample

9726

if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))

9727

{

9728

ret = GLEW_OML_subsample;

9729

continue;

9730

}

9731

#endif

9732

}

9733

if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))

9734

{

9735

#ifdef GL_PGI_misc_hints

9736

if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))

9737

{

9738

ret = GLEW_PGI_misc_hints;

9739

continue;

9740

}

9741

#endif

9742

#ifdef GL_PGI_vertex_hints

9743

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))

9744

{

9745

ret = GLEW_PGI_vertex_hints;

9746

continue;

9747

}

9748

#endif

9749

}

9750

if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))

9751

{

9752

#ifdef GL_REND_screen_coordinates

9753

if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))

9754

{

9755

ret = GLEW_REND_screen_coordinates;

9756

continue;

9757

}

9758

#endif

9759

}

9760

if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))

9761

{

9762

#ifdef GL_S3_s3tc

9763

if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))

9764

{

9765

ret = GLEW_S3_s3tc;

9766

continue;

9767

}

9768

#endif

9769

}

9770

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

9771

{

9772

#ifdef GL_SGIS_color_range

9773

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

9774

{

9775

ret = GLEW_SGIS_color_range;

9776

continue;

9777

}

9778

#endif

9779

#ifdef GL_SGIS_detail_texture

9780

if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))

9781

{

9782

ret = GLEW_SGIS_detail_texture;

9783

continue;

9784

}

9785

#endif

9786

#ifdef GL_SGIS_fog_function

9787

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))

9788

{

9789

ret = GLEW_SGIS_fog_function;

9790

continue;

9791

}

9792

#endif

9793

#ifdef GL_SGIS_generate_mipmap

9794

if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))

9795

{

9796

ret = GLEW_SGIS_generate_mipmap;

9797

continue;

9798

}

9799

#endif

9800

#ifdef GL_SGIS_multisample

9801

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9802

{

9803

ret = GLEW_SGIS_multisample;

9804

continue;

9805

}

9806

#endif

9807

#ifdef GL_SGIS_pixel_texture

9808

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

9809

{

9810

ret = GLEW_SGIS_pixel_texture;

9811

continue;

9812

}

9813

#endif

9814

#ifdef GL_SGIS_sharpen_texture

9815

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))

9816

{

9817

ret = GLEW_SGIS_sharpen_texture;

9818

continue;

9819

}

9820

#endif

9821

#ifdef GL_SGIS_texture4D

9822

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))

9823

{

9824

ret = GLEW_SGIS_texture4D;

9825

continue;

9826

}

9827

#endif

9828

#ifdef GL_SGIS_texture_border_clamp

9829

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

9830

{

9831

ret = GLEW_SGIS_texture_border_clamp;

9832

continue;

9833

}

9834

#endif

9835

#ifdef GL_SGIS_texture_edge_clamp

9836

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

9837

{

9838

ret = GLEW_SGIS_texture_edge_clamp;

9839

continue;

9840

}

9841

#endif

9842

#ifdef GL_SGIS_texture_filter4

9843

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))

9844

{

9845

ret = GLEW_SGIS_texture_filter4;

9846

continue;

9847

}

9848

#endif

9849

#ifdef GL_SGIS_texture_lod

9850

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))

9851

{

9852

ret = GLEW_SGIS_texture_lod;

9853

continue;

9854

}

9855

#endif

9856

#ifdef GL_SGIS_texture_select

9857

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))

9858

{

9859

ret = GLEW_SGIS_texture_select;

9860

continue;

9861

}

9862

#endif

9863

}

9864

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

9865

{

9866

#ifdef GL_SGIX_async

9867

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))

9868

{

9869

ret = GLEW_SGIX_async;

9870

continue;

9871

}

9872

#endif

9873

#ifdef GL_SGIX_async_histogram

9874

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))

9875

{

9876

ret = GLEW_SGIX_async_histogram;

9877

continue;

9878

}

9879

#endif

9880

#ifdef GL_SGIX_async_pixel

9881

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))

9882

{

9883

ret = GLEW_SGIX_async_pixel;

9884

continue;

9885

}

9886

#endif

9887

#ifdef GL_SGIX_blend_alpha_minmax

9888

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))

9889

{

9890

ret = GLEW_SGIX_blend_alpha_minmax;

9891

continue;

9892

}

9893

#endif

9894

#ifdef GL_SGIX_clipmap

9895

if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))

9896

{

9897

ret = GLEW_SGIX_clipmap;

9898

continue;

9899

}

9900

#endif

9901

#ifdef GL_SGIX_depth_texture

9902

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

9903

{

9904

ret = GLEW_SGIX_depth_texture;

9905

continue;

9906

}

9907

#endif

9908

#ifdef GL_SGIX_flush_raster

9909

if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))

9910

{

9911

ret = GLEW_SGIX_flush_raster;

9912

continue;

9913

}

9914

#endif

9915

#ifdef GL_SGIX_fog_offset

9916

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))

9917

{

9918

ret = GLEW_SGIX_fog_offset;

9919

continue;

9920

}

9921

#endif

9922

#ifdef GL_SGIX_fog_texture

9923

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))

9924

{

9925

ret = GLEW_SGIX_fog_texture;

9926

continue;

9927

}

9928

#endif

9929

#ifdef GL_SGIX_fragment_specular_lighting

9930

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))

9931

{

9932

ret = GLEW_SGIX_fragment_specular_lighting;

9933

continue;

9934

}

9935

#endif

9936

#ifdef GL_SGIX_framezoom

9937

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))

9938

{

9939

ret = GLEW_SGIX_framezoom;

9940

continue;

9941

}

9942

#endif

9943

#ifdef GL_SGIX_interlace

9944

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

9945

{

9946

ret = GLEW_SGIX_interlace;

9947

continue;

9948

}

9949

#endif

9950

#ifdef GL_SGIX_ir_instrument1

9951

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))

9952

{

9953

ret = GLEW_SGIX_ir_instrument1;

9954

continue;

9955

}

9956

#endif

9957

#ifdef GL_SGIX_list_priority

9958

if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))

9959

{

9960

ret = GLEW_SGIX_list_priority;

9961

continue;

9962

}

9963

#endif

9964

#ifdef GL_SGIX_pixel_texture

9965

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

9966

{

9967

ret = GLEW_SGIX_pixel_texture;

9968

continue;

9969

}

9970

#endif

9971

#ifdef GL_SGIX_pixel_texture_bits

9972

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))

9973

{

9974

ret = GLEW_SGIX_pixel_texture_bits;

9975

continue;

9976

}

9977

#endif

9978

#ifdef GL_SGIX_reference_plane

9979

if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))

9980

{

9981

ret = GLEW_SGIX_reference_plane;

9982

continue;

9983

}

9984

#endif

9985

#ifdef GL_SGIX_resample

9986

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

9987

{

9988

ret = GLEW_SGIX_resample;

9989

continue;

9990

}

9991

#endif

9992

#ifdef GL_SGIX_shadow

9993

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

9994

{

9995

ret = GLEW_SGIX_shadow;

9996

continue;

9997

}

9998

#endif

9999

#ifdef GL_SGIX_shadow_ambient

10000

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

10001

{

10002

ret = GLEW_SGIX_shadow_ambient;

10003

continue;

10004

}

10005

#endif

10006

#ifdef GL_SGIX_sprite

10007

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))

10008

{

10009

ret = GLEW_SGIX_sprite;

10010

continue;

10011

}

10012

#endif

10013

#ifdef GL_SGIX_tag_sample_buffer

10014

if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))

10015

{

10016

ret = GLEW_SGIX_tag_sample_buffer;

10017

continue;

10018

}

10019

#endif

10020

#ifdef GL_SGIX_texture_add_env

10021

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))

10022

{

10023

ret = GLEW_SGIX_texture_add_env;

10024

continue;

10025

}

10026

#endif

10027

#ifdef GL_SGIX_texture_coordinate_clamp

10028

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))

10029

{

10030

ret = GLEW_SGIX_texture_coordinate_clamp;

10031

continue;

10032

}

10033

#endif

10034

#ifdef GL_SGIX_texture_lod_bias

10035

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

10036

{

10037

ret = GLEW_SGIX_texture_lod_bias;

10038

continue;

10039

}

10040

#endif

10041

#ifdef GL_SGIX_texture_multi_buffer

10042

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))

10043

{

10044

ret = GLEW_SGIX_texture_multi_buffer;

10045

continue;

10046

}

10047

#endif

10048

#ifdef GL_SGIX_texture_range

10049

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

10050

{

10051

ret = GLEW_SGIX_texture_range;

10052

continue;

10053

}

10054

#endif

10055

#ifdef GL_SGIX_texture_scale_bias

10056

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))

10057

{

10058

ret = GLEW_SGIX_texture_scale_bias;

10059

continue;

10060

}

10061

#endif

10062

#ifdef GL_SGIX_vertex_preclip

10063

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))

10064

{

10065

ret = GLEW_SGIX_vertex_preclip;

10066

continue;

10067

}

10068

#endif

10069

#ifdef GL_SGIX_vertex_preclip_hint

10070

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))

10071

{

10072

ret = GLEW_SGIX_vertex_preclip_hint;

10073

continue;

10074

}

10075

#endif

10076

#ifdef GL_SGIX_ycrcb

10077

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))

10078

{

10079

ret = GLEW_SGIX_ycrcb;

10080

continue;

10081

}

10082

#endif

10083

}

10084

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

10085

{

10086

#ifdef GL_SGI_color_matrix

10087

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))

10088

{

10089

ret = GLEW_SGI_color_matrix;

10090

continue;

10091

}

10092

#endif

10093

#ifdef GL_SGI_color_table

10094

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))

10095

{

10096

ret = GLEW_SGI_color_table;

10097

continue;

10098

}

10099

#endif

10100

#ifdef GL_SGI_texture_color_table

10101

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))

10102

{

10103

ret = GLEW_SGI_texture_color_table;

10104

continue;

10105

}

10106

#endif

10107

}

10108

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))

10109

{

10110

#ifdef GL_SUNX_constant_data

10111

if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))

10112

{

10113

ret = GLEW_SUNX_constant_data;

10114

continue;

10115

}

10116

#endif

10117

}

10118

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

10119

{

10120

#ifdef GL_SUN_convolution_border_modes

10121

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

10122

{

10123

ret = GLEW_SUN_convolution_border_modes;

10124

continue;

10125

}

10126

#endif

10127

#ifdef GL_SUN_global_alpha

10128

if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))

10129

{

10130

ret = GLEW_SUN_global_alpha;

10131

continue;

10132

}

10133

#endif

10134

#ifdef GL_SUN_mesh_array

10135

if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))

10136

{

10137

ret = GLEW_SUN_mesh_array;

10138

continue;

10139

}

10140

#endif

10141

#ifdef GL_SUN_read_video_pixels

10142

if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))

10143

{

10144

ret = GLEW_SUN_read_video_pixels;

10145

continue;

10146

}

10147

#endif

10148

#ifdef GL_SUN_slice_accum

10149

if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))

10150

{

10151

ret = GLEW_SUN_slice_accum;

10152

continue;

10153

}

10154

#endif

10155

#ifdef GL_SUN_triangle_list

10156

if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))

10157

{

10158

ret = GLEW_SUN_triangle_list;

10159

continue;

10160

}

10161

#endif

10162

#ifdef GL_SUN_vertex

10163

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))

10164

{

10165

ret = GLEW_SUN_vertex;

10166

continue;

10167

}

10168

#endif

10169

}

10170

if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))

10171

{

10172

#ifdef GL_WIN_phong_shading

10173

if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))

10174

{

10175

ret = GLEW_WIN_phong_shading;

10176

continue;

10177

}

10178

#endif

10179

#ifdef GL_WIN_specular_fog

10180

if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))

10181

{

10182

ret = GLEW_WIN_specular_fog;

10183

continue;

10184

}

10185

#endif

10186

#ifdef GL_WIN_swap_hint

10187

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))

10188

{

10189

ret = GLEW_WIN_swap_hint;

10190

continue;

10191

}

10192

#endif

10193

}

10194

}

10195

ret = (len == 0);

10196

}

10197

return ret;

10198

}

10199

10200

#if defined(_WIN32)

10201

10202

#if defined(GLEW_MX)

10203

GLboolean wglewContextIsSupported (WGLEWContext* ctx, const char* name)

10204

#else

10205

GLboolean wglewIsSupported (const char* name)

10206

#endif

10207

{

10208

GLubyte* pos = (GLubyte*)name;

10209

GLuint len = _glewStrLen(pos);

10210

GLboolean ret = GL_TRUE;

10211

while (ret && len > 0)

10212

{

10213

if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))

10214

{

10215

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

10216

{

10217

#ifdef WGL_3DFX_multisample

10218

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10219

{

10220

ret = WGLEW_3DFX_multisample;

10221

continue;

10222

}

10223

#endif

10224

}

10225

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4))

10226

{

10227

#ifdef WGL_3DL_stereo_control

10228

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14))

10229

{

10230

ret = WGLEW_3DL_stereo_control;

10231

continue;

10232

}

10233

#endif

10234

}

10235

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

10236

{

10237

#ifdef WGL_ARB_buffer_region

10238

if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

10239

{

10240

ret = WGLEW_ARB_buffer_region;

10241

continue;

10242

}

10243

#endif

10244

#ifdef WGL_ARB_extensions_string

10245

if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

10246

{

10247

ret = WGLEW_ARB_extensions_string;

10248

continue;

10249

}

10250

#endif

10251

#ifdef WGL_ARB_make_current_read

10252

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

10253

{

10254

ret = WGLEW_ARB_make_current_read;

10255

continue;

10256

}

10257

#endif

10258

#ifdef WGL_ARB_multisample

10259

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10260

{

10261

ret = WGLEW_ARB_multisample;

10262

continue;

10263

}

10264

#endif

10265

#ifdef WGL_ARB_pbuffer

10266

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

10267

{

10268

ret = WGLEW_ARB_pbuffer;

10269

continue;

10270

}

10271

#endif

10272

#ifdef WGL_ARB_pixel_format

10273

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

10274

{

10275

ret = WGLEW_ARB_pixel_format;

10276

continue;

10277

}

10278

#endif

10279

#ifdef WGL_ARB_pixel_format_float

10280

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

10281

{

10282

ret = WGLEW_ARB_pixel_format_float;

10283

continue;

10284

}

10285

#endif

10286

#ifdef WGL_ARB_render_texture

10287

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

10288

{

10289

ret = WGLEW_ARB_render_texture;

10290

continue;

10291

}

10292

#endif

10293

}

10294

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

10295

{

10296

#ifdef WGL_ATI_pixel_format_float

10297

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

10298

{

10299

ret = WGLEW_ATI_pixel_format_float;

10300

continue;

10301

}

10302

#endif

10303

#ifdef WGL_ATI_render_texture_rectangle

10304

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

10305

{

10306

ret = WGLEW_ATI_render_texture_rectangle;

10307

continue;

10308

}

10309

#endif

10310

}

10311

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

10312

{

10313

#ifdef WGL_EXT_depth_float

10314

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))

10315

{

10316

ret = WGLEW_EXT_depth_float;

10317

continue;

10318

}

10319

#endif

10320

#ifdef WGL_EXT_display_color_table

10321

if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))

10322

{

10323

ret = WGLEW_EXT_display_color_table;

10324

continue;

10325

}

10326

#endif

10327

#ifdef WGL_EXT_extensions_string

10328

if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

10329

{

10330

ret = WGLEW_EXT_extensions_string;

10331

continue;

10332

}

10333

#endif

10334

#ifdef WGL_EXT_framebuffer_sRGB

10335

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

10336

{

10337

ret = WGLEW_EXT_framebuffer_sRGB;

10338

continue;

10339

}

10340

#endif

10341

#ifdef WGL_EXT_make_current_read

10342

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

10343

{

10344

ret = WGLEW_EXT_make_current_read;

10345

continue;

10346

}

10347

#endif

10348

#ifdef WGL_EXT_multisample

10349

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10350

{

10351

ret = WGLEW_EXT_multisample;

10352

continue;

10353

}

10354

#endif

10355

#ifdef WGL_EXT_pbuffer

10356

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

10357

{

10358

ret = WGLEW_EXT_pbuffer;

10359

continue;

10360

}

10361

#endif

10362

#ifdef WGL_EXT_pixel_format

10363

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

10364

{

10365

ret = WGLEW_EXT_pixel_format;

10366

continue;

10367

}

10368

#endif

10369

#ifdef WGL_EXT_pixel_format_packed_float

10370

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25))

10371

{

10372

ret = WGLEW_EXT_pixel_format_packed_float;

10373

continue;

10374

}

10375

#endif

10376

#ifdef WGL_EXT_swap_control

10377

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

10378

{

10379

ret = WGLEW_EXT_swap_control;

10380

continue;

10381

}

10382

#endif

10383

}

10384

if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))

10385

{

10386

#ifdef WGL_I3D_digital_video_control

10387

if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))

10388

{

10389

ret = WGLEW_I3D_digital_video_control;

10390

continue;

10391

}

10392

#endif

10393

#ifdef WGL_I3D_gamma

10394

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))

10395

{

10396

ret = WGLEW_I3D_gamma;

10397

continue;

10398

}

10399

#endif

10400

#ifdef WGL_I3D_genlock

10401

if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))

10402

{

10403

ret = WGLEW_I3D_genlock;

10404

continue;

10405

}

10406

#endif

10407

#ifdef WGL_I3D_image_buffer

10408

if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))

10409

{

10410

ret = WGLEW_I3D_image_buffer;

10411

continue;

10412

}

10413

#endif

10414

#ifdef WGL_I3D_swap_frame_lock

10415

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))

10416

{

10417

ret = WGLEW_I3D_swap_frame_lock;

10418

continue;

10419

}

10420

#endif

10421

#ifdef WGL_I3D_swap_frame_usage

10422

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))

10423

{

10424

ret = WGLEW_I3D_swap_frame_usage;

10425

continue;

10426

}

10427

#endif

10428

}

10429

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

10430

{

10431

#ifdef WGL_NV_float_buffer

10432

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

10433

{

10434

ret = WGLEW_NV_float_buffer;

10435

continue;

10436

}

10437

#endif

10438

#ifdef WGL_NV_gpu_affinity

10439

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12))

10440

{

10441

ret = WGLEW_NV_gpu_affinity;

10442

continue;

10443

}

10444

#endif

10445

#ifdef WGL_NV_render_depth_texture

10446

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))

10447

{

10448

ret = WGLEW_NV_render_depth_texture;

10449

continue;

10450

}

10451

#endif

10452

#ifdef WGL_NV_render_texture_rectangle

10453

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

10454

{

10455

ret = WGLEW_NV_render_texture_rectangle;

10456

continue;

10457

}

10458

#endif

10459

#ifdef WGL_NV_vertex_array_range

10460

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

10461

{

10462

ret = WGLEW_NV_vertex_array_range;

10463

continue;

10464

}

10465

#endif

10466

}

10467

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

10468

{

10469

#ifdef WGL_OML_sync_control

10470

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

10471

{

10472

ret = WGLEW_OML_sync_control;

10473

continue;

10474

}

10475

#endif

10476

}

10477

}

10478

ret = (len == 0);

10479

}

10480

return ret;

10481

}

10482

10483

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

10484

10485

#if defined(GLEW_MX)

10486

GLboolean glxewContextIsSupported (GLXEWContext* ctx, const char* name)

10487

#else

10488

GLboolean glxewIsSupported (const char* name)

10489

#endif

10490

{

10491

GLubyte* pos = (GLubyte*)name;

10492

GLuint len = _glewStrLen(pos);

10493

GLboolean ret = GL_TRUE;

10494

while (ret && len > 0)

10495

{

10496

if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))

10497

{

10498

if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

10499

{

10500

#ifdef GLX_VERSION_1_2

10501

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

10502

{

10503

ret = GLXEW_VERSION_1_2;

10504

continue;

10505

}

10506

#endif

10507

#ifdef GLX_VERSION_1_3

10508

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

10509

{

10510

ret = GLXEW_VERSION_1_3;

10511

continue;

10512

}

10513

#endif

10514

#ifdef GLX_VERSION_1_4

10515

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

10516

{

10517

ret = GLXEW_VERSION_1_4;

10518

continue;

10519

}

10520

#endif

10521

}

10522

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

10523

{

10524

#ifdef GLX_3DFX_multisample

10525

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10526

{

10527

ret = GLXEW_3DFX_multisample;

10528

continue;

10529

}

10530

#endif

10531

}

10532

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

10533

{

10534

#ifdef GLX_ARB_fbconfig_float

10535

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))

10536

{

10537

ret = GLXEW_ARB_fbconfig_float;

10538

continue;

10539

}

10540

#endif

10541

#ifdef GLX_ARB_get_proc_address

10542

if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))

10543

{

10544

ret = GLXEW_ARB_get_proc_address;

10545

continue;

10546

}

10547

#endif

10548

#ifdef GLX_ARB_multisample

10549

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10550

{

10551

ret = GLXEW_ARB_multisample;

10552

continue;

10553

}

10554

#endif

10555

}

10556

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

10557

{

10558

#ifdef GLX_ATI_pixel_format_float

10559

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

10560

{

10561

ret = GLXEW_ATI_pixel_format_float;

10562

continue;

10563

}

10564

#endif

10565

#ifdef GLX_ATI_render_texture

10566

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

10567

{

10568

ret = GLXEW_ATI_render_texture;

10569

continue;

10570

}

10571

#endif

10572

}

10573

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

10574

{

10575

#ifdef GLX_EXT_fbconfig_packed_float

10576

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21))

10577

{

10578

ret = GLXEW_EXT_fbconfig_packed_float;

10579

continue;

10580

}

10581

#endif

10582

#ifdef GLX_EXT_framebuffer_sRGB

10583

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

10584

{

10585

ret = GLXEW_EXT_framebuffer_sRGB;

10586

continue;

10587

}

10588

#endif

10589

#ifdef GLX_EXT_import_context

10590

if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))

10591

{

10592

ret = GLXEW_EXT_import_context;

10593

continue;

10594

}

10595

#endif

10596

#ifdef GLX_EXT_scene_marker

10597

if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

10598

{

10599

ret = GLXEW_EXT_scene_marker;

10600

continue;

10601

}

10602

#endif

10603

#ifdef GLX_EXT_texture_from_pixmap

10604

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))

10605

{

10606

ret = GLXEW_EXT_texture_from_pixmap;

10607

continue;

10608

}

10609

#endif

10610

#ifdef GLX_EXT_visual_info

10611

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))

10612

{

10613

ret = GLXEW_EXT_visual_info;

10614

continue;

10615

}

10616

#endif

10617

#ifdef GLX_EXT_visual_rating

10618

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))

10619

{

10620

ret = GLXEW_EXT_visual_rating;

10621

continue;

10622

}

10623

#endif

10624

}

10625

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

10626

{

10627

#ifdef GLX_MESA_agp_offset

10628

if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))

10629

{

10630

ret = GLXEW_MESA_agp_offset;

10631

continue;

10632

}

10633

#endif

10634

#ifdef GLX_MESA_copy_sub_buffer

10635

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))

10636

{

10637

ret = GLXEW_MESA_copy_sub_buffer;

10638

continue;

10639

}

10640

#endif

10641

#ifdef GLX_MESA_pixmap_colormap

10642

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))

10643

{

10644

ret = GLXEW_MESA_pixmap_colormap;

10645

continue;

10646

}

10647

#endif

10648

#ifdef GLX_MESA_release_buffers

10649

if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))

10650

{

10651

ret = GLXEW_MESA_release_buffers;

10652

continue;

10653

}

10654

#endif

10655

#ifdef GLX_MESA_set_3dfx_mode

10656

if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))

10657

{

10658

ret = GLXEW_MESA_set_3dfx_mode;

10659

continue;

10660

}

10661

#endif

10662

}

10663

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

10664

{

10665

#ifdef GLX_NV_float_buffer

10666

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

10667

{

10668

ret = GLXEW_NV_float_buffer;

10669

continue;

10670

}

10671

#endif

10672

#ifdef GLX_NV_vertex_array_range

10673

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

10674

{

10675

ret = GLXEW_NV_vertex_array_range;

10676

continue;

10677

}

10678

#endif

10679

}

10680

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

10681

{

10682

#ifdef GLX_OML_swap_method

10683

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))

10684

{

10685

ret = GLXEW_OML_swap_method;

10686

continue;

10687

}

10688

#endif

10689

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

10690

#include <inttypes.h>

10691

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

10692

{

10693

ret = GLXEW_OML_sync_control;

10694

continue;

10695

}

10696

#endif

10697

}

10698

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

10699

{

10700

#ifdef GLX_SGIS_blended_overlay

10701

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))

10702

{

10703

ret = GLXEW_SGIS_blended_overlay;

10704

continue;

10705

}

10706

#endif

10707

#ifdef GLX_SGIS_color_range

10708

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

10709

{

10710

ret = GLXEW_SGIS_color_range;

10711

continue;

10712

}

10713

#endif

10714

#ifdef GLX_SGIS_multisample

10715

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10716

{

10717

ret = GLXEW_SGIS_multisample;

10718

continue;

10719

}

10720

#endif

10721

#ifdef GLX_SGIS_shared_multisample

10722

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))

10723

{

10724

ret = GLXEW_SGIS_shared_multisample;

10725

continue;

10726

}

10727

#endif

10728

}

10729

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

10730

{

10731

#ifdef GLX_SGIX_fbconfig

10732

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))

10733

{

10734

ret = GLXEW_SGIX_fbconfig;

10735

continue;

10736

}

10737

#endif

10738

#ifdef GLX_SGIX_hyperpipe

10739

if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9))

10740

{

10741

ret = GLXEW_SGIX_hyperpipe;

10742

continue;

10743

}

10744

#endif

10745

#ifdef GLX_SGIX_pbuffer

10746

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

10747

{

10748

ret = GLXEW_SGIX_pbuffer;

10749

continue;

10750

}

10751

#endif

10752

#ifdef GLX_SGIX_swap_barrier

10753

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))

10754

{

10755

ret = GLXEW_SGIX_swap_barrier;

10756

continue;

10757

}

10758

#endif

10759

#ifdef GLX_SGIX_swap_group

10760

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

10761

{

10762

ret = GLXEW_SGIX_swap_group;

10763

continue;

10764

}

10765

#endif

10766

#ifdef GLX_SGIX_video_resize

10767

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

10768

{

10769

ret = GLXEW_SGIX_video_resize;

10770

continue;

10771

}

10772

#endif

10773

#ifdef GLX_SGIX_visual_select_group

10774

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))

10775

{

10776

ret = GLXEW_SGIX_visual_select_group;

10777

continue;

10778

}

10779

#endif

10780

}

10781

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

10782

{

10783

#ifdef GLX_SGI_cushion

10784

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))

10785

{

10786

ret = GLXEW_SGI_cushion;

10787

continue;

10788

}

10789

#endif

10790

#ifdef GLX_SGI_make_current_read

10791

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

10792

{

10793

ret = GLXEW_SGI_make_current_read;

10794

continue;

10795

}

10796

#endif

10797

#ifdef GLX_SGI_swap_control

10798

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

10799

{

10800

ret = GLXEW_SGI_swap_control;

10801

continue;

10802

}

10803

#endif

10804

#ifdef GLX_SGI_video_sync

10805

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))

10806

{

10807

ret = GLXEW_SGI_video_sync;

10808

continue;

10809

}

10810

#endif

10811

}

10812

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

10813

{

10814

#ifdef GLX_SUN_get_transparent_index

10815

if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))

10816

{

10817

ret = GLXEW_SUN_get_transparent_index;

10818

continue;

10819

}

10820

#endif

10821

#ifdef GLX_SUN_video_resize

10822

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

10823

{

10824

ret = GLXEW_SUN_video_resize;

10825

continue;

10826

}

10827

#endif

10828

}

10829

}

10830

ret = (len == 0);

10831

}

10832

return ret;

10833

}

10834

10835

#endif /* _WIN32 */

1

/*

2

** The OpenGL Extension Wrangler Library

3

4

5

6

7

**

8

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

9

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

10

**

11

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

12

** this list of conditions and the following disclaimer.

13

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

14

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

15

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

16

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

17

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

18

**

19

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

20

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

21

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

22

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

23

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

24

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

25

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

26

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

27

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

28

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

29

** THE POSSIBILITY OF SUCH DAMAGE.

30

*/

31

32

#include <GL/glew.h>

33

#if defined(_WIN32)

34

# include <GL/wglew.h>

35

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

36

# include <GL/glxew.h>

37

#endif

38

39

/*

40

* Define glewGetContext and related helper macros.

41

*/

42

#ifdef GLEW_MX

43

# define glewGetContext() ctx

44

# ifdef _WIN32

45

# define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx

46

# define GLEW_CONTEXT_ARG_VAR_INIT ctx

47

# define wglewGetContext() ctx

48

# define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx

49

# define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx

50

# else /* _WIN32 */

51

# define GLEW_CONTEXT_ARG_DEF_INIT void

52

# define GLEW_CONTEXT_ARG_VAR_INIT

53

# define glxewGetContext() ctx

54

# define GLXEW_CONTEXT_ARG_DEF_INIT void

55

# define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx

56

# endif /* _WIN32 */

57

# define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx

58

#else /* GLEW_MX */

59

# define GLEW_CONTEXT_ARG_DEF_INIT void

60

# define GLEW_CONTEXT_ARG_VAR_INIT

61

# define GLEW_CONTEXT_ARG_DEF_LIST void

62

# define WGLEW_CONTEXT_ARG_DEF_INIT void

63

# define WGLEW_CONTEXT_ARG_DEF_LIST void

64

# define GLXEW_CONTEXT_ARG_DEF_INIT void

65

# define GLXEW_CONTEXT_ARG_DEF_LIST void

66

#endif /* GLEW_MX */

67

68

#if defined(__APPLE__)

69

#include <mach-o/dyld.h>

70

#include <stdlib.h>

71

#include <string.h>

72

73

void* NSGLGetProcAddress (const GLubyte *name)

74

{

75

static const struct mach_header* image = NULL;

76

NSSymbol symbol;

77

char* symbolName;

78

if (NULL == image)

79

{

80

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

81

}

82

/* prepend a '_' for the Unix C symbol mangling convention */

83

symbolName = malloc(strlen((const char*)name) + 2);

84

strcpy(symbolName+1, (const char*)name);

85

symbolName[0] = '_';

86

symbol = NULL;

87

/* if (NSIsSymbolNameDefined(symbolName))

88

symbol = NSLookupAndBindSymbol(symbolName); */

89

symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL;

90

free(symbolName);

91

return symbol ? NSAddressOfSymbol(symbol) : NULL;

92

}

93

#endif /* __APPLE__ */

94

95

#if defined(__sgi) || defined (__sun)

96

#include <dlfcn.h>

97

#include <stdio.h>

98

#include <stdlib.h>

99

100

void* dlGetProcAddress (const GLubyte* name)

101

{

102

static void* h = NULL;

103

static void* gpa;

104

105

if (h == NULL)

106

{

107

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

108

gpa = dlsym(h, "glXGetProcAddress");

109

}

110

111

if (gpa != NULL)

112

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

113

else

114

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

115

}

116

#endif /* __sgi || __sun */

117

118

/*

119

* Define glewGetProcAddress.

120

*/

121

#if defined(_WIN32)

122

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

123

#else

124

# if defined(__APPLE__)

125

# define glewGetProcAddress(name) NSGLGetProcAddress(name)

126

# else

127

# if defined(__sgi) || defined(__sun)

128

# define glewGetProcAddress(name) dlGetProcAddress(name)

129

# else /* __linux */

130

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

131

# endif

132

# endif

133

#endif

134

135

/*

136

* Define GLboolean const cast.

137

*/

138

#define CONST_CAST(x) (*(GLboolean*)&x)

139

140

/*

141

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

142

* These functions implement the functionality required in this file.

143

*/

144

static GLuint _glewStrLen (const GLubyte* s)

145

{

146

GLuint i=0;

147

if (s == NULL) return 0;

148

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

149

return i;

150

}

151

152

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

153

{

154

GLuint i=0;

155

if (s == NULL) return 0;

156

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

157

return (s[i] == '\0' || s[i] == c) ? i : 0;

158

}

159

160

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

161

{

162

GLuint i=0;

163

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

164

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

165

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

166

return i == n ? GL_TRUE : GL_FALSE;

167

}

168

169

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

170

{

171

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

172

{

173

(*a)++;

174

(*na)--;

175

}

176

if(*na >= nb)

177

{

178

GLuint i=0;

179

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

180

if(i == nb)

181

{

182

*a = *a + nb;

183

*na = *na - nb;

184

return GL_TRUE;

185

}

186

}

187

return GL_FALSE;

188

}

189

190

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

191

{

192

if(*na >= nb)

193

{

194

GLuint i=0;

195

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

196

if(i == nb)

197

{

198

*a = *a + nb;

199

*na = *na - nb;

200

return GL_TRUE;

201

}

202

}

203

return GL_FALSE;

204

}

205

206

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

207

{

208

if(*na >= nb)

209

{

210

GLuint i=0;

211

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

212

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

213

{

214

*a = *a + nb;

215

*na = *na - nb;

216

return GL_TRUE;

217

}

218

}

219

return GL_FALSE;

220

}

221

222

#if !defined(_WIN32) || !defined(GLEW_MX)

223

224

PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;

225

PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;

226

PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;

227

PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;

228

229

PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;

230

PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;

231

PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;

232

PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;

233

PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;

234

PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;

235

PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;

236

PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;

237

PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;

238

PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;

239

PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;

240

PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;

241

PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;

242

PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;

243

PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;

244

PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;

245

PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;

246

PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;

247

PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;

248

PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;

249

PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;

250

PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;

251

PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;

252

PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;

253

PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;

254

PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;

255

PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;

256

PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;

257

PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;

258

PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;

259

PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;

260

PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;

261

PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;

262

PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;

263

PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;

264

PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;

265

PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;

266

PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;

267

PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;

268

PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;

269

PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;

270

PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;

271

PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;

272

PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;

273

PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;

274

PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;

275

276

PFNGLBLENDCOLORPROC __glewBlendColor = NULL;

277

PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;

278

PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;

279

PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;

280

PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;

281

PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;

282

PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;

283

PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;

284

PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;

285

PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;

286

PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;

287

PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;

288

PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL;

289

PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL;

290

PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;

291

PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;

292

PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;

293

PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;

294

PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;

295

PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;

296

PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;

297

PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;

298

PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;

299

PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;

300

PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;

301

PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;

302

PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;

303

PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;

304

PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;

305

PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;

306

PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;

307

PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;

308

PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;

309

PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;

310

PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;

311

PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;

312

PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;

313

PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;

314

PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;

315

PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;

316

PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;

317

PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;

318

PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;

319

PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;

320

PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;

321

PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;

322

PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;

323

324

PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;

325

PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;

326

PFNGLBUFFERDATAPROC __glewBufferData = NULL;

327

PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;

328

PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;

329

PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;

330

PFNGLENDQUERYPROC __glewEndQuery = NULL;

331

PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;

332

PFNGLGENQUERIESPROC __glewGenQueries = NULL;

333

PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;

334

PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;

335

PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;

336

PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;

337

PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;

338

PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;

339

PFNGLISBUFFERPROC __glewIsBuffer = NULL;

340

PFNGLISQUERYPROC __glewIsQuery = NULL;

341

PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;

342

PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;

343

344

PFNGLATTACHSHADERPROC __glewAttachShader = NULL;

345

PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;

346

PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;

347

PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;

348

PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;

349

PFNGLCREATESHADERPROC __glewCreateShader = NULL;

350

PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;

351

PFNGLDELETESHADERPROC __glewDeleteShader = NULL;

352

PFNGLDETACHSHADERPROC __glewDetachShader = NULL;

353

PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;

354

PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;

355

PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;

356

PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;

357

PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;

358

PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;

359

PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;

360

PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;

361

PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;

362

PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;

363

PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;

364

PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;

365

PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;

366

PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;

367

PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;

368

PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;

369

PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;

370

PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;

371

PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;

372

PFNGLISPROGRAMPROC __glewIsProgram = NULL;

373

PFNGLISSHADERPROC __glewIsShader = NULL;

374

PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;

375

PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;

376

PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;

377

PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;

378

PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;

379

PFNGLUNIFORM1FPROC __glewUniform1f = NULL;

380

PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;

381

PFNGLUNIFORM1IPROC __glewUniform1i = NULL;

382

PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;

383

PFNGLUNIFORM2FPROC __glewUniform2f = NULL;

384

PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;

385

PFNGLUNIFORM2IPROC __glewUniform2i = NULL;

386

PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;

387

PFNGLUNIFORM3FPROC __glewUniform3f = NULL;

388

PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;

389

PFNGLUNIFORM3IPROC __glewUniform3i = NULL;

390

PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;

391

PFNGLUNIFORM4FPROC __glewUniform4f = NULL;

392

PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;

393

PFNGLUNIFORM4IPROC __glewUniform4i = NULL;

394

PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;

395

PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;

396

PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;

397

PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;

398

PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;

399

PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;

400

PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;

401

PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;

402

PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;

403

PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;

404

PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;

405

PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;

406

PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;

407

PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;

408

PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;

409

PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;

410

PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;

411

PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;

412

PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;

413

PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;

414

PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;

415

PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;

416

PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;

417

PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;

418

PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;

419

PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;

420

PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;

421

PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;

422

PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;

423

PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;

424

PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;

425

PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;

426

PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;

427

PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;

428

PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;

429

PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;

430

PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;

431

PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;

432

PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;

433

PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;

434

PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;

435

PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;

436

PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;

437

438

PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;

439

PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;

440

PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;

441

PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;

442

PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;

443

PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;

444

445

PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL;

446

PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL;

447

PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;

448

PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;

449

PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL;

450

PFNGLCLAMPCOLORPROC __glewClampColor = NULL;

451

PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL;

452

PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL;

453

PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL;

454

PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL;

455

PFNGLCOLORMASKIPROC __glewColorMaski = NULL;

456

PFNGLDISABLEIPROC __glewDisablei = NULL;

457

PFNGLENABLEIPROC __glewEnablei = NULL;

458

PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL;

459

PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL;

460

PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL;

461

PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL;

462

PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;

463

PFNGLGETSTRINGIPROC __glewGetStringi = NULL;

464

PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL;

465

PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL;

466

PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL;

467

PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL;

468

PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL;

469

PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL;

470

PFNGLISENABLEDIPROC __glewIsEnabledi = NULL;

471

PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL;

472

PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL;

473

PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL;

474

PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL;

475

PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL;

476

PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL;

477

PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL;

478

PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL;

479

PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL;

480

PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL;

481

PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL;

482

PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL;

483

PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL;

484

PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL;

485

PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL;

486

PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL;

487

PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL;

488

PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL;

489

PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL;

490

PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL;

491

PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL;

492

PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL;

493

PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL;

494

PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL;

495

PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL;

496

PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL;

497

PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL;

498

PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL;

499

PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL;

500

PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL;

501

PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL;

502

PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL;

503

504

PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;

505

506

PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;

507

PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;

508

PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;

509

PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;

510

PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;

511

512

PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;

513

PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;

514

PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;

515

PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;

516

PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;

517

PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;

518

PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;

519

PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;

520

521

PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;

522

PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;

523

524

PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;

525

PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;

526

527

PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;

528

PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;

529

PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;

530

PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;

531

532

PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;

533

PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;

534

PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;

535

536

PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;

537

538

PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;

539

540

PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL;

541

PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL;

542

543

PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL;

544

PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL;

545

PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL;

546

PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL;

547

PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL;

548

PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL;

549

PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL;

550

PFNGLFRAMEBUFFERTEXTURLAYERPROC __glewFramebufferTexturLayer = NULL;

551

PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL;

552

PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL;

553

PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL;

554

PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL;

555

PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL;

556

PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL;

557

PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL;

558

PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL;

559

PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL;

560

PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL;

561

PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL;

562

PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL;

563

564

PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL;

565

PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL;

566

PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL;

567

PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL;

568

569

PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;

570

PFNGLCOLORTABLEPROC __glewColorTable = NULL;

571

PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;

572

PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;

573

PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;

574

PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;

575

PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;

576

PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;

577

PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;

578

PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;

579

PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;

580

PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;

581

PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;

582

PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;

583

PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;

584

PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;

585

PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;

586

PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;

587

PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;

588

PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;

589

PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;

590

PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;

591

PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;

592

PFNGLGETMINMAXPROC __glewGetMinmax = NULL;

593

PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;

594

PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;

595

PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;

596

PFNGLHISTOGRAMPROC __glewHistogram = NULL;

597

PFNGLMINMAXPROC __glewMinmax = NULL;

598

PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;

599

PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;

600

PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;

601

602

PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL;

603

604

PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL;

605

PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL;

606

607

PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;

608

PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;

609

PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;

610

PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;

611

PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;

612

613

PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;

614

615

PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;

616

PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;

617

PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;

618

PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;

619

PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;

620

PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;

621

PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;

622

PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;

623

PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;

624

PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;

625

PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;

626

PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;

627

PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;

628

PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;

629

PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;

630

PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;

631

PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;

632

PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;

633

PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;

634

PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;

635

PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;

636

PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;

637

PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;

638

PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;

639

PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;

640

PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;

641

PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;

642

PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;

643

PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;

644

PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;

645

PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;

646

PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;

647

PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;

648

PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;

649

650

PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;

651

PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;

652

PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;

653

PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;

654

PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;

655

PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;

656

PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;

657

PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;

658

659

PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;

660

PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;

661

662

PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;

663

PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;

664

PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;

665

PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;

666

PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;

667

PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;

668

PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;

669

PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;

670

PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;

671

PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;

672

PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;

673

PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;

674

PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;

675

PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;

676

PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;

677

PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;

678

PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;

679

PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;

680

PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;

681

PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;

682

PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;

683

PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;

684

PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;

685

PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;

686

PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;

687

PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;

688

PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;

689

PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;

690

PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;

691

PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;

692

PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;

693

PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;

694

PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;

695

PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;

696

PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;

697

PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;

698

PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;

699

PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;

700

PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;

701

702

PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL;

703

704

PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;

705

PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;

706

PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;

707

PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;

708

PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;

709

PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;

710

PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;

711

712

PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;

713

PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;

714

PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;

715

PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;

716

717

PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL;

718

PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL;

719

PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL;

720

PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL;

721

722

PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;

723

PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;

724

PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;

725

PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;

726

PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;

727

PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;

728

PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;

729

PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;

730

PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;

731

PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;

732

733

PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;

734

PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;

735

PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;

736

PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;

737

PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;

738

PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;

739

PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;

740

PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;

741

PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;

742

PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;

743

PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;

744

745

PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;

746

PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;

747

PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;

748

PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;

749

PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;

750

PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;

751

PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;

752

PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;

753

PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;

754

PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;

755

PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;

756

PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;

757

PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;

758

PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;

759

PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;

760

PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;

761

PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;

762

PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;

763

PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;

764

PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;

765

PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;

766

PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;

767

PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;

768

PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;

769

PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;

770

PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;

771

PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;

772

PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;

773

PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;

774

PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;

775

PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;

776

PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;

777

PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;

778

PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;

779

PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;

780

PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;

781

PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;

782

PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;

783

PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;

784

PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;

785

PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;

786

PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;

787

PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;

788

PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;

789

PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;

790

PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;

791

PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;

792

PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;

793

PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;

794

PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;

795

PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;

796

PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;

797

PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;

798

PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;

799

PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;

800

PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;

801

PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;

802

PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;

803

PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;

804

PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;

805

PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;

806

PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;

807

808

PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;

809

PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;

810

PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;

811

812

PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;

813

PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;

814

PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;

815

PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;

816

PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;

817

PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;

818

PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;

819

PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;

820

PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;

821

PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;

822

PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;

823

PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;

824

PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;

825

PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;

826

PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;

827

PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;

828

829

PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;

830

831

PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;

832

PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;

833

PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;

834

835

PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;

836

PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;

837

PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;

838

PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;

839

840

PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;

841

PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;

842

PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;

843

PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;

844

PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;

845

PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;

846

PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;

847

PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;

848

PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;

849

PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;

850

PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;

851

PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;

852

PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;

853

PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;

854

855

PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;

856

PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;

857

858

PFNGLPNTRIANGLESFATIPROC __glPNTrianglewesfATI = NULL;

859

PFNGLPNTRIANGLESIATIPROC __glPNTrianglewesiATI = NULL;

860

861

PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;

862

PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;

863

864

PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;

865

PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;

866

PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;

867

PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;

868

PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;

869

PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;

870

PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;

871

PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;

872

PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;

873

PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;

874

PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;

875

PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;

876

877

PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;

878

PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;

879

PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;

880

881

PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;

882

PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;

883

PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;

884

PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;

885

PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;

886

PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;

887

PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;

888

PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;

889

PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;

890

PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;

891

PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;

892

PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;

893

PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;

894

PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;

895

PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;

896

PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;

897

PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;

898

PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;

899

PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;

900

PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;

901

PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;

902

PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;

903

PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;

904

PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;

905

PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;

906

PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;

907

PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;

908

PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;

909

PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;

910

PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;

911

PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;

912

PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;

913

PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;

914

PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;

915

PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;

916

PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;

917

PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;

918

919

PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL;

920

PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL;

921

PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL;

922

923

PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;

924

925

PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;

926

927

PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;

928

929

PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;

930

931

PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;

932

PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;

933

934

PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;

935

PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;

936

937

PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;

938

PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;

939

PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;

940

PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;

941

PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;

942

PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;

943

PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;

944

PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;

945

PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;

946

PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;

947

PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;

948

PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;

949

PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;

950

951

PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;

952

PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;

953

954

PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;

955

PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;

956

PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;

957

PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;

958

PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;

959

960

PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;

961

PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;

962

963

PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;

964

965

PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL;

966

PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL;

967

PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL;

968

PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL;

969

PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL;

970

PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL;

971

PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL;

972

PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL;

973

PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL;

974

PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL;

975

PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL;

976

PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL;

977

PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL;

978

PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL;

979

PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL;

980

PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL;

981

PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL;

982

PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL;

983

PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL;

984

PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL;

985

PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL;

986

PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL;

987

PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL;

988

PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL;

989

PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL;

990

PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL;

991

PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL;

992

PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL;

993

PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL;

994

PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL;

995

PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL;

996

PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL;

997

PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL;

998

PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL;

999

PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL;

1000

PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL;

1001

PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL;

1002

PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL;

1003

PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL;

1004

PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL;

1005

PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL;

1006

PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL;

1007

PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL;

1008

PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL;

1009

PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL;

1010

PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL;

1011

PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL;

1012

PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL;

1013

PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL;

1014

PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL;

1015

PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL;

1016

PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL;

1017

PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL;

1018

PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL;

1019

PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL;

1020

PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL;

1021

PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL;

1022

PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL;

1023

PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL;

1024

PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL;

1025

PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL;

1026

PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL;

1027

PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL;

1028

PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL;

1029

PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL;

1030

PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL;

1031

PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL;

1032

PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL;

1033

PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL;

1034

PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL;

1035

PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL;

1036

PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL;

1037

PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL;

1038

PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL;

1039

PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL;

1040

PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL;

1041

PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL;

1042

PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL;

1043

PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL;

1044

PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL;

1045

PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL;

1046

PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL;

1047

PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL;

1048

PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL;

1049

PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL;

1050

PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL;

1051

PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL;

1052

PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL;

1053

PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL;

1054

PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL;

1055

PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL;

1056

PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL;

1057

PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL;

1058

PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL;

1059

PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL;

1060

PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL;

1061

PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL;

1062

PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL;

1063

PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL;

1064

PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL;

1065

PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL;

1066

PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL;

1067

PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL;

1068

PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL;

1069

PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL;

1070

PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL;

1071

PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL;

1072

PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL;

1073

PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL;

1074

PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL;

1075

PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL;

1076

PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;

1077

PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;

1078

PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;

1079

PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;

1080

PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;

1081

PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL;

1082

PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL;

1083

PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL;

1084

PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL;

1085

PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL;

1086

PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL;

1087

PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL;

1088

PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL;

1089

PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL;

1090

PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL;

1091

PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL;

1092

PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL;

1093

PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL;

1094

PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL;

1095

PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL;

1096

PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL;

1097

PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL;

1098

PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL;

1099

PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL;

1100

PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL;

1101

PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL;

1102

PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL;

1103

PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL;

1104

PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL;

1105

PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL;

1106

PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL;

1107

PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL;

1108

PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL;

1109

PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL;

1110

PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL;

1111

PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL;

1112

PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL;

1113

PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL;

1114

PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL;

1115

PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL;

1116

PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL;

1117

PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL;

1118

PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL;

1119

PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL;

1120

PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL;

1121

PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL;

1122

PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL;

1123

PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL;

1124

PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL;

1125

PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL;

1126

PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL;

1127

PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL;

1128

PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL;

1129

PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL;

1130

PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL;

1131

PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL;

1132

PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL;

1133

PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL;

1134

PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL;

1135

PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL;

1136

PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL;

1137

PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL;

1138

PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL;

1139

PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL;

1140

PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL;

1141

PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL;

1142

PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL;

1143

PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL;

1144

PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL;

1145

PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL;

1146

PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL;

1147

PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL;

1148

PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL;

1149

PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL;

1150

PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL;

1151

1152

PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;

1153

PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;

1154

PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL;

1155

PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL;

1156

PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL;

1157

PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL;

1158

1159

PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL;

1160

PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL;

1161

1162

PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;

1163

1164

PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;

1165

PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;

1166

PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;

1167

PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;

1168

PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;

1169

1170

PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;

1171

PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;

1172

PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;

1173

PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;

1174

PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;

1175

PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;

1176

PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;

1177

PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;

1178

PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;

1179

PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;

1180

PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;

1181

PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;

1182

PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;

1183

PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;

1184

PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;

1185

PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;

1186

PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;

1187

PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;

1188

1189

PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;

1190

1191

PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;

1192

1193

PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;

1194

PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;

1195

PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;

1196

PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;

1197

PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;

1198

PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;

1199

PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;

1200

PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;

1201

PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;

1202

PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;

1203

PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;

1204

PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;

1205

PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;

1206

PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;

1207

PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;

1208

PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;

1209

PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;

1210

1211

PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL;

1212

PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL;

1213

PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL;

1214

PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL;

1215

1216

PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL;

1217

PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL;

1218

1219

PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL;

1220

PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL;

1221

PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL;

1222

PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL;

1223

PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL;

1224

PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL;

1225

PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL;

1226

PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL;

1227

PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL;

1228

PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL;

1229

PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL;

1230

PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL;

1231

PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL;

1232

PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL;

1233

PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL;

1234

PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL;

1235

PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL;

1236

PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL;

1237

PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL;

1238

PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL;

1239

PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL;

1240

PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL;

1241

PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL;

1242

PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL;

1243

PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL;

1244

PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL;

1245

PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL;

1246

PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL;

1247

PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL;

1248

PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL;

1249

PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL;

1250

PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL;

1251

PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL;

1252

PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL;

1253

1254

PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;

1255

PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;

1256

PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;

1257

PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;

1258

PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;

1259

PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;

1260

PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;

1261

PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;

1262

PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;

1263

PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;

1264

1265

PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;

1266

1267

PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;

1268

1269

PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;

1270

PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;

1271

PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;

1272

1273

PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;

1274

PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;

1275

1276

PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;

1277

PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;

1278

1279

PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;

1280

PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;

1281

PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;

1282

PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;

1283

1284

PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;

1285

PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;

1286

PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;

1287

PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;

1288

PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;

1289

PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;

1290

1291

PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;

1292

PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;

1293

1294

PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;

1295

1296

PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;

1297

PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;

1298

1299

PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;

1300

PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;

1301

PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;

1302

PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;

1303

PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;

1304

PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;

1305

PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;

1306

PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;

1307

PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;

1308

PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;

1309

PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;

1310

PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;

1311

PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;

1312

PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;

1313

PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;

1314

PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;

1315

PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;

1316

1317

PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;

1318

1319

PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;

1320

PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;

1321

PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;

1322

1323

PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;

1324

1325

PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL;

1326

1327

PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL;

1328

PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL;

1329

PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL;

1330

PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL;

1331

PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL;

1332

PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL;

1333

1334

PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;

1335

PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;

1336

PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;

1337

PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;

1338

PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;

1339

PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;

1340

1341

PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;

1342

1343

PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;

1344

PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL;

1345

1346

PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL;

1347

PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL;

1348

PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL;

1349

PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL;

1350

PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL;

1351

PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL;

1352

PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL;

1353

1354

PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;

1355

PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;

1356

PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;

1357

PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;

1358

PFNGLGETPOINTERVEXTPROC __glewGetPointervEXT = NULL;

1359

PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;

1360

PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;

1361

PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;

1362

PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;

1363

1364

PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;

1365

PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;

1366

PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;

1367

PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;

1368

PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;

1369

PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;

1370

PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;

1371

PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;

1372

PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;

1373

PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;

1374

PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;

1375

PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;

1376

PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;

1377

PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;

1378

PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;

1379

PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;

1380

PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;

1381

PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;

1382

PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;

1383

PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;

1384

PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;

1385

PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;

1386

PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;

1387

PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;

1388

PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;

1389

PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;

1390

PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;

1391

PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;

1392

PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;

1393

PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;

1394

PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;

1395

PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;

1396

PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;

1397

PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;

1398

PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;

1399

PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;

1400

PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;

1401

PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;

1402

PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;

1403

PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;

1404

PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;

1405

PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;

1406

1407

PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;

1408

PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;

1409

PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;

1410

1411

PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL;

1412

1413

PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL;

1414

1415

PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;

1416

PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;

1417

PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;

1418

PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;

1419

PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;

1420

PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;

1421

1422

PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;

1423

PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;

1424

1425

PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;

1426

PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;

1427

PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;

1428

PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;

1429

PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;

1430

PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;

1431

PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;

1432

PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;

1433

1434

PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;

1435

PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;

1436

PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;

1437

PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;

1438

1439

PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;

1440

PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;

1441

1442

PFNGLBUFFERREGIONENABLEDEXTPROC __glewBufferRegionEnabledEXT = NULL;

1443

PFNGLDELETEBUFFERREGIONEXTPROC __glewDeleteBufferRegionEXT = NULL;

1444

PFNGLDRAWBUFFERREGIONEXTPROC __glewDrawBufferRegionEXT = NULL;

1445

PFNGLNEWBUFFERREGIONEXTPROC __glewNewBufferRegionEXT = NULL;

1446

PFNGLREADBUFFERREGIONEXTPROC __glewReadBufferRegionEXT = NULL;

1447

1448

PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;

1449

1450

PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;

1451

PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;

1452

PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;

1453

PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;

1454

PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;

1455

PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;

1456

PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;

1457

PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;

1458

PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;

1459

PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;

1460

PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;

1461

PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;

1462

PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;

1463

PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;

1464

PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;

1465

PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;

1466

PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;

1467

PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;

1468

PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;

1469

PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;

1470

PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;

1471

PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;

1472

PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;

1473

PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;

1474

1475

PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL;

1476

PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL;

1477

1478

PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;

1479

PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;

1480

PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;

1481

1482

PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;

1483

PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;

1484

PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;

1485

PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;

1486

PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;

1487

PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;

1488

PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;

1489

PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;

1490

PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;

1491

1492

PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL;

1493

PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL;

1494

PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL;

1495

1496

PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;

1497

PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;

1498

PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;

1499

PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;

1500

PFNGLISFENCENVPROC __glewIsFenceNV = NULL;

1501

PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;

1502

PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;

1503

1504

PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;

1505

PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;

1506

PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;

1507

PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;

1508

PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;

1509

PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;

1510

1511

PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL;

1512

1513

PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL;

1514

1515

PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL;

1516

PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL;

1517

PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL;

1518

PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL;

1519

PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL;

1520

PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL;

1521

PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL;

1522

PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL;

1523

PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL;

1524

PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;

1525

PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;

1526

PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;

1527

1528

PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;

1529

PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;

1530

PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;

1531

PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;

1532

PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;

1533

PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;

1534

PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;

1535

PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;

1536

PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;

1537

PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;

1538

PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;

1539

PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;

1540

PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;

1541

PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;

1542

PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;

1543

PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;

1544

PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;

1545

PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;

1546

PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;

1547

PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;

1548

PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;

1549

PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;

1550

PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;

1551

PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;

1552

PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;

1553

PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;

1554

PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;

1555

PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;

1556

PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;

1557

PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;

1558

PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;

1559

PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;

1560

PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;

1561

PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;

1562

PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;

1563

PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;

1564

PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;

1565

PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;

1566

PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;

1567

PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;

1568

PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;

1569

PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;

1570

PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;

1571

PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;

1572

PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;

1573

PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;

1574

1575

PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;

1576

PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;

1577

PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;

1578

PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;

1579

PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;

1580

PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;

1581

PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;

1582

1583

PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL;

1584

PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL;

1585

PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL;

1586

1587

PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;

1588

PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;

1589

1590

PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;

1591

PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;

1592

1593

PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL;

1594

PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL;

1595

PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL;

1596

PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL;

1597

PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL;

1598

PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL;

1599

PFNGLVIDEOPARAMETERIVNVPROC __glewVideoParameterivNV = NULL;

1600

1601

PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;

1602

PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;

1603

1604

PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;

1605

PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;

1606

PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;

1607

PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;

1608

PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;

1609

PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;

1610

PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;

1611

PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;

1612

PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;

1613

PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;

1614

PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;

1615

PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;

1616

PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;

1617

1618

PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;

1619

PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;

1620

1621

PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;

1622

PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;

1623

PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;

1624

PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL;

1625

PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL;

1626

PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL;

1627

PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL;

1628

PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL;

1629

PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;

1630

PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;

1631

PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;

1632

1633

PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;

1634

PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;

1635

1636

PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;

1637

PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;

1638

PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;

1639

PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;

1640

PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;

1641

PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;

1642

PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;

1643

PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;

1644

PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;

1645

PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;

1646

PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;

1647

PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;

1648

PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;

1649

PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;

1650

PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;

1651

PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;

1652

PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;

1653

PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;

1654

PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;

1655

PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;

1656

PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;

1657

PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;

1658

PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;

1659

PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;

1660

PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;

1661

PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;

1662

PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;

1663

PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;

1664

PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;

1665

PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;

1666

PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;

1667

PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;

1668

PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;

1669

PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;

1670

PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;

1671

PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;

1672

PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;

1673

PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;

1674

PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;

1675

PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;

1676

PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;

1677

PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;

1678

PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;

1679

PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;

1680

PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;

1681

PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;

1682

PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;

1683

PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;

1684

PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;

1685

PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;

1686

PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;

1687

PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;

1688

PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;

1689

PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;

1690

PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;

1691

PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;

1692

PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;

1693

PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;

1694

PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;

1695

PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;

1696

PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;

1697

PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;

1698

PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;

1699

PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;

1700

1701

PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL;

1702

PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL;

1703

PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL;

1704

PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL;

1705

PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL;

1706

PFNGLORTHOFOESPROC __glewOrthofOES = NULL;

1707

1708

PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;

1709

PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;

1710

1711

PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;

1712

PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;

1713

1714

PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;

1715

PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;

1716

1717

PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;

1718

PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;

1719

1720

PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;

1721

PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;

1722

1723

PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;

1724

PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;

1725

1726

PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;

1727

PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;

1728

PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;

1729

PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;

1730

PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;

1731

PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;

1732

1733

PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;

1734

1735

PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;

1736

1737

PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;

1738

PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;

1739

PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;

1740

PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;

1741

PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;

1742

PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;

1743

PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;

1744

PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;

1745

PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;

1746

PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;

1747

PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;

1748

PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;

1749

PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;

1750

PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;

1751

PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;

1752

PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;

1753

PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;

1754

1755

PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;

1756

1757

PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;

1758

1759

PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;

1760

1761

PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;

1762

PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;

1763

PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;

1764

PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;

1765

1766

PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;

1767

1768

PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;

1769

PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;

1770

PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;

1771

PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;

1772

PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;

1773

PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;

1774

PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;

1775

1776

PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;

1777

1778

PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;

1779

PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;

1780

PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;

1781

PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;

1782

PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;

1783

PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;

1784

PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;

1785

PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;

1786

1787

PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;

1788

1789

PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;

1790

PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;

1791

PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;

1792

PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;

1793

PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;

1794

PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;

1795

PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;

1796

1797

PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;

1798

PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;

1799

PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;

1800

PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;

1801

PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;

1802

PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;

1803

PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;

1804

PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;

1805

PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;

1806

PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;

1807

PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;

1808

PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;

1809

PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;

1810

PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;

1811

PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;

1812

PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;

1813

PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;

1814

PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;

1815

PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

1816

PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

1817

PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;

1818

PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;

1819

PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;

1820

PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;

1821

PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;

1822

PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;

1823

PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;

1824

PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;

1825

PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

1826

PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

1827

PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;

1828

PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;

1829

PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;

1830

PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;

1831

PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;

1832

PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;

1833

PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;

1834

PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;

1835

PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;

1836

PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;

1837

1838

PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;

1839

1840

#endif /* !WIN32 || !GLEW_MX */

1841

1842

#if !defined(GLEW_MX)

1843

1844

GLboolean __GLEW_VERSION_1_1 = GL_FALSE;

1845

GLboolean __GLEW_VERSION_1_2 = GL_FALSE;

1846

GLboolean __GLEW_VERSION_1_3 = GL_FALSE;

1847

GLboolean __GLEW_VERSION_1_4 = GL_FALSE;

1848

GLboolean __GLEW_VERSION_1_5 = GL_FALSE;

1849

GLboolean __GLEW_VERSION_2_0 = GL_FALSE;

1850

GLboolean __GLEW_VERSION_2_1 = GL_FALSE;

1851

GLboolean __GLEW_VERSION_3_0 = GL_FALSE;

1852

GLboolean __GLEW_3DFX_multisample = GL_FALSE;

1853

GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;

1854

GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;

1855

GLboolean __GLEW_APPLE_client_storage = GL_FALSE;

1856

GLboolean __GLEW_APPLE_element_array = GL_FALSE;

1857

GLboolean __GLEW_APPLE_fence = GL_FALSE;

1858

GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;

1859

GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;

1860

GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;

1861

GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;

1862

GLboolean __GLEW_APPLE_texture_range = GL_FALSE;

1863

GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;

1864

GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;

1865

GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;

1866

GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;

1867

GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;

1868

GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE;

1869

GLboolean __GLEW_ARB_depth_texture = GL_FALSE;

1870

GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;

1871

GLboolean __GLEW_ARB_draw_instanced = GL_FALSE;

1872

GLboolean __GLEW_ARB_fragment_program = GL_FALSE;

1873

GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;

1874

GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;

1875

GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE;

1876

GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE;

1877

GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE;

1878

GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;

1879

GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE;

1880

GLboolean __GLEW_ARB_imaging = GL_FALSE;

1881

GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE;

1882

GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE;

1883

GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;

1884

GLboolean __GLEW_ARB_multisample = GL_FALSE;

1885

GLboolean __GLEW_ARB_multitexture = GL_FALSE;

1886

GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;

1887

GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;

1888

GLboolean __GLEW_ARB_point_parameters = GL_FALSE;

1889

GLboolean __GLEW_ARB_point_sprite = GL_FALSE;

1890

GLboolean __GLEW_ARB_shader_objects = GL_FALSE;

1891

GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;

1892

GLboolean __GLEW_ARB_shadow = GL_FALSE;

1893

GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;

1894

GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;

1895

GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE;

1896

GLboolean __GLEW_ARB_texture_compression = GL_FALSE;

1897

GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE;

1898

GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;

1899

GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;

1900

GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;

1901

GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;

1902

GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;

1903

GLboolean __GLEW_ARB_texture_float = GL_FALSE;

1904

GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;

1905

GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;

1906

GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;

1907

GLboolean __GLEW_ARB_texture_rg = GL_FALSE;

1908

GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;

1909

GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE;

1910

GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;

1911

GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;

1912

GLboolean __GLEW_ARB_vertex_program = GL_FALSE;

1913

GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;

1914

GLboolean __GLEW_ARB_window_pos = GL_FALSE;

1915

GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;

1916

GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;

1917

GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;

1918

GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;

1919

GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;

1920

GLboolean __GLEW_ATI_element_array = GL_FALSE;

1921

GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;

1922

GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;

1923

GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;

1924

GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;

1925

GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;

1926

GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;

1927

GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;

1928

GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;

1929

GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;

1930

GLboolean __GLEW_ATI_texture_float = GL_FALSE;

1931

GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;

1932

GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;

1933

GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;

1934

GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;

1935

GLboolean __GLEW_EXT_422_pixels = GL_FALSE;

1936

GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;

1937

GLboolean __GLEW_EXT_abgr = GL_FALSE;

1938

GLboolean __GLEW_EXT_bgra = GL_FALSE;

1939

GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE;

1940

GLboolean __GLEW_EXT_blend_color = GL_FALSE;

1941

GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;

1942

GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;

1943

GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;

1944

GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;

1945

GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;

1946

GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;

1947

GLboolean __GLEW_EXT_cmyka = GL_FALSE;

1948

GLboolean __GLEW_EXT_color_subtable = GL_FALSE;

1949

GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;

1950

GLboolean __GLEW_EXT_convolution = GL_FALSE;

1951

GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;

1952

GLboolean __GLEW_EXT_copy_texture = GL_FALSE;

1953

GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;

1954

GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;

1955

GLboolean __GLEW_EXT_direct_state_access = GL_FALSE;

1956

GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE;

1957

GLboolean __GLEW_EXT_draw_instanced = GL_FALSE;

1958

GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;

1959

GLboolean __GLEW_EXT_fog_coord = GL_FALSE;

1960

GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;

1961

GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;

1962

GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;

1963

GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;

1964

GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE;

1965

GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE;

1966

GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE;

1967

GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE;

1968

GLboolean __GLEW_EXT_histogram = GL_FALSE;

1969

GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;

1970

GLboolean __GLEW_EXT_index_func = GL_FALSE;

1971

GLboolean __GLEW_EXT_index_material = GL_FALSE;

1972

GLboolean __GLEW_EXT_index_texture = GL_FALSE;

1973

GLboolean __GLEW_EXT_light_texture = GL_FALSE;

1974

GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;

1975

GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;

1976

GLboolean __GLEW_EXT_multisample = GL_FALSE;

1977

GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE;

1978

GLboolean __GLEW_EXT_packed_float = GL_FALSE;

1979

GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;

1980

GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;

1981

GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;

1982

GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;

1983

GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;

1984

GLboolean __GLEW_EXT_point_parameters = GL_FALSE;

1985

GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;

1986

GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;

1987

GLboolean __GLEW_EXT_scene_marker = GL_FALSE;

1988

GLboolean __GLEW_EXT_secondary_color = GL_FALSE;

1989

GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;

1990

GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;

1991

GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;

1992

GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;

1993

GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;

1994

GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;

1995

GLboolean __GLEW_EXT_subtexture = GL_FALSE;

1996

GLboolean __GLEW_EXT_texture = GL_FALSE;

1997

GLboolean __GLEW_EXT_texture3D = GL_FALSE;

1998

GLboolean __GLEW_EXT_texture_array = GL_FALSE;

1999

GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE;

2000

GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;

2001

GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE;

2002

GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE;

2003

GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;

2004

GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;

2005

GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;

2006

GLboolean __GLEW_EXT_texture_env = GL_FALSE;

2007

GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;

2008

GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;

2009

GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;

2010

GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;

2011

GLboolean __GLEW_EXT_texture_integer = GL_FALSE;

2012

GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;

2013

GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;

2014

GLboolean __GLEW_EXT_texture_object = GL_FALSE;

2015

GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;

2016

GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;

2017

GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;

2018

GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;

2019

GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;

2020

GLboolean __GLEW_EXT_timer_query = GL_FALSE;

2021

GLboolean __GLEW_EXT_transform_feedback = GL_FALSE;

2022

GLboolean __GLEW_EXT_vertex_array = GL_FALSE;

2023

GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE;

2024

GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;

2025

GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;

2026

GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;

2027

GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE;

2028

GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;

2029

GLboolean __GLEW_HP_image_transform = GL_FALSE;

2030

GLboolean __GLEW_HP_occlusion_test = GL_FALSE;

2031

GLboolean __GLEW_HP_texture_lighting = GL_FALSE;

2032

GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;

2033

GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;

2034

GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;

2035

GLboolean __GLEW_IBM_static_data = GL_FALSE;

2036

GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;

2037

GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;

2038

GLboolean __GLEW_INGR_color_clamp = GL_FALSE;

2039

GLboolean __GLEW_INGR_interlace_read = GL_FALSE;

2040

GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;

2041

GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;

2042

GLboolean __GLEW_KTX_buffer_region = GL_FALSE;

2043

GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;

2044

GLboolean __GLEW_MESA_pack_invert = GL_FALSE;

2045

GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;

2046

GLboolean __GLEW_MESA_window_pos = GL_FALSE;

2047

GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;

2048

GLboolean __GLEW_NV_blend_square = GL_FALSE;

2049

GLboolean __GLEW_NV_conditional_render = GL_FALSE;

2050

GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;

2051

GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;

2052

GLboolean __GLEW_NV_depth_clamp = GL_FALSE;

2053

GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;

2054

GLboolean __GLEW_NV_evaluators = GL_FALSE;

2055

GLboolean __GLEW_NV_explicit_multisample = GL_FALSE;

2056

GLboolean __GLEW_NV_fence = GL_FALSE;

2057

GLboolean __GLEW_NV_float_buffer = GL_FALSE;

2058

GLboolean __GLEW_NV_fog_distance = GL_FALSE;

2059

GLboolean __GLEW_NV_fragment_program = GL_FALSE;

2060

GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;

2061

GLboolean __GLEW_NV_fragment_program4 = GL_FALSE;

2062

GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;

2063

GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;

2064

GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;

2065

GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;

2066

GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;

2067

GLboolean __GLEW_NV_half_float = GL_FALSE;

2068

GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;

2069

GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;

2070

GLboolean __GLEW_NV_occlusion_query = GL_FALSE;

2071

GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;

2072

GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;

2073

GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;

2074

GLboolean __GLEW_NV_point_sprite = GL_FALSE;

2075

GLboolean __GLEW_NV_present_video = GL_FALSE;

2076

GLboolean __GLEW_NV_primitive_restart = GL_FALSE;

2077

GLboolean __GLEW_NV_register_combiners = GL_FALSE;

2078

GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;

2079

GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;

2080

GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;

2081

GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;

2082

GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;

2083

GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;

2084

GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;

2085

GLboolean __GLEW_NV_texture_shader = GL_FALSE;

2086

GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;

2087

GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;

2088

GLboolean __GLEW_NV_transform_feedback = GL_FALSE;

2089

GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;

2090

GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;

2091

GLboolean __GLEW_NV_vertex_program = GL_FALSE;

2092

GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;

2093

GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;

2094

GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;

2095

GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;

2096

GLboolean __GLEW_NV_vertex_program4 = GL_FALSE;

2097

GLboolean __GLEW_OES_byte_coordinates = GL_FALSE;

2098

GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE;

2099

GLboolean __GLEW_OES_read_format = GL_FALSE;

2100

GLboolean __GLEW_OES_single_precision = GL_FALSE;

2101

GLboolean __GLEW_OML_interlace = GL_FALSE;

2102

GLboolean __GLEW_OML_resample = GL_FALSE;

2103

GLboolean __GLEW_OML_subsample = GL_FALSE;

2104

GLboolean __GLEW_PGI_misc_hints = GL_FALSE;

2105

GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;

2106

GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;

2107

GLboolean __GLEW_S3_s3tc = GL_FALSE;

2108

GLboolean __GLEW_SGIS_color_range = GL_FALSE;

2109

GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;

2110

GLboolean __GLEW_SGIS_fog_function = GL_FALSE;

2111

GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;

2112

GLboolean __GLEW_SGIS_multisample = GL_FALSE;

2113

GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;

2114

GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE;

2115

GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;

2116

GLboolean __GLEW_SGIS_texture4D = GL_FALSE;

2117

GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;

2118

GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;

2119

GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;

2120

GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;

2121

GLboolean __GLEW_SGIS_texture_select = GL_FALSE;

2122

GLboolean __GLEW_SGIX_async = GL_FALSE;

2123

GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;

2124

GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;

2125

GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;

2126

GLboolean __GLEW_SGIX_clipmap = GL_FALSE;

2127

GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE;

2128

GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;

2129

GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;

2130

GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;

2131

GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;

2132

GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;

2133

GLboolean __GLEW_SGIX_framezoom = GL_FALSE;

2134

GLboolean __GLEW_SGIX_interlace = GL_FALSE;

2135

GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;

2136

GLboolean __GLEW_SGIX_list_priority = GL_FALSE;

2137

GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;

2138

GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;

2139

GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;

2140

GLboolean __GLEW_SGIX_resample = GL_FALSE;

2141

GLboolean __GLEW_SGIX_shadow = GL_FALSE;

2142

GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;

2143

GLboolean __GLEW_SGIX_sprite = GL_FALSE;

2144

GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;

2145

GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;

2146

GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;

2147

GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;

2148

GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;

2149

GLboolean __GLEW_SGIX_texture_range = GL_FALSE;

2150

GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;

2151

GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;

2152

GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;

2153

GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;

2154

GLboolean __GLEW_SGI_color_matrix = GL_FALSE;

2155

GLboolean __GLEW_SGI_color_table = GL_FALSE;

2156

GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;

2157

GLboolean __GLEW_SUNX_constant_data = GL_FALSE;

2158

GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;

2159

GLboolean __GLEW_SUN_global_alpha = GL_FALSE;

2160

GLboolean __GLEW_SUN_mesh_array = GL_FALSE;

2161

GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;

2162

GLboolean __GLEW_SUN_slice_accum = GL_FALSE;

2163

GLboolean __GLEW_SUN_triangle_list = GL_FALSE;

2164

GLboolean __GLEW_SUN_vertex = GL_FALSE;

2165

GLboolean __GLEW_WIN_phong_shading = GL_FALSE;

2166

GLboolean __GLEW_WIN_specular_fog = GL_FALSE;

2167

GLboolean __GLEW_WIN_swap_hint = GL_FALSE;

2168

2169

#endif /* !GLEW_MX */

2170

2171

#ifdef GL_VERSION_1_2

2172

2173

static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)

2174

{

2175

GLboolean r = GL_FALSE;

2176

2177

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

2178

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

2179

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

2180

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

2181

2182

return r;

2183

}

2184

2185

#endif /* GL_VERSION_1_2 */

2186

2187

#ifdef GL_VERSION_1_3

2188

2189

static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)

2190

{

2191

GLboolean r = GL_FALSE;

2192

2193

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

2194

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

2195

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

2196

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

2197

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

2198

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

2199

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

2200

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

2201

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

2202

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

2203

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

2204

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

2205

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

2206

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

2207

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

2208

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

2209

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

2210

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

2211

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

2212

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

2213

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

2214

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

2215

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

2216

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

2217

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

2218

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

2219

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

2220

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

2221

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

2222

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

2223

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

2224

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

2225

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

2226

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

2227

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

2228

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

2229

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

2230

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

2231

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

2232

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

2233

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

2234

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

2235

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

2236

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

2237

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

2238

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

2239

2240

return r;

2241

}

2242

2243

#endif /* GL_VERSION_1_3 */

2244

2245

#ifdef GL_VERSION_1_4

2246

2247

static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)

2248

{

2249

GLboolean r = GL_FALSE;

2250

2251

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

2252

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

2253

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

2254

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

2255

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

2256

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

2257

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

2258

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

2259

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

2260

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

2261

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

2262

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

2263

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

2264

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

2265

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

2266

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

2267

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

2268

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

2269

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

2270

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

2271

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

2272

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

2273

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

2274

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

2275

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

2276

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

2277

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

2278

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

2279

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

2280

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

2281

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

2282

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

2283

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

2284

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

2285

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

2286

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

2287

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

2288

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

2289

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

2290

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

2291

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

2292

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

2293

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

2294

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

2295

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

2296

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

2297

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

2298

2299

return r;

2300

}

2301

2302

#endif /* GL_VERSION_1_4 */

2303

2304

#ifdef GL_VERSION_1_5

2305

2306

static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)

2307

{

2308

GLboolean r = GL_FALSE;

2309

2310

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

2311

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

2312

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

2313

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

2314

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

2315

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

2316

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

2317

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

2318

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

2319

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

2320

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

2321

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

2322

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

2323

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

2324

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

2325

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

2326

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

2327

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

2328

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

2329

2330

return r;

2331

}

2332

2333

#endif /* GL_VERSION_1_5 */

2334

2335

#ifdef GL_VERSION_2_0

2336

2337

static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)

2338

{

2339

GLboolean r = GL_FALSE;

2340

2341

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

2342

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

2343

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

2344

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

2345

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

2346

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

2347

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

2348

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

2349

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

2350

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

2351

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

2352

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

2353

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

2354

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

2355

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

2356

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

2357

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

2358

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

2359

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

2360

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

2361

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

2362

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

2363

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

2364

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

2365

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

2366

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

2367

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

2368

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

2369

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

2370

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

2371

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

2372

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

2373

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

2374

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

2375

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

2376

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

2377

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

2378

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

2379

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

2380

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

2381

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

2382

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

2383

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

2384

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

2385

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

2386

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

2387

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

2388

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

2389

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

2390

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

2391

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

2392

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

2393

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

2394

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

2395

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

2396

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

2397

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

2398

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

2399

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

2400

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

2401

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

2402

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

2403

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

2404

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

2405

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

2406

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

2407

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

2408

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

2409

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

2410

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

2411

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

2412

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

2413

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

2414

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

2415

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

2416

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

2417

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

2418

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

2419

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

2420

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

2421

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

2422

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

2423

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

2424

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

2425

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

2426

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

2427

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

2428

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

2429

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

2430

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

2431

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

2432

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

2433

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

2434

2435

return r;

2436

}

2437

2438

#endif /* GL_VERSION_2_0 */

2439

2440

#ifdef GL_VERSION_2_1

2441

2442

static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT)

2443

{

2444

GLboolean r = GL_FALSE;

2445

2446

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

2447

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

2448

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

2449

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

2450

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

2451

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

2452

2453

return r;

2454

}

2455

2456

#endif /* GL_VERSION_2_1 */

2457

2458

#ifdef GL_VERSION_3_0

2459

2460

static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)

2461

{

2462

GLboolean r = GL_FALSE;

2463

2464

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

2465

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

2466

r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;

2467

r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;

2468

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

2469

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

2470

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

2471

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

2472

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

2473

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

2474

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

2475

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

2476

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

2477

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

2478

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

2479

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

2480

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

2481

r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;

2482

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

2483

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

2484

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

2485

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

2486

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

2487

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

2488

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

2489

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

2490

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

2491

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

2492

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

2493

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

2494

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

2495

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

2496

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

2497

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

2498

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

2499

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

2500

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

2501

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

2502

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

2503

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

2504

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

2505

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

2506

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

2507

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

2508

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

2509

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

2510

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

2511

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

2512

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

2513

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

2514

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

2515

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

2516

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

2517

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

2518

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

2519

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

2520

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

2521

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

2522

2523

return r;

2524

}

2525

2526

#endif /* GL_VERSION_3_0 */

2527

2528

#ifdef GL_3DFX_multisample

2529

2530

#endif /* GL_3DFX_multisample */

2531

2532

#ifdef GL_3DFX_tbuffer

2533

2534

static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)

2535

{

2536

GLboolean r = GL_FALSE;

2537

2538

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

2539

2540

return r;

2541

}

2542

2543

#endif /* GL_3DFX_tbuffer */

2544

2545

#ifdef GL_3DFX_texture_compression_FXT1

2546

2547

#endif /* GL_3DFX_texture_compression_FXT1 */

2548

2549

#ifdef GL_APPLE_client_storage

2550

2551

#endif /* GL_APPLE_client_storage */

2552

2553

#ifdef GL_APPLE_element_array

2554

2555

static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT)

2556

{

2557

GLboolean r = GL_FALSE;

2558

2559

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

2560

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

2561

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

2562

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

2563

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

2564

2565

return r;

2566

}

2567

2568

#endif /* GL_APPLE_element_array */

2569

2570

#ifdef GL_APPLE_fence

2571

2572

static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT)

2573

{

2574

GLboolean r = GL_FALSE;

2575

2576

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

2577

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

2578

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

2579

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

2580

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

2581

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

2582

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

2583

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

2584

2585

return r;

2586

}

2587

2588

#endif /* GL_APPLE_fence */

2589

2590

#ifdef GL_APPLE_float_pixels

2591

2592

#endif /* GL_APPLE_float_pixels */

2593

2594

#ifdef GL_APPLE_flush_buffer_range

2595

2596

static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)

2597

{

2598

GLboolean r = GL_FALSE;

2599

2600

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

2601

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

2602

2603

return r;

2604

}

2605

2606

#endif /* GL_APPLE_flush_buffer_range */

2607

2608

#ifdef GL_APPLE_pixel_buffer

2609

2610

#endif /* GL_APPLE_pixel_buffer */

2611

2612

#ifdef GL_APPLE_specular_vector

2613

2614

#endif /* GL_APPLE_specular_vector */

2615

2616

#ifdef GL_APPLE_texture_range

2617

2618

static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT)

2619

{

2620

GLboolean r = GL_FALSE;

2621

2622

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

2623

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

2624

2625

return r;

2626

}

2627

2628

#endif /* GL_APPLE_texture_range */

2629

2630

#ifdef GL_APPLE_transform_hint

2631

2632

#endif /* GL_APPLE_transform_hint */

2633

2634

#ifdef GL_APPLE_vertex_array_object

2635

2636

static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

2637

{

2638

GLboolean r = GL_FALSE;

2639

2640

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

2641

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

2642

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

2643

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

2644

2645

return r;

2646

}

2647

2648

#endif /* GL_APPLE_vertex_array_object */

2649

2650

#ifdef GL_APPLE_vertex_array_range

2651

2652

static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)

2653

{

2654

GLboolean r = GL_FALSE;

2655

2656

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

2657

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

2658

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

2659

2660

return r;

2661

}

2662

2663

#endif /* GL_APPLE_vertex_array_range */

2664

2665

#ifdef GL_APPLE_ycbcr_422

2666

2667

#endif /* GL_APPLE_ycbcr_422 */

2668

2669

#ifdef GL_ARB_color_buffer_float

2670

2671

static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)

2672

{

2673

GLboolean r = GL_FALSE;

2674

2675

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

2676

2677

return r;

2678

}

2679

2680

#endif /* GL_ARB_color_buffer_float */

2681

2682

#ifdef GL_ARB_depth_buffer_float

2683

2684

#endif /* GL_ARB_depth_buffer_float */

2685

2686

#ifdef GL_ARB_depth_texture

2687

2688

#endif /* GL_ARB_depth_texture */

2689

2690

#ifdef GL_ARB_draw_buffers

2691

2692

static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

2693

{

2694

GLboolean r = GL_FALSE;

2695

2696

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

2697

2698

return r;

2699

}

2700

2701

#endif /* GL_ARB_draw_buffers */

2702

2703

#ifdef GL_ARB_draw_instanced

2704

2705

static GLboolean _glewInit_GL_ARB_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)

2706

{

2707

GLboolean r = GL_FALSE;

2708

2709

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

2710

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

2711

2712

return r;

2713

}

2714

2715

#endif /* GL_ARB_draw_instanced */

2716

2717

#ifdef GL_ARB_fragment_program

2718

2719

#endif /* GL_ARB_fragment_program */

2720

2721

#ifdef GL_ARB_fragment_program_shadow

2722

2723

#endif /* GL_ARB_fragment_program_shadow */

2724

2725

#ifdef GL_ARB_fragment_shader

2726

2727

#endif /* GL_ARB_fragment_shader */

2728

2729

#ifdef GL_ARB_framebuffer_object

2730

2731

static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

2732

{

2733

GLboolean r = GL_FALSE;

2734

2735

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

2736

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

2737

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

2738

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

2739

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

2740

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

2741

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

2742

r = ((glFramebufferTexturLayer = (PFNGLFRAMEBUFFERTEXTURLAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexturLayer")) == NULL) || r;

2743

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

2744

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

2745

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

2746

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

2747

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

2748

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

2749

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

2750

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

2751

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

2752

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

2753

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

2754

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

2755

2756

return r;

2757

}

2758

2759

#endif /* GL_ARB_framebuffer_object */

2760

2761

#ifdef GL_ARB_framebuffer_sRGB

2762

2763

#endif /* GL_ARB_framebuffer_sRGB */

2764

2765

#ifdef GL_ARB_geometry_shader4

2766

2767

static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)

2768

{

2769

GLboolean r = GL_FALSE;

2770

2771

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

2772

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

2773

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

2774

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

2775

2776

return r;

2777

}

2778

2779

#endif /* GL_ARB_geometry_shader4 */

2780

2781

#ifdef GL_ARB_half_float_pixel

2782

2783

#endif /* GL_ARB_half_float_pixel */

2784

2785

#ifdef GL_ARB_half_float_vertex

2786

2787

#endif /* GL_ARB_half_float_vertex */

2788

2789

#ifdef GL_ARB_imaging

2790

2791

static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT)

2792

{

2793

GLboolean r = GL_FALSE;

2794

2795

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

2796

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

2797

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

2798

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

2799

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

2800

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

2801

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

2802

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

2803

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

2804

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

2805

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

2806

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

2807

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

2808

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

2809

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

2810

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

2811

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

2812

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

2813

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

2814

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

2815

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

2816

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

2817

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

2818

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

2819

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

2820

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

2821

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

2822

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

2823

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

2824

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

2825

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

2826

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

2827

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

2828

2829

return r;

2830

}

2831

2832

#endif /* GL_ARB_imaging */

2833

2834

#ifdef GL_ARB_instanced_arrays

2835

2836

static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

2837

{

2838

GLboolean r = GL_FALSE;

2839

2840

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

2841

2842

return r;

2843

}

2844

2845

#endif /* GL_ARB_instanced_arrays */

2846

2847

#ifdef GL_ARB_map_buffer_range

2848

2849

static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)

2850

{

2851

GLboolean r = GL_FALSE;

2852

2853

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

2854

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

2855

2856

return r;

2857

}

2858

2859

#endif /* GL_ARB_map_buffer_range */

2860

2861

#ifdef GL_ARB_matrix_palette

2862

2863

static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT)

2864

{

2865

GLboolean r = GL_FALSE;

2866

2867

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

2868

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

2869

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

2870

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

2871

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

2872

2873

return r;

2874

}

2875

2876

#endif /* GL_ARB_matrix_palette */

2877

2878

#ifdef GL_ARB_multisample

2879

2880

static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

2881

{

2882

GLboolean r = GL_FALSE;

2883

2884

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

2885

2886

return r;

2887

}

2888

2889

#endif /* GL_ARB_multisample */

2890

2891

#ifdef GL_ARB_multitexture

2892

2893

static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)

2894

{

2895

GLboolean r = GL_FALSE;

2896

2897

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

2898

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

2899

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

2900

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

2901

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

2902

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

2903

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

2904

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

2905

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

2906

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

2907

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

2908

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

2909

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

2910

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

2911

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

2912

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

2913

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

2914

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

2915

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

2916

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

2917

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

2918

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

2919

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

2920

r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;

2921

r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;

2922

r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;

2923

r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;

2924

r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;

2925

r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;

2926

r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;

2927

r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;

2928

r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;

2929

r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;

2930

r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;

2931

2932

return r;

2933

}

2934

2935

#endif /* GL_ARB_multitexture */

2936

2937

#ifdef GL_ARB_occlusion_query

2938

2939

static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)

2940

{

2941

GLboolean r = GL_FALSE;

2942

2943

r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;

2944

r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;

2945

r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;

2946

r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;

2947

r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;

2948

r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;

2949

r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;

2950

r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;

2951

2952

return r;

2953

}

2954

2955

#endif /* GL_ARB_occlusion_query */

2956

2957

#ifdef GL_ARB_pixel_buffer_object

2958

2959

#endif /* GL_ARB_pixel_buffer_object */

2960

2961

#ifdef GL_ARB_point_parameters

2962

2963

static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

2964

{

2965

GLboolean r = GL_FALSE;

2966

2967

r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;

2968

r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;

2969

2970

return r;

2971

}

2972

2973

#endif /* GL_ARB_point_parameters */

2974

2975

#ifdef GL_ARB_point_sprite

2976

2977

#endif /* GL_ARB_point_sprite */

2978

2979

#ifdef GL_ARB_shader_objects

2980

2981

static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)

2982

{

2983

GLboolean r = GL_FALSE;

2984

2985

r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;

2986

r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;

2987

r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;

2988

r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;

2989

r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;

2990

r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;

2991

r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;

2992

r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;

2993

r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;

2994

r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;

2995

r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;

2996

r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;

2997

r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;

2998

r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;

2999

r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;

3000

r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;

3001

r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;

3002

r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;

3003

r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;

3004

r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;

3005

r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;

3006

r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;

3007

r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;

3008

r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;

3009

r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;

3010

r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;

3011

r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;

3012

r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;

3013

r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;

3014

r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;

3015

r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;

3016

r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;

3017

r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;

3018

r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;

3019

r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;

3020

r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;

3021

r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;

3022

r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;

3023

r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;

3024

3025

return r;

3026

}

3027

3028

#endif /* GL_ARB_shader_objects */

3029

3030

#ifdef GL_ARB_shading_language_100

3031

3032

#endif /* GL_ARB_shading_language_100 */

3033

3034

#ifdef GL_ARB_shadow

3035

3036

#endif /* GL_ARB_shadow */

3037

3038

#ifdef GL_ARB_shadow_ambient

3039

3040

#endif /* GL_ARB_shadow_ambient */

3041

3042

#ifdef GL_ARB_texture_border_clamp

3043

3044

#endif /* GL_ARB_texture_border_clamp */

3045

3046

#ifdef GL_ARB_texture_buffer_object

3047

3048

static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

3049

{

3050

GLboolean r = GL_FALSE;

3051

3052

r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;

3053

3054

return r;

3055

}

3056

3057

#endif /* GL_ARB_texture_buffer_object */

3058

3059

#ifdef GL_ARB_texture_compression

3060

3061

static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)

3062

{

3063

GLboolean r = GL_FALSE;

3064

3065

r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;

3066

r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;

3067

r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;

3068

r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;

3069

r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;

3070

r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;

3071

r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;

3072

3073

return r;

3074

}

3075

3076

#endif /* GL_ARB_texture_compression */

3077

3078

#ifdef GL_ARB_texture_compression_rgtc

3079

3080

#endif /* GL_ARB_texture_compression_rgtc */

3081

3082

#ifdef GL_ARB_texture_cube_map

3083

3084

#endif /* GL_ARB_texture_cube_map */

3085

3086

#ifdef GL_ARB_texture_env_add

3087

3088

#endif /* GL_ARB_texture_env_add */

3089

3090

#ifdef GL_ARB_texture_env_combine

3091

3092

#endif /* GL_ARB_texture_env_combine */

3093

3094

#ifdef GL_ARB_texture_env_crossbar

3095

3096

#endif /* GL_ARB_texture_env_crossbar */

3097

3098

#ifdef GL_ARB_texture_env_dot3

3099

3100

#endif /* GL_ARB_texture_env_dot3 */

3101

3102

#ifdef GL_ARB_texture_float

3103

3104

#endif /* GL_ARB_texture_float */

3105

3106

#ifdef GL_ARB_texture_mirrored_repeat

3107

3108

#endif /* GL_ARB_texture_mirrored_repeat */

3109

3110

#ifdef GL_ARB_texture_non_power_of_two

3111

3112

#endif /* GL_ARB_texture_non_power_of_two */

3113

3114

#ifdef GL_ARB_texture_rectangle

3115

3116

#endif /* GL_ARB_texture_rectangle */

3117

3118

#ifdef GL_ARB_texture_rg

3119

3120

#endif /* GL_ARB_texture_rg */

3121

3122

#ifdef GL_ARB_transpose_matrix

3123

3124

static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)

3125

{

3126

GLboolean r = GL_FALSE;

3127

3128

r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r;

3129

r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r;

3130

r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r;

3131

r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r;

3132

3133

return r;

3134

}

3135

3136

#endif /* GL_ARB_transpose_matrix */

3137

3138

#ifdef GL_ARB_vertex_array_object

3139

3140

static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

3141

{

3142

GLboolean r = GL_FALSE;

3143

3144

r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r;

3145

r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r;

3146

r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r;

3147

r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r;

3148

3149

return r;

3150

}

3151

3152

#endif /* GL_ARB_vertex_array_object */

3153

3154

#ifdef GL_ARB_vertex_blend

3155

3156

static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT)

3157

{

3158

GLboolean r = GL_FALSE;

3159

3160

r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r;

3161

r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r;

3162

r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r;

3163

r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r;

3164

r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r;

3165

r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r;

3166

r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r;

3167

r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r;

3168

r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r;

3169

r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r;

3170

3171

return r;

3172

}

3173

3174

#endif /* GL_ARB_vertex_blend */

3175

3176

#ifdef GL_ARB_vertex_buffer_object

3177

3178

static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

3179

{

3180

GLboolean r = GL_FALSE;

3181

3182

r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;

3183

r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;

3184

r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;

3185

r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;

3186

r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;

3187

r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;

3188

r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;

3189

r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;

3190

r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;

3191

r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;

3192

r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;

3193

3194

return r;

3195

}

3196

3197

#endif /* GL_ARB_vertex_buffer_object */

3198

3199

#ifdef GL_ARB_vertex_program

3200

3201

static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)

3202

{

3203

GLboolean r = GL_FALSE;

3204

3205

r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;

3206

r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;

3207

r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;

3208

r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;

3209

r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;

3210

r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;

3211

r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;

3212

r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;

3213

r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;

3214

r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;

3215

r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;

3216

r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;

3217

r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;

3218

r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;

3219

r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;

3220

r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;

3221

r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;

3222

r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;

3223

r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;

3224

r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;

3225

r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;

3226

r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;

3227

r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;

3228

r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;

3229

r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;

3230

r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;

3231

r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;

3232

r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;

3233

r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;

3234

r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;

3235

r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;

3236

r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;

3237

r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;

3238

r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;

3239

r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;

3240

r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;

3241

r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;

3242

r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;

3243

r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;

3244

r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;

3245

r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;

3246

r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;

3247

r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;

3248

r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;

3249

r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;

3250

r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;

3251

r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;

3252

r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;

3253

r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;

3254

r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;

3255

r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;

3256

r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;

3257

r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;

3258

r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;

3259

r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;

3260

r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;

3261

r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;

3262

r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;

3263

r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;

3264

r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;

3265

r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;

3266

r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;

3267

3268

return r;

3269

}

3270

3271

#endif /* GL_ARB_vertex_program */

3272

3273

#ifdef GL_ARB_vertex_shader

3274

3275

static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)

3276

{

3277

GLboolean r = GL_FALSE;

3278

3279

r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;

3280

r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;

3281

r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;

3282

3283

return r;

3284

}

3285

3286

#endif /* GL_ARB_vertex_shader */

3287

3288

#ifdef GL_ARB_window_pos

3289

3290

static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)

3291

{

3292

GLboolean r = GL_FALSE;

3293

3294

r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r;

3295

r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r;

3296

r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r;

3297

r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r;

3298

r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r;

3299

r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r;

3300

r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r;

3301

r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r;

3302

r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r;

3303

r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r;

3304

r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r;

3305

r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r;

3306

r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r;

3307

r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r;

3308

r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r;

3309

r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r;

3310

3311

return r;

3312

}

3313

3314

#endif /* GL_ARB_window_pos */

3315

3316

#ifdef GL_ATIX_point_sprites

3317

3318

#endif /* GL_ATIX_point_sprites */

3319

3320

#ifdef GL_ATIX_texture_env_combine3

3321

3322

#endif /* GL_ATIX_texture_env_combine3 */

3323

3324

#ifdef GL_ATIX_texture_env_route

3325

3326

#endif /* GL_ATIX_texture_env_route */

3327

3328

#ifdef GL_ATIX_vertex_shader_output_point_size

3329

3330

#endif /* GL_ATIX_vertex_shader_output_point_size */

3331

3332

#ifdef GL_ATI_draw_buffers

3333

3334

static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

3335

{

3336

GLboolean r = GL_FALSE;

3337

3338

r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;

3339

3340

return r;

3341

}

3342

3343

#endif /* GL_ATI_draw_buffers */

3344

3345

#ifdef GL_ATI_element_array

3346

3347

static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT)

3348

{

3349

GLboolean r = GL_FALSE;

3350

3351

r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r;

3352

r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r;

3353

r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r;

3354

3355

return r;

3356

}

3357

3358

#endif /* GL_ATI_element_array */

3359

3360

#ifdef GL_ATI_envmap_bumpmap

3361

3362

static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT)

3363

{

3364

GLboolean r = GL_FALSE;

3365

3366

r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r;

3367

r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r;

3368

r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r;

3369

r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r;

3370

3371

return r;

3372

}

3373

3374

#endif /* GL_ATI_envmap_bumpmap */

3375

3376

#ifdef GL_ATI_fragment_shader

3377

3378

static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)

3379

{

3380

GLboolean r = GL_FALSE;

3381

3382

r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;

3383

r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;

3384

r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;

3385

r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;

3386

r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;

3387

r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;

3388

r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;

3389

r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;

3390

r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;

3391

r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;

3392

r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;

3393

r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;

3394

r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;

3395

r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;

3396

3397

return r;

3398

}

3399

3400

#endif /* GL_ATI_fragment_shader */

3401

3402

#ifdef GL_ATI_map_object_buffer

3403

3404

static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)

3405

{

3406

GLboolean r = GL_FALSE;

3407

3408

r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r;

3409

r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r;

3410

3411

return r;

3412

}

3413

3414

#endif /* GL_ATI_map_object_buffer */

3415

3416

#ifdef GL_ATI_pn_triangles

3417

3418

static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)

3419

{

3420

GLboolean r = GL_FALSE;

3421

3422

r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r;

3423

r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r;

3424

3425

return r;

3426

}

3427

3428

#endif /* GL_ATI_pn_triangles */

3429

3430

#ifdef GL_ATI_separate_stencil

3431

3432

static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT)

3433

{

3434

GLboolean r = GL_FALSE;

3435

3436

r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r;

3437

r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r;

3438

3439

return r;

3440

}

3441

3442

#endif /* GL_ATI_separate_stencil */

3443

3444

#ifdef GL_ATI_shader_texture_lod

3445

3446

#endif /* GL_ATI_shader_texture_lod */

3447

3448

#ifdef GL_ATI_text_fragment_shader

3449

3450

#endif /* GL_ATI_text_fragment_shader */

3451

3452

#ifdef GL_ATI_texture_compression_3dc

3453

3454

#endif /* GL_ATI_texture_compression_3dc */

3455

3456

#ifdef GL_ATI_texture_env_combine3

3457

3458

#endif /* GL_ATI_texture_env_combine3 */

3459

3460

#ifdef GL_ATI_texture_float

3461

3462

#endif /* GL_ATI_texture_float */

3463

3464

#ifdef GL_ATI_texture_mirror_once

3465

3466

#endif /* GL_ATI_texture_mirror_once */

3467

3468

#ifdef GL_ATI_vertex_array_object

3469

3470

static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

3471

{

3472

GLboolean r = GL_FALSE;

3473

3474

r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r;

3475

r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r;

3476

r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r;

3477

r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r;

3478

r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r;

3479

r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r;

3480

r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r;

3481

r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r;

3482

r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r;

3483

r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r;

3484

r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r;

3485

r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r;

3486

3487

return r;

3488

}

3489

3490

#endif /* GL_ATI_vertex_array_object */

3491

3492

#ifdef GL_ATI_vertex_attrib_array_object

3493

3494

static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

3495

{

3496

GLboolean r = GL_FALSE;

3497

3498

r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r;

3499

r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r;

3500

r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r;

3501

3502

return r;

3503

}

3504

3505

#endif /* GL_ATI_vertex_attrib_array_object */

3506

3507

#ifdef GL_ATI_vertex_streams

3508

3509

static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT)

3510

{

3511

GLboolean r = GL_FALSE;

3512

3513

r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r;

3514

r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r;

3515

r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r;

3516

r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r;

3517

r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r;

3518

r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r;

3519

r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r;

3520

r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r;

3521

r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r;

3522

r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r;

3523

r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r;

3524

r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r;

3525

r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r;

3526

r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r;

3527

r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r;

3528

r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r;

3529

r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r;

3530

r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r;

3531

r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r;

3532

r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r;

3533

r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r;

3534

r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r;

3535

r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r;

3536

r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r;

3537

r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r;

3538

r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r;

3539

r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r;

3540

r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r;

3541

r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r;

3542

r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r;

3543

r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r;

3544

r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r;

3545

r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r;

3546

r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r;

3547

r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r;

3548

r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r;

3549

r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r;

3550

3551

return r;

3552

}

3553

3554

#endif /* GL_ATI_vertex_streams */

3555

3556

#ifdef GL_EXT_422_pixels

3557

3558

#endif /* GL_EXT_422_pixels */

3559

3560

#ifdef GL_EXT_Cg_shader

3561

3562

#endif /* GL_EXT_Cg_shader */

3563

3564

#ifdef GL_EXT_abgr

3565

3566

#endif /* GL_EXT_abgr */

3567

3568

#ifdef GL_EXT_bgra

3569

3570

#endif /* GL_EXT_bgra */

3571

3572

#ifdef GL_EXT_bindable_uniform

3573

3574

static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT)

3575

{

3576

GLboolean r = GL_FALSE;

3577

3578

r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r;

3579

r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r;

3580

r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r;

3581

3582

return r;

3583

}

3584

3585

#endif /* GL_EXT_bindable_uniform */

3586

3587

#ifdef GL_EXT_blend_color

3588

3589

static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT)

3590

{

3591

GLboolean r = GL_FALSE;

3592

3593

r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r;

3594

3595

return r;

3596

}

3597

3598

#endif /* GL_EXT_blend_color */

3599

3600

#ifdef GL_EXT_blend_equation_separate

3601

3602

static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT)

3603

{

3604

GLboolean r = GL_FALSE;

3605

3606

r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r;

3607

3608

return r;

3609

}

3610

3611

#endif /* GL_EXT_blend_equation_separate */

3612

3613

#ifdef GL_EXT_blend_func_separate

3614

3615

static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT)

3616

{

3617

GLboolean r = GL_FALSE;

3618

3619

r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r;

3620

3621

return r;

3622

}

3623

3624

#endif /* GL_EXT_blend_func_separate */

3625

3626

#ifdef GL_EXT_blend_logic_op

3627

3628

#endif /* GL_EXT_blend_logic_op */

3629

3630

#ifdef GL_EXT_blend_minmax

3631

3632

static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT)

3633

{

3634

GLboolean r = GL_FALSE;

3635

3636

r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r;

3637

3638

return r;

3639

}

3640

3641

#endif /* GL_EXT_blend_minmax */

3642

3643

#ifdef GL_EXT_blend_subtract

3644

3645

#endif /* GL_EXT_blend_subtract */

3646

3647

#ifdef GL_EXT_clip_volume_hint

3648

3649

#endif /* GL_EXT_clip_volume_hint */

3650

3651

#ifdef GL_EXT_cmyka

3652

3653

#endif /* GL_EXT_cmyka */

3654

3655

#ifdef GL_EXT_color_subtable

3656

3657

static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT)

3658

{

3659

GLboolean r = GL_FALSE;

3660

3661

r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r;

3662

r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r;

3663

3664

return r;

3665

}

3666

3667

#endif /* GL_EXT_color_subtable */

3668

3669

#ifdef GL_EXT_compiled_vertex_array

3670

3671

static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)

3672

{

3673

GLboolean r = GL_FALSE;

3674

3675

r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r;

3676

r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r;

3677

3678

return r;

3679

}

3680

3681

#endif /* GL_EXT_compiled_vertex_array */

3682

3683

#ifdef GL_EXT_convolution

3684

3685

static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT)

3686

{

3687

GLboolean r = GL_FALSE;

3688

3689

r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r;

3690

r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r;

3691

r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r;

3692

r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r;

3693

r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r;

3694

r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r;

3695

r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r;

3696

r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r;

3697

r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r;

3698

r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r;

3699

r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r;

3700

r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r;

3701

r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r;

3702

3703

return r;

3704

}

3705

3706

#endif /* GL_EXT_convolution */

3707

3708

#ifdef GL_EXT_coordinate_frame

3709

3710

static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT)

3711

{

3712

GLboolean r = GL_FALSE;

3713

3714

r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r;

3715

r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r;

3716

3717

return r;

3718

}

3719

3720

#endif /* GL_EXT_coordinate_frame */

3721

3722

#ifdef GL_EXT_copy_texture

3723

3724

static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT)

3725

{

3726

GLboolean r = GL_FALSE;

3727

3728

r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r;

3729

r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r;

3730

r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r;

3731

r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r;

3732

r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r;

3733

3734

return r;

3735

}

3736

3737

#endif /* GL_EXT_copy_texture */

3738

3739

#ifdef GL_EXT_cull_vertex

3740

3741

static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT)

3742

{

3743

GLboolean r = GL_FALSE;

3744

3745

r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r;

3746

r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r;

3747

3748

return r;

3749

}

3750

3751

#endif /* GL_EXT_cull_vertex */

3752

3753

#ifdef GL_EXT_depth_bounds_test

3754

3755

static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT)

3756

{

3757

GLboolean r = GL_FALSE;

3758

3759

r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r;

3760

3761

return r;

3762

}

3763

3764

#endif /* GL_EXT_depth_bounds_test */

3765

3766

#ifdef GL_EXT_direct_state_access

3767

3768

static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT)

3769

{

3770

GLboolean r = GL_FALSE;

3771

3772

r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r;

3773

r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r;

3774

r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r;

3775

r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r;

3776

r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r;

3777

r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r;

3778

r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r;

3779

r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r;

3780

r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r;

3781

r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r;

3782

r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r;

3783

r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r;

3784

r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r;

3785

r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r;

3786

r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r;

3787

r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r;

3788

r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r;

3789

r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r;

3790

r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r;

3791

r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r;

3792

r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r;

3793

r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r;

3794

r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r;

3795

r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r;

3796

r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r;

3797

r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r;

3798

r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r;

3799

r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r;

3800

r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r;

3801

r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r;

3802

r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r;

3803

r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r;

3804

r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r;

3805

r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r;

3806

r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r;

3807

r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r;

3808

r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r;

3809

r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r;

3810

r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r;

3811

r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r;

3812

r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r;

3813

r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r;

3814

r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r;

3815

r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r;

3816

r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r;

3817

r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r;

3818

r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r;

3819

r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r;

3820

r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r;

3821

r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r;

3822

r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r;

3823

r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r;

3824

r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r;

3825

r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r;

3826

r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r;

3827

r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r;

3828

r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r;

3829

r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r;

3830

r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r;

3831

r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r;

3832

r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r;

3833

r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r;

3834

r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r;

3835

r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r;

3836

r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r;

3837

r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r;

3838

r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r;

3839

r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r;

3840

r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r;

3841

r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r;

3842

r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r;

3843

r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r;

3844

r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r;

3845

r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r;

3846

r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r;

3847

r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r;

3848

r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r;

3849

r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r;

3850

r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r;

3851

r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r;

3852

r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r;

3853

r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r;

3854

r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r;

3855

r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r;

3856

r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r;

3857

r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r;

3858

r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r;

3859

r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r;

3860

r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r;

3861

r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r;

3862

r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r;

3863

r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r;

3864

r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r;

3865

r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r;

3866

r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r;

3867

r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r;

3868

r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r;

3869

r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r;

3870

r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r;

3871

r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r;

3872

r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r;

3873

r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r;

3874

r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r;

3875

r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r;

3876

r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r;

3877

r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r;

3878

r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r;

3879

r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r;

3880

r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r;

3881

r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r;

3882

r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r;

3883

r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r;

3884

r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;

3885

r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;

3886

r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;

3887

r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;

3888

r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r;

3889

r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r;

3890

r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r;

3891

r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r;

3892

r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r;

3893

r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r;

3894

r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r;

3895

r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r;

3896

r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r;

3897

r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r;

3898

r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r;

3899

r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r;

3900

r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r;

3901

r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r;

3902

r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r;

3903

r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r;

3904

r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r;

3905

r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r;

3906

r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r;

3907

r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r;

3908

r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r;

3909

r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r;

3910

r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r;

3911

r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r;

3912

r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r;

3913

r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r;

3914

r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r;

3915

r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r;

3916

r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r;

3917

r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r;

3918

r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r;

3919

r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r;

3920

r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r;

3921

r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r;

3922

r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r;

3923

r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r;

3924

r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r;

3925

r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r;

3926

r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r;

3927

r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r;

3928

r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r;

3929

r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r;

3930

r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r;

3931

r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r;

3932

r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r;

3933

r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r;

3934

r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r;

3935

r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r;

3936

r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r;

3937

r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r;

3938

r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r;

3939

r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r;

3940

r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r;

3941

r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r;

3942

r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r;

3943

r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r;

3944

r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r;

3945

r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r;

3946

r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r;

3947

r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r;

3948

r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r;

3949

r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r;

3950

r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r;

3951

r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r;

3952

r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r;

3953

r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r;

3954

r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r;

3955

r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r;

3956

r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r;

3957

r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r;

3958

3959

return r;

3960

}

3961

3962

#endif /* GL_EXT_direct_state_access */

3963

3964

#ifdef GL_EXT_draw_buffers2

3965

3966

static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT)

3967

{

3968

GLboolean r = GL_FALSE;

3969

3970

r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r;

3971

r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r;

3972

r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r;

3973

r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r;

3974

r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r;

3975

r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r;

3976

3977

return r;

3978

}

3979

3980

#endif /* GL_EXT_draw_buffers2 */

3981

3982

#ifdef GL_EXT_draw_instanced

3983

3984

static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)

3985

{

3986

GLboolean r = GL_FALSE;

3987

3988

r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r;

3989

r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r;

3990

3991

return r;

3992

}

3993

3994

#endif /* GL_EXT_draw_instanced */

3995

3996

#ifdef GL_EXT_draw_range_elements

3997

3998

static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT)

3999

{

4000

GLboolean r = GL_FALSE;

4001

4002

r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r;

4003

4004

return r;

4005

}

4006

4007

#endif /* GL_EXT_draw_range_elements */

4008

4009

#ifdef GL_EXT_fog_coord

4010

4011

static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT)

4012

{

4013

GLboolean r = GL_FALSE;

4014

4015

r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r;

4016

r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r;

4017

r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r;

4018

r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r;

4019

r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r;

4020

4021

return r;

4022

}

4023

4024

#endif /* GL_EXT_fog_coord */

4025

4026

#ifdef GL_EXT_fragment_lighting

4027

4028

static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT)

4029

{

4030

GLboolean r = GL_FALSE;

4031

4032

r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r;

4033

r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r;

4034

r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r;

4035

r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r;

4036

r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r;

4037

r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r;

4038

r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r;

4039

r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r;

4040

r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r;

4041

r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r;

4042

r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r;

4043

r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r;

4044

r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r;

4045

r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r;

4046

r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r;

4047

r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r;

4048

r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r;

4049

r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r;

4050

4051

return r;

4052

}

4053

4054

#endif /* GL_EXT_fragment_lighting */

4055

4056

#ifdef GL_EXT_framebuffer_blit

4057

4058

static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT)

4059

{

4060

GLboolean r = GL_FALSE;

4061

4062

r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r;

4063

4064

return r;

4065

}

4066

4067

#endif /* GL_EXT_framebuffer_blit */

4068

4069

#ifdef GL_EXT_framebuffer_multisample

4070

4071

static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

4072

{

4073

GLboolean r = GL_FALSE;

4074

4075

r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r;

4076

4077

return r;

4078

}

4079

4080

#endif /* GL_EXT_framebuffer_multisample */

4081

4082

#ifdef GL_EXT_framebuffer_object

4083

4084

static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

4085

{

4086

GLboolean r = GL_FALSE;

4087

4088

r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;

4089

r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;

4090

r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;

4091

r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;

4092

r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;

4093

r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;

4094

r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;

4095

r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;

4096

r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;

4097

r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;

4098

r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;

4099

r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;

4100

r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;

4101

r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;

4102

r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;

4103

r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;

4104

r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;

4105

4106

return r;

4107

}

4108

4109

#endif /* GL_EXT_framebuffer_object */

4110

4111

#ifdef GL_EXT_framebuffer_sRGB

4112

4113

#endif /* GL_EXT_framebuffer_sRGB */

4114

4115

#ifdef GL_EXT_geometry_shader4

4116

4117

static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)

4118

{

4119

GLboolean r = GL_FALSE;

4120

4121

r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r;

4122

r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r;

4123

r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r;

4124

r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r;

4125

4126

return r;

4127

}

4128

4129

#endif /* GL_EXT_geometry_shader4 */

4130

4131

#ifdef GL_EXT_gpu_program_parameters

4132

4133

static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

4134

{

4135

GLboolean r = GL_FALSE;

4136

4137

r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r;

4138

r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r;

4139

4140

return r;

4141

}

4142

4143

#endif /* GL_EXT_gpu_program_parameters */

4144

4145

#ifdef GL_EXT_gpu_shader4

4146

4147

static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)

4148

{

4149

GLboolean r = GL_FALSE;

4150

4151

r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r;

4152

r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r;

4153

r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r;

4154

r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r;

4155

r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r;

4156

r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r;

4157

r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r;

4158

r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r;

4159

r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r;

4160

r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r;

4161

r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r;

4162

r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r;

4163

r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r;

4164

r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r;

4165

r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r;

4166

r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r;

4167

r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r;

4168

r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r;

4169

r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r;

4170

r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r;

4171

r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r;

4172

r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r;

4173

r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r;

4174

r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r;

4175

r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r;

4176

r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r;

4177

r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r;

4178

r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r;

4179

r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r;

4180

r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r;

4181

r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r;

4182

r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r;

4183

r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r;

4184

r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r;

4185

4186

return r;

4187

}

4188

4189

#endif /* GL_EXT_gpu_shader4 */

4190

4191

#ifdef GL_EXT_histogram

4192

4193

static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT)

4194

{

4195

GLboolean r = GL_FALSE;

4196

4197

r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r;

4198

r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r;

4199

r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r;

4200

r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r;

4201

r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r;

4202

r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r;

4203

r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r;

4204

r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r;

4205

r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r;

4206

r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r;

4207

4208

return r;

4209

}

4210

4211

#endif /* GL_EXT_histogram */

4212

4213

#ifdef GL_EXT_index_array_formats

4214

4215

#endif /* GL_EXT_index_array_formats */

4216

4217

#ifdef GL_EXT_index_func

4218

4219

static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT)

4220

{

4221

GLboolean r = GL_FALSE;

4222

4223

r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r;

4224

4225

return r;

4226

}

4227

4228

#endif /* GL_EXT_index_func */

4229

4230

#ifdef GL_EXT_index_material

4231

4232

static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT)

4233

{

4234

GLboolean r = GL_FALSE;

4235

4236

r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r;

4237

4238

return r;

4239

}

4240

4241

#endif /* GL_EXT_index_material */

4242

4243

#ifdef GL_EXT_index_texture

4244

4245

#endif /* GL_EXT_index_texture */

4246

4247

#ifdef GL_EXT_light_texture

4248

4249

static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4250

{

4251

GLboolean r = GL_FALSE;

4252

4253

r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r;

4254

r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r;

4255

r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r;

4256

4257

return r;

4258

}

4259

4260

#endif /* GL_EXT_light_texture */

4261

4262

#ifdef GL_EXT_misc_attribute

4263

4264

#endif /* GL_EXT_misc_attribute */

4265

4266

#ifdef GL_EXT_multi_draw_arrays

4267

4268

static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

4269

{

4270

GLboolean r = GL_FALSE;

4271

4272

r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r;

4273

r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r;

4274

4275

return r;

4276

}

4277

4278

#endif /* GL_EXT_multi_draw_arrays */

4279

4280

#ifdef GL_EXT_multisample

4281

4282

static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

4283

{

4284

GLboolean r = GL_FALSE;

4285

4286

r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r;

4287

r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r;

4288

4289

return r;

4290

}

4291

4292

#endif /* GL_EXT_multisample */

4293

4294

#ifdef GL_EXT_packed_depth_stencil

4295

4296

#endif /* GL_EXT_packed_depth_stencil */

4297

4298

#ifdef GL_EXT_packed_float

4299

4300

#endif /* GL_EXT_packed_float */

4301

4302

#ifdef GL_EXT_packed_pixels

4303

4304

#endif /* GL_EXT_packed_pixels */

4305

4306

#ifdef GL_EXT_paletted_texture

4307

4308

static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4309

{

4310

GLboolean r = GL_FALSE;

4311

4312

r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r;

4313

r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r;

4314

r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r;

4315

r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r;

4316

4317

return r;

4318

}

4319

4320

#endif /* GL_EXT_paletted_texture */

4321

4322

#ifdef GL_EXT_pixel_buffer_object

4323

4324

#endif /* GL_EXT_pixel_buffer_object */

4325

4326

#ifdef GL_EXT_pixel_transform

4327

4328

static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT)

4329

{

4330

GLboolean r = GL_FALSE;

4331

4332

r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r;

4333

r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r;

4334

r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r;

4335

r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r;

4336

r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r;

4337

r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r;

4338

4339

return r;

4340

}

4341

4342

#endif /* GL_EXT_pixel_transform */

4343

4344

#ifdef GL_EXT_pixel_transform_color_table

4345

4346

#endif /* GL_EXT_pixel_transform_color_table */

4347

4348

#ifdef GL_EXT_point_parameters

4349

4350

static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

4351

{

4352

GLboolean r = GL_FALSE;

4353

4354

r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;

4355

r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;

4356

4357

return r;

4358

}

4359

4360

#endif /* GL_EXT_point_parameters */

4361

4362

#ifdef GL_EXT_polygon_offset

4363

4364

static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)

4365

{

4366

GLboolean r = GL_FALSE;

4367

4368

r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r;

4369

4370

return r;

4371

}

4372

4373

#endif /* GL_EXT_polygon_offset */

4374

4375

#ifdef GL_EXT_rescale_normal

4376

4377

#endif /* GL_EXT_rescale_normal */

4378

4379

#ifdef GL_EXT_scene_marker

4380

4381

static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT)

4382

{

4383

GLboolean r = GL_FALSE;

4384

4385

r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r;

4386

r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r;

4387

4388

return r;

4389

}

4390

4391

#endif /* GL_EXT_scene_marker */

4392

4393

#ifdef GL_EXT_secondary_color

4394

4395

static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)

4396

{

4397

GLboolean r = GL_FALSE;

4398

4399

r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;

4400

r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;

4401

r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;

4402

r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;

4403

r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;

4404

r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;

4405

r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;

4406

r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;

4407

r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;

4408

r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;

4409

r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;

4410

r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;

4411

r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;

4412

r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;

4413

r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;

4414

r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;

4415

r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;

4416

4417

return r;

4418

}

4419

4420

#endif /* GL_EXT_secondary_color */

4421

4422

#ifdef GL_EXT_separate_specular_color

4423

4424

#endif /* GL_EXT_separate_specular_color */

4425

4426

#ifdef GL_EXT_shadow_funcs

4427

4428

#endif /* GL_EXT_shadow_funcs */

4429

4430

#ifdef GL_EXT_shared_texture_palette

4431

4432

#endif /* GL_EXT_shared_texture_palette */

4433

4434

#ifdef GL_EXT_stencil_clear_tag

4435

4436

#endif /* GL_EXT_stencil_clear_tag */

4437

4438

#ifdef GL_EXT_stencil_two_side

4439

4440

static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)

4441

{

4442

GLboolean r = GL_FALSE;

4443

4444

r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;

4445

4446

return r;

4447

}

4448

4449

#endif /* GL_EXT_stencil_two_side */

4450

4451

#ifdef GL_EXT_stencil_wrap

4452

4453

#endif /* GL_EXT_stencil_wrap */

4454

4455

#ifdef GL_EXT_subtexture

4456

4457

static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT)

4458

{

4459

GLboolean r = GL_FALSE;

4460

4461

r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r;

4462

r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r;

4463

r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r;

4464

4465

return r;

4466

}

4467

4468

#endif /* GL_EXT_subtexture */

4469

4470

#ifdef GL_EXT_texture

4471

4472

#endif /* GL_EXT_texture */

4473

4474

#ifdef GL_EXT_texture3D

4475

4476

static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT)

4477

{

4478

GLboolean r = GL_FALSE;

4479

4480

r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r;

4481

4482

return r;

4483

}

4484

4485

#endif /* GL_EXT_texture3D */

4486

4487

#ifdef GL_EXT_texture_array

4488

4489

#endif /* GL_EXT_texture_array */

4490

4491

#ifdef GL_EXT_texture_buffer_object

4492

4493

static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

4494

{

4495

GLboolean r = GL_FALSE;

4496

4497

r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r;

4498

4499

return r;

4500

}

4501

4502

#endif /* GL_EXT_texture_buffer_object */

4503

4504

#ifdef GL_EXT_texture_compression_dxt1

4505

4506

#endif /* GL_EXT_texture_compression_dxt1 */

4507

4508

#ifdef GL_EXT_texture_compression_latc

4509

4510

#endif /* GL_EXT_texture_compression_latc */

4511

4512

#ifdef GL_EXT_texture_compression_rgtc

4513

4514

#endif /* GL_EXT_texture_compression_rgtc */

4515

4516

#ifdef GL_EXT_texture_compression_s3tc

4517

4518

#endif /* GL_EXT_texture_compression_s3tc */

4519

4520

#ifdef GL_EXT_texture_cube_map

4521

4522

#endif /* GL_EXT_texture_cube_map */

4523

4524

#ifdef GL_EXT_texture_edge_clamp

4525

4526

#endif /* GL_EXT_texture_edge_clamp */

4527

4528

#ifdef GL_EXT_texture_env

4529

4530

#endif /* GL_EXT_texture_env */

4531

4532

#ifdef GL_EXT_texture_env_add

4533

4534

#endif /* GL_EXT_texture_env_add */

4535

4536

#ifdef GL_EXT_texture_env_combine

4537

4538

#endif /* GL_EXT_texture_env_combine */

4539

4540

#ifdef GL_EXT_texture_env_dot3

4541

4542

#endif /* GL_EXT_texture_env_dot3 */

4543

4544

#ifdef GL_EXT_texture_filter_anisotropic

4545

4546

#endif /* GL_EXT_texture_filter_anisotropic */

4547

4548

#ifdef GL_EXT_texture_integer

4549

4550

static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT)

4551

{

4552

GLboolean r = GL_FALSE;

4553

4554

r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r;

4555

r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r;

4556

r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r;

4557

r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r;

4558

r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r;

4559

r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r;

4560

4561

return r;

4562

}

4563

4564

#endif /* GL_EXT_texture_integer */

4565

4566

#ifdef GL_EXT_texture_lod_bias

4567

4568

#endif /* GL_EXT_texture_lod_bias */

4569

4570

#ifdef GL_EXT_texture_mirror_clamp

4571

4572

#endif /* GL_EXT_texture_mirror_clamp */

4573

4574

#ifdef GL_EXT_texture_object

4575

4576

static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT)

4577

{

4578

GLboolean r = GL_FALSE;

4579

4580

r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r;

4581

r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r;

4582

r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r;

4583

r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;

4584

r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;

4585

r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;

4586

4587

return r;

4588

}

4589

4590

#endif /* GL_EXT_texture_object */

4591

4592

#ifdef GL_EXT_texture_perturb_normal

4593

4594

static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT)

4595

{

4596

GLboolean r = GL_FALSE;

4597

4598

r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;

4599

4600

return r;

4601

}

4602

4603

#endif /* GL_EXT_texture_perturb_normal */

4604

4605

#ifdef GL_EXT_texture_rectangle

4606

4607

#endif /* GL_EXT_texture_rectangle */

4608

4609

#ifdef GL_EXT_texture_sRGB

4610

4611

#endif /* GL_EXT_texture_sRGB */

4612

4613

#ifdef GL_EXT_texture_shared_exponent

4614

4615

#endif /* GL_EXT_texture_shared_exponent */

4616

4617

#ifdef GL_EXT_texture_swizzle

4618

4619

#endif /* GL_EXT_texture_swizzle */

4620

4621

#ifdef GL_EXT_timer_query

4622

4623

static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)

4624

{

4625

GLboolean r = GL_FALSE;

4626

4627

r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r;

4628

r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r;

4629

4630

return r;

4631

}

4632

4633

#endif /* GL_EXT_timer_query */

4634

4635

#ifdef GL_EXT_transform_feedback

4636

4637

static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)

4638

{

4639

GLboolean r = GL_FALSE;

4640

4641

r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r;

4642

r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r;

4643

r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r;

4644

r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r;

4645

r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r;

4646

r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r;

4647

r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r;

4648

4649

return r;

4650

}

4651

4652

#endif /* GL_EXT_transform_feedback */

4653

4654

#ifdef GL_EXT_vertex_array

4655

4656

static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)

4657

{

4658

GLboolean r = GL_FALSE;

4659

4660

r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;

4661

r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;

4662

r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;

4663

r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;

4664

r = ((glGetPointervEXT = (PFNGLGETPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointervEXT")) == NULL) || r;

4665

r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;

4666

r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;

4667

r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;

4668

r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;

4669

4670

return r;

4671

}

4672

4673

#endif /* GL_EXT_vertex_array */

4674

4675

#ifdef GL_EXT_vertex_array_bgra

4676

4677

#endif /* GL_EXT_vertex_array_bgra */

4678

4679

#ifdef GL_EXT_vertex_shader

4680

4681

static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)

4682

{

4683

GLboolean r = GL_FALSE;

4684

4685

r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;

4686

r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;

4687

r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;

4688

r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;

4689

r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;

4690

r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;

4691

r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;

4692

r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;

4693

r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;

4694

r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;

4695

r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;

4696

r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;

4697

r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;

4698

r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;

4699

r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;

4700

r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;

4701

r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;

4702

r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;

4703

r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;

4704

r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;

4705

r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;

4706

r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;

4707

r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;

4708

r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;

4709

r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;

4710

r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;

4711

r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;

4712

r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;

4713

r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;

4714

r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;

4715

r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;

4716

r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;

4717

r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;

4718

r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;

4719

r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;

4720

r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;

4721

r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;

4722

r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;

4723

r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;

4724

r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;

4725

r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;

4726

r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;

4727

4728

return r;

4729

}

4730

4731

#endif /* GL_EXT_vertex_shader */

4732

4733

#ifdef GL_EXT_vertex_weighting

4734

4735

static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT)

4736

{

4737

GLboolean r = GL_FALSE;

4738

4739

r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;

4740

r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;

4741

r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;

4742

4743

return r;

4744

}

4745

4746

#endif /* GL_EXT_vertex_weighting */

4747

4748

#ifdef GL_GREMEDY_frame_terminator

4749

4750

static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT)

4751

{

4752

GLboolean r = GL_FALSE;

4753

4754

r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r;

4755

4756

return r;

4757

}

4758

4759

#endif /* GL_GREMEDY_frame_terminator */

4760

4761

#ifdef GL_GREMEDY_string_marker

4762

4763

static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT)

4764

{

4765

GLboolean r = GL_FALSE;

4766

4767

r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r;

4768

4769

return r;

4770

}

4771

4772

#endif /* GL_GREMEDY_string_marker */

4773

4774

#ifdef GL_HP_convolution_border_modes

4775

4776

#endif /* GL_HP_convolution_border_modes */

4777

4778

#ifdef GL_HP_image_transform

4779

4780

static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT)

4781

{

4782

GLboolean r = GL_FALSE;

4783

4784

r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;

4785

r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;

4786

r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;

4787

r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;

4788

r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;

4789

r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;

4790

4791

return r;

4792

}

4793

4794

#endif /* GL_HP_image_transform */

4795

4796

#ifdef GL_HP_occlusion_test

4797

4798

#endif /* GL_HP_occlusion_test */

4799

4800

#ifdef GL_HP_texture_lighting

4801

4802

#endif /* GL_HP_texture_lighting */

4803

4804

#ifdef GL_IBM_cull_vertex

4805

4806

#endif /* GL_IBM_cull_vertex */

4807

4808

#ifdef GL_IBM_multimode_draw_arrays

4809

4810

static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

4811

{

4812

GLboolean r = GL_FALSE;

4813

4814

r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;

4815

r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;

4816

4817

return r;

4818

}

4819

4820

#endif /* GL_IBM_multimode_draw_arrays */

4821

4822

#ifdef GL_IBM_rasterpos_clip

4823

4824

#endif /* GL_IBM_rasterpos_clip */

4825

4826

#ifdef GL_IBM_static_data

4827

4828

#endif /* GL_IBM_static_data */

4829

4830

#ifdef GL_IBM_texture_mirrored_repeat

4831

4832

#endif /* GL_IBM_texture_mirrored_repeat */

4833

4834

#ifdef GL_IBM_vertex_array_lists

4835

4836

static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT)

4837

{

4838

GLboolean r = GL_FALSE;

4839

4840

r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;

4841

r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;

4842

r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;

4843

r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;

4844

r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;

4845

r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;

4846

r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;

4847

r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;

4848

4849

return r;

4850

}

4851

4852

#endif /* GL_IBM_vertex_array_lists */

4853

4854

#ifdef GL_INGR_color_clamp

4855

4856

#endif /* GL_INGR_color_clamp */

4857

4858

#ifdef GL_INGR_interlace_read

4859

4860

#endif /* GL_INGR_interlace_read */

4861

4862

#ifdef GL_INTEL_parallel_arrays

4863

4864

static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

4865

{

4866

GLboolean r = GL_FALSE;

4867

4868

r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;

4869

r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;

4870

r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;

4871

r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;

4872

4873

return r;

4874

}

4875

4876

#endif /* GL_INTEL_parallel_arrays */

4877

4878

#ifdef GL_INTEL_texture_scissor

4879

4880

static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT)

4881

{

4882

GLboolean r = GL_FALSE;

4883

4884

r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;

4885

r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;

4886

4887

return r;

4888

}

4889

4890

#endif /* GL_INTEL_texture_scissor */

4891

4892

#ifdef GL_KTX_buffer_region

4893

4894

static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT)

4895

{

4896

GLboolean r = GL_FALSE;

4897

4898

r = ((glBufferRegionEnabledEXT = (PFNGLBUFFERREGIONENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabledEXT")) == NULL) || r;

4899

r = ((glDeleteBufferRegionEXT = (PFNGLDELETEBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegionEXT")) == NULL) || r;

4900

r = ((glDrawBufferRegionEXT = (PFNGLDRAWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegionEXT")) == NULL) || r;

4901

r = ((glNewBufferRegionEXT = (PFNGLNEWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegionEXT")) == NULL) || r;

4902

r = ((glReadBufferRegionEXT = (PFNGLREADBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegionEXT")) == NULL) || r;

4903

4904

return r;

4905

}

4906

4907

#endif /* GL_KTX_buffer_region */

4908

4909

#ifdef GL_MESAX_texture_stack

4910

4911

#endif /* GL_MESAX_texture_stack */

4912

4913

#ifdef GL_MESA_pack_invert

4914

4915

#endif /* GL_MESA_pack_invert */

4916

4917

#ifdef GL_MESA_resize_buffers

4918

4919

static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

4920

{

4921

GLboolean r = GL_FALSE;

4922

4923

r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;

4924

4925

return r;

4926

}

4927

4928

#endif /* GL_MESA_resize_buffers */

4929

4930

#ifdef GL_MESA_window_pos

4931

4932

static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)

4933

{

4934

GLboolean r = GL_FALSE;

4935

4936

r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;

4937

r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;

4938

r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;

4939

r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;

4940

r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;

4941

r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;

4942

r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;

4943

r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;

4944

r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;

4945

r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;

4946

r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;

4947

r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;

4948

r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;

4949

r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;

4950

r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;

4951

r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;

4952

r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;

4953

r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;

4954

r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;

4955

r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;

4956

r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;

4957

r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;

4958

r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;

4959

r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;

4960

4961

return r;

4962

}

4963

4964

#endif /* GL_MESA_window_pos */

4965

4966

#ifdef GL_MESA_ycbcr_texture

4967

4968

#endif /* GL_MESA_ycbcr_texture */

4969

4970

#ifdef GL_NV_blend_square

4971

4972

#endif /* GL_NV_blend_square */

4973

4974

#ifdef GL_NV_conditional_render

4975

4976

static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT)

4977

{

4978

GLboolean r = GL_FALSE;

4979

4980

r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r;

4981

r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r;

4982

4983

return r;

4984

}

4985

4986

#endif /* GL_NV_conditional_render */

4987

4988

#ifdef GL_NV_copy_depth_to_color

4989

4990

#endif /* GL_NV_copy_depth_to_color */

4991

4992

#ifdef GL_NV_depth_buffer_float

4993

4994

static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)

4995

{

4996

GLboolean r = GL_FALSE;

4997

4998

r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r;

4999

r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r;

5000

r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r;

5001

5002

return r;

5003

}

5004

5005

#endif /* GL_NV_depth_buffer_float */

5006

5007

#ifdef GL_NV_depth_clamp

5008

5009

#endif /* GL_NV_depth_clamp */

5010

5011

#ifdef GL_NV_depth_range_unclamped

5012

5013

#endif /* GL_NV_depth_range_unclamped */

5014

5015

#ifdef GL_NV_evaluators

5016

5017

static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)

5018

{

5019

GLboolean r = GL_FALSE;

5020

5021

r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;

5022

r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;

5023

r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;

5024

r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;

5025

r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;

5026

r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;

5027

r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;

5028

r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;

5029

r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;

5030

5031

return r;

5032

}

5033

5034

#endif /* GL_NV_evaluators */

5035

5036

#ifdef GL_NV_explicit_multisample

5037

5038

static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

5039

{

5040

GLboolean r = GL_FALSE;

5041

5042

r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r;

5043

r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r;

5044

r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r;

5045

5046

return r;

5047

}

5048

5049

#endif /* GL_NV_explicit_multisample */

5050

5051

#ifdef GL_NV_fence

5052

5053

static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT)

5054

{

5055

GLboolean r = GL_FALSE;

5056

5057

r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;

5058

r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;

5059

r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;

5060

r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;

5061

r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;

5062

r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;

5063

r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;

5064

5065

return r;

5066

}

5067

5068

#endif /* GL_NV_fence */

5069

5070

#ifdef GL_NV_float_buffer

5071

5072

#endif /* GL_NV_float_buffer */

5073

5074

#ifdef GL_NV_fog_distance

5075

5076

#endif /* GL_NV_fog_distance */

5077

5078

#ifdef GL_NV_fragment_program

5079

5080

static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)

5081

{

5082

GLboolean r = GL_FALSE;

5083

5084

r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;

5085

r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;

5086

r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;

5087

r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;

5088

r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;

5089

r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;

5090

5091

return r;

5092

}

5093

5094

#endif /* GL_NV_fragment_program */

5095

5096

#ifdef GL_NV_fragment_program2

5097

5098

#endif /* GL_NV_fragment_program2 */

5099

5100

#ifdef GL_NV_fragment_program4

5101

5102

#endif /* GL_NV_fragment_program4 */

5103

5104

#ifdef GL_NV_fragment_program_option

5105

5106

#endif /* GL_NV_fragment_program_option */

5107

5108

#ifdef GL_NV_framebuffer_multisample_coverage

5109

5110

static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT)

5111

{

5112

GLboolean r = GL_FALSE;

5113

5114

r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r;

5115

5116

return r;

5117

}

5118

5119

#endif /* GL_NV_framebuffer_multisample_coverage */

5120

5121

#ifdef GL_NV_geometry_program4

5122

5123

static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT)

5124

{

5125

GLboolean r = GL_FALSE;

5126

5127

r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r;

5128

5129

return r;

5130

}

5131

5132

#endif /* GL_NV_geometry_program4 */

5133

5134

#ifdef GL_NV_geometry_shader4

5135

5136

#endif /* GL_NV_geometry_shader4 */

5137

5138

#ifdef GL_NV_gpu_program4

5139

5140

static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT)

5141

{

5142

GLboolean r = GL_FALSE;

5143

5144

r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r;

5145

r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r;

5146

r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r;

5147

r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r;

5148

r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r;

5149

r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r;

5150

r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r;

5151

r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r;

5152

r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r;

5153

r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r;

5154

r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r;

5155

r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r;

5156

5157

return r;

5158

}

5159

5160

#endif /* GL_NV_gpu_program4 */

5161

5162

#ifdef GL_NV_half_float

5163

5164

static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)

5165

{

5166

GLboolean r = GL_FALSE;

5167

5168

r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;

5169

r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;

5170

r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;

5171

r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;

5172

r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;

5173

r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;

5174

r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;

5175

r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;

5176

r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;

5177

r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;

5178

r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;

5179

r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;

5180

r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;

5181

r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;

5182

r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;

5183

r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;

5184

r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;

5185

r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;

5186

r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;

5187

r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;

5188

r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;

5189

r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;

5190

r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;

5191

r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;

5192

r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;

5193

r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;

5194

r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;

5195

r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;

5196

r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;

5197

r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;

5198

r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;

5199

r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;

5200

r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;

5201

r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;

5202

r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;

5203

r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;

5204

r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;

5205

r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;

5206

r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;

5207

r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;

5208

r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;

5209

r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;

5210

r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;

5211

r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;

5212

r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;

5213

r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;

5214

5215

return r;

5216

}

5217

5218

#endif /* GL_NV_half_float */

5219

5220

#ifdef GL_NV_light_max_exponent

5221

5222

#endif /* GL_NV_light_max_exponent */

5223

5224

#ifdef GL_NV_multisample_filter_hint

5225

5226

#endif /* GL_NV_multisample_filter_hint */

5227

5228

#ifdef GL_NV_occlusion_query

5229

5230

static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)

5231

{

5232

GLboolean r = GL_FALSE;

5233

5234

r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;

5235

r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;

5236

r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;

5237

r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;

5238

r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;

5239

r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;

5240

r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;

5241

5242

return r;

5243

}

5244

5245

#endif /* GL_NV_occlusion_query */

5246

5247

#ifdef GL_NV_packed_depth_stencil

5248

5249

#endif /* GL_NV_packed_depth_stencil */

5250

5251

#ifdef GL_NV_parameter_buffer_object

5252

5253

static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

5254

{

5255

GLboolean r = GL_FALSE;

5256

5257

r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r;

5258

r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r;

5259

r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r;

5260

5261

return r;

5262

}

5263

5264

#endif /* GL_NV_parameter_buffer_object */

5265

5266

#ifdef GL_NV_pixel_data_range

5267

5268

static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)

5269

{

5270

GLboolean r = GL_FALSE;

5271

5272

r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;

5273

r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;

5274

5275

return r;

5276

}

5277

5278

#endif /* GL_NV_pixel_data_range */

5279

5280

#ifdef GL_NV_point_sprite

5281

5282

static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT)

5283

{

5284

GLboolean r = GL_FALSE;

5285

5286

r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;

5287

r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;

5288

5289

return r;

5290

}

5291

5292

#endif /* GL_NV_point_sprite */

5293

5294

#ifdef GL_NV_present_video

5295

5296

static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT)

5297

{

5298

GLboolean r = GL_FALSE;

5299

5300

r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r;

5301

r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r;

5302

r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r;

5303

r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r;

5304

r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r;

5305

r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r;

5306

r = ((glVideoParameterivNV = (PFNGLVIDEOPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoParameterivNV")) == NULL) || r;

5307

5308

return r;

5309

}

5310

5311

#endif /* GL_NV_present_video */

5312

5313

#ifdef GL_NV_primitive_restart

5314

5315

static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT)

5316

{

5317

GLboolean r = GL_FALSE;

5318

5319

r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;

5320

r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;

5321

5322

return r;

5323

}

5324

5325

#endif /* GL_NV_primitive_restart */

5326

5327

#ifdef GL_NV_register_combiners

5328

5329

static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)

5330

{

5331

GLboolean r = GL_FALSE;

5332

5333

r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;

5334

r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;

5335

r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;

5336

r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;

5337

r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;

5338

r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;

5339

r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;

5340

r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;

5341

r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;

5342

r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;

5343

r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;

5344

r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;

5345

r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;

5346

5347

return r;

5348

}

5349

5350

#endif /* GL_NV_register_combiners */

5351

5352

#ifdef GL_NV_register_combiners2

5353

5354

static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)

5355

{

5356

GLboolean r = GL_FALSE;

5357

5358

r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;

5359

r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;

5360

5361

return r;

5362

}

5363

5364

#endif /* GL_NV_register_combiners2 */

5365

5366

#ifdef GL_NV_texgen_emboss

5367

5368

#endif /* GL_NV_texgen_emboss */

5369

5370

#ifdef GL_NV_texgen_reflection

5371

5372

#endif /* GL_NV_texgen_reflection */

5373

5374

#ifdef GL_NV_texture_compression_vtc

5375

5376

#endif /* GL_NV_texture_compression_vtc */

5377

5378

#ifdef GL_NV_texture_env_combine4

5379

5380

#endif /* GL_NV_texture_env_combine4 */

5381

5382

#ifdef GL_NV_texture_expand_normal

5383

5384

#endif /* GL_NV_texture_expand_normal */

5385

5386

#ifdef GL_NV_texture_rectangle

5387

5388

#endif /* GL_NV_texture_rectangle */

5389

5390

#ifdef GL_NV_texture_shader

5391

5392

#endif /* GL_NV_texture_shader */

5393

5394

#ifdef GL_NV_texture_shader2

5395

5396

#endif /* GL_NV_texture_shader2 */

5397

5398

#ifdef GL_NV_texture_shader3

5399

5400

#endif /* GL_NV_texture_shader3 */

5401

5402

#ifdef GL_NV_transform_feedback

5403

5404

static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)

5405

{

5406

GLboolean r = GL_FALSE;

5407

5408

r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r;

5409

r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r;

5410

r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r;

5411

r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r;

5412

r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r;

5413

r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r;

5414

r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r;

5415

r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r;

5416

r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r;

5417

r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r;

5418

r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r;

5419

5420

return r;

5421

}

5422

5423

#endif /* GL_NV_transform_feedback */

5424

5425

#ifdef GL_NV_vertex_array_range

5426

5427

static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)

5428

{

5429

GLboolean r = GL_FALSE;

5430

5431

r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;

5432

r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;

5433

5434

return r;

5435

}

5436

5437

#endif /* GL_NV_vertex_array_range */

5438

5439

#ifdef GL_NV_vertex_array_range2

5440

5441

#endif /* GL_NV_vertex_array_range2 */

5442

5443

#ifdef GL_NV_vertex_program

5444

5445

static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)

5446

{

5447

GLboolean r = GL_FALSE;

5448

5449

r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;

5450

r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;

5451

r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;

5452

r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;

5453

r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;

5454

r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;

5455

r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;

5456

r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;

5457

r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;

5458

r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;

5459

r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;

5460

r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;

5461

r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;

5462

r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;

5463

r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;

5464

r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;

5465

r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;

5466

r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;

5467

r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;

5468

r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;

5469

r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;

5470

r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;

5471

r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;

5472

r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;

5473

r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;

5474

r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;

5475

r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;

5476

r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;

5477

r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;

5478

r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;

5479

r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;

5480

r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;

5481

r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;

5482

r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;

5483

r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;

5484

r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;

5485

r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;

5486

r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;

5487

r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;

5488

r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;

5489

r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;

5490

r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;

5491

r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;

5492

r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;

5493

r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;

5494

r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;

5495

r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;

5496

r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;

5497

r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;

5498

r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;

5499

r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;

5500

r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;

5501

r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;

5502

r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;

5503

r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;

5504

r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;

5505

r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;

5506

r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;

5507

r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;

5508

r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;

5509

r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;

5510

r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;

5511

r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;

5512

r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;

5513

5514

return r;

5515

}

5516

5517

#endif /* GL_NV_vertex_program */

5518

5519

#ifdef GL_NV_vertex_program1_1

5520

5521

#endif /* GL_NV_vertex_program1_1 */

5522

5523

#ifdef GL_NV_vertex_program2

5524

5525

#endif /* GL_NV_vertex_program2 */

5526

5527

#ifdef GL_NV_vertex_program2_option

5528

5529

#endif /* GL_NV_vertex_program2_option */

5530

5531

#ifdef GL_NV_vertex_program3

5532

5533

#endif /* GL_NV_vertex_program3 */

5534

5535

#ifdef GL_NV_vertex_program4

5536

5537

#endif /* GL_NV_vertex_program4 */

5538

5539

#ifdef GL_OES_byte_coordinates

5540

5541

#endif /* GL_OES_byte_coordinates */

5542

5543

#ifdef GL_OES_compressed_paletted_texture

5544

5545

#endif /* GL_OES_compressed_paletted_texture */

5546

5547

#ifdef GL_OES_read_format

5548

5549

#endif /* GL_OES_read_format */

5550

5551

#ifdef GL_OES_single_precision

5552

5553

static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT)

5554

{

5555

GLboolean r = GL_FALSE;

5556

5557

r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r;

5558

r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r;

5559

r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r;

5560

r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r;

5561

r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r;

5562

r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r;

5563

5564

return r;

5565

}

5566

5567

#endif /* GL_OES_single_precision */

5568

5569

#ifdef GL_OML_interlace

5570

5571

#endif /* GL_OML_interlace */

5572

5573

#ifdef GL_OML_resample

5574

5575

#endif /* GL_OML_resample */

5576

5577

#ifdef GL_OML_subsample

5578

5579

#endif /* GL_OML_subsample */

5580

5581

#ifdef GL_PGI_misc_hints

5582

5583

#endif /* GL_PGI_misc_hints */

5584

5585

#ifdef GL_PGI_vertex_hints

5586

5587

#endif /* GL_PGI_vertex_hints */

5588

5589

#ifdef GL_REND_screen_coordinates

5590

5591

#endif /* GL_REND_screen_coordinates */

5592

5593

#ifdef GL_S3_s3tc

5594

5595

#endif /* GL_S3_s3tc */

5596

5597

#ifdef GL_SGIS_color_range

5598

5599

#endif /* GL_SGIS_color_range */

5600

5601

#ifdef GL_SGIS_detail_texture

5602

5603

static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT)

5604

{

5605

GLboolean r = GL_FALSE;

5606

5607

r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;

5608

r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;

5609

5610

return r;

5611

}

5612

5613

#endif /* GL_SGIS_detail_texture */

5614

5615

#ifdef GL_SGIS_fog_function

5616

5617

static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT)

5618

{

5619

GLboolean r = GL_FALSE;

5620

5621

r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;

5622

r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;

5623

5624

return r;

5625

}

5626

5627

#endif /* GL_SGIS_fog_function */

5628

5629

#ifdef GL_SGIS_generate_mipmap

5630

5631

#endif /* GL_SGIS_generate_mipmap */

5632

5633

#ifdef GL_SGIS_multisample

5634

5635

static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

5636

{

5637

GLboolean r = GL_FALSE;

5638

5639

r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;

5640

r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;

5641

5642

return r;

5643

}

5644

5645

#endif /* GL_SGIS_multisample */

5646

5647

#ifdef GL_SGIS_pixel_texture

5648

5649

#endif /* GL_SGIS_pixel_texture */

5650

5651

#ifdef GL_SGIS_point_line_texgen

5652

5653

#endif /* GL_SGIS_point_line_texgen */

5654

5655

#ifdef GL_SGIS_sharpen_texture

5656

5657

static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT)

5658

{

5659

GLboolean r = GL_FALSE;

5660

5661

r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;

5662

r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;

5663

5664

return r;

5665

}

5666

5667

#endif /* GL_SGIS_sharpen_texture */

5668

5669

#ifdef GL_SGIS_texture4D

5670

5671

static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT)

5672

{

5673

GLboolean r = GL_FALSE;

5674

5675

r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;

5676

r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;

5677

5678

return r;

5679

}

5680

5681

#endif /* GL_SGIS_texture4D */

5682

5683

#ifdef GL_SGIS_texture_border_clamp

5684

5685

#endif /* GL_SGIS_texture_border_clamp */

5686

5687

#ifdef GL_SGIS_texture_edge_clamp

5688

5689

#endif /* GL_SGIS_texture_edge_clamp */

5690

5691

#ifdef GL_SGIS_texture_filter4

5692

5693

static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT)

5694

{

5695

GLboolean r = GL_FALSE;

5696

5697

r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;

5698

r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;

5699

5700

return r;

5701

}

5702

5703

#endif /* GL_SGIS_texture_filter4 */

5704

5705

#ifdef GL_SGIS_texture_lod

5706

5707

#endif /* GL_SGIS_texture_lod */

5708

5709

#ifdef GL_SGIS_texture_select

5710

5711

#endif /* GL_SGIS_texture_select */

5712

5713

#ifdef GL_SGIX_async

5714

5715

static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT)

5716

{

5717

GLboolean r = GL_FALSE;

5718

5719

r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;

5720

r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;

5721

r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;

5722

r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;

5723

r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;

5724

r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;

5725

5726

return r;

5727

}

5728

5729

#endif /* GL_SGIX_async */

5730

5731

#ifdef GL_SGIX_async_histogram

5732

5733

#endif /* GL_SGIX_async_histogram */

5734

5735

#ifdef GL_SGIX_async_pixel

5736

5737

#endif /* GL_SGIX_async_pixel */

5738

5739

#ifdef GL_SGIX_blend_alpha_minmax

5740

5741

#endif /* GL_SGIX_blend_alpha_minmax */

5742

5743

#ifdef GL_SGIX_clipmap

5744

5745

#endif /* GL_SGIX_clipmap */

5746

5747

#ifdef GL_SGIX_convolution_accuracy

5748

5749

#endif /* GL_SGIX_convolution_accuracy */

5750

5751

#ifdef GL_SGIX_depth_texture

5752

5753

#endif /* GL_SGIX_depth_texture */

5754

5755

#ifdef GL_SGIX_flush_raster

5756

5757

static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT)

5758

{

5759

GLboolean r = GL_FALSE;

5760

5761

r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;

5762

5763

return r;

5764

}

5765

5766

#endif /* GL_SGIX_flush_raster */

5767

5768

#ifdef GL_SGIX_fog_offset

5769

5770

#endif /* GL_SGIX_fog_offset */

5771

5772

#ifdef GL_SGIX_fog_texture

5773

5774

static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT)

5775

{

5776

GLboolean r = GL_FALSE;

5777

5778

r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;

5779

5780

return r;

5781

}

5782

5783

#endif /* GL_SGIX_fog_texture */

5784

5785

#ifdef GL_SGIX_fragment_specular_lighting

5786

5787

static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT)

5788

{

5789

GLboolean r = GL_FALSE;

5790

5791

r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;

5792

r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;

5793

r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;

5794

r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;

5795

r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;

5796

r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;

5797

r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;

5798

r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;

5799

r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;

5800

r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;

5801

r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;

5802

r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;

5803

r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;

5804

r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;

5805

r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;

5806

r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;

5807

r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;

5808

5809

return r;

5810

}

5811

5812

#endif /* GL_SGIX_fragment_specular_lighting */

5813

5814

#ifdef GL_SGIX_framezoom

5815

5816

static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT)

5817

{

5818

GLboolean r = GL_FALSE;

5819

5820

r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;

5821

5822

return r;

5823

}

5824

5825

#endif /* GL_SGIX_framezoom */

5826

5827

#ifdef GL_SGIX_interlace

5828

5829

#endif /* GL_SGIX_interlace */

5830

5831

#ifdef GL_SGIX_ir_instrument1

5832

5833

#endif /* GL_SGIX_ir_instrument1 */

5834

5835

#ifdef GL_SGIX_list_priority

5836

5837

#endif /* GL_SGIX_list_priority */

5838

5839

#ifdef GL_SGIX_pixel_texture

5840

5841

static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT)

5842

{

5843

GLboolean r = GL_FALSE;

5844

5845

r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;

5846

5847

return r;

5848

}

5849

5850

#endif /* GL_SGIX_pixel_texture */

5851

5852

#ifdef GL_SGIX_pixel_texture_bits

5853

5854

#endif /* GL_SGIX_pixel_texture_bits */

5855

5856

#ifdef GL_SGIX_reference_plane

5857

5858

static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT)

5859

{

5860

GLboolean r = GL_FALSE;

5861

5862

r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;

5863

5864

return r;

5865

}

5866

5867

#endif /* GL_SGIX_reference_plane */

5868

5869

#ifdef GL_SGIX_resample

5870

5871

#endif /* GL_SGIX_resample */

5872

5873

#ifdef GL_SGIX_shadow

5874

5875

#endif /* GL_SGIX_shadow */

5876

5877

#ifdef GL_SGIX_shadow_ambient

5878

5879

#endif /* GL_SGIX_shadow_ambient */

5880

5881

#ifdef GL_SGIX_sprite

5882

5883

static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT)

5884

{

5885

GLboolean r = GL_FALSE;

5886

5887

r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;

5888

r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;

5889

r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;

5890

r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;

5891

5892

return r;

5893

}

5894

5895

#endif /* GL_SGIX_sprite */

5896

5897

#ifdef GL_SGIX_tag_sample_buffer

5898

5899

static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT)

5900

{

5901

GLboolean r = GL_FALSE;

5902

5903

r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;

5904

5905

return r;

5906

}

5907

5908

#endif /* GL_SGIX_tag_sample_buffer */

5909

5910

#ifdef GL_SGIX_texture_add_env

5911

5912

#endif /* GL_SGIX_texture_add_env */

5913

5914

#ifdef GL_SGIX_texture_coordinate_clamp

5915

5916

#endif /* GL_SGIX_texture_coordinate_clamp */

5917

5918

#ifdef GL_SGIX_texture_lod_bias

5919

5920

#endif /* GL_SGIX_texture_lod_bias */

5921

5922

#ifdef GL_SGIX_texture_multi_buffer

5923

5924

#endif /* GL_SGIX_texture_multi_buffer */

5925

5926

#ifdef GL_SGIX_texture_range

5927

5928

#endif /* GL_SGIX_texture_range */

5929

5930

#ifdef GL_SGIX_texture_scale_bias

5931

5932

#endif /* GL_SGIX_texture_scale_bias */

5933

5934

#ifdef GL_SGIX_vertex_preclip

5935

5936

#endif /* GL_SGIX_vertex_preclip */

5937

5938

#ifdef GL_SGIX_vertex_preclip_hint

5939

5940

#endif /* GL_SGIX_vertex_preclip_hint */

5941

5942

#ifdef GL_SGIX_ycrcb

5943

5944

#endif /* GL_SGIX_ycrcb */

5945

5946

#ifdef GL_SGI_color_matrix

5947

5948

#endif /* GL_SGI_color_matrix */

5949

5950

#ifdef GL_SGI_color_table

5951

5952

static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT)

5953

{

5954

GLboolean r = GL_FALSE;

5955

5956

r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;

5957

r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;

5958

r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;

5959

r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;

5960

r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;

5961

r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;

5962

r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;

5963

5964

return r;

5965

}

5966

5967

#endif /* GL_SGI_color_table */

5968

5969

#ifdef GL_SGI_texture_color_table

5970

5971

#endif /* GL_SGI_texture_color_table */

5972

5973

#ifdef GL_SUNX_constant_data

5974

5975

static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT)

5976

{

5977

GLboolean r = GL_FALSE;

5978

5979

r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;

5980

5981

return r;

5982

}

5983

5984

#endif /* GL_SUNX_constant_data */

5985

5986

#ifdef GL_SUN_convolution_border_modes

5987

5988

#endif /* GL_SUN_convolution_border_modes */

5989

5990

#ifdef GL_SUN_global_alpha

5991

5992

static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT)

5993

{

5994

GLboolean r = GL_FALSE;

5995

5996

r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;

5997

r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;

5998

r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;

5999

r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;

6000

r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;

6001

r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;

6002

r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;

6003

r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;

6004

6005

return r;

6006

}

6007

6008

#endif /* GL_SUN_global_alpha */

6009

6010

#ifdef GL_SUN_mesh_array

6011

6012

#endif /* GL_SUN_mesh_array */

6013

6014

#ifdef GL_SUN_read_video_pixels

6015

6016

static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT)

6017

{

6018

GLboolean r = GL_FALSE;

6019

6020

r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;

6021

6022

return r;

6023

}

6024

6025

#endif /* GL_SUN_read_video_pixels */

6026

6027

#ifdef GL_SUN_slice_accum

6028

6029

#endif /* GL_SUN_slice_accum */

6030

6031

#ifdef GL_SUN_triangle_list

6032

6033

static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT)

6034

{

6035

GLboolean r = GL_FALSE;

6036

6037

r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;

6038

r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;

6039

r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;

6040

r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;

6041

r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;

6042

r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;

6043

r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;

6044

6045

return r;

6046

}

6047

6048

#endif /* GL_SUN_triangle_list */

6049

6050

#ifdef GL_SUN_vertex

6051

6052

static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT)

6053

{

6054

GLboolean r = GL_FALSE;

6055

6056

r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;

6057

r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;

6058

r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;

6059

r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;

6060

r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;

6061

r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;

6062

r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;

6063

r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;

6064

r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;

6065

r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;

6066

r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;

6067

r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;

6068

r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;

6069

r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;

6070

r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;

6071

r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;

6072

r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;

6073

r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;

6074

r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

6075

r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

6076

r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

6077

r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

6078

r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;

6079

r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;

6080

r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;

6081

r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;

6082

r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;

6083

r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;

6084

r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

6085

r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

6086

r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;

6087

r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;

6088

r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

6089

r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

6090

r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;

6091

r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;

6092

r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;

6093

r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;

6094

r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;

6095

r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;

6096

6097

return r;

6098

}

6099

6100

#endif /* GL_SUN_vertex */

6101

6102

#ifdef GL_WIN_phong_shading

6103

6104

#endif /* GL_WIN_phong_shading */

6105

6106

#ifdef GL_WIN_specular_fog

6107

6108

#endif /* GL_WIN_specular_fog */

6109

6110

#ifdef GL_WIN_swap_hint

6111

6112

static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT)

6113

{

6114

GLboolean r = GL_FALSE;

6115

6116

r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;

6117

6118

return r;

6119

}

6120

6121

#endif /* GL_WIN_swap_hint */

6122

6123

/* ------------------------------------------------------------------------- */

6124

6125

/*

6126

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

6127

* is not sufficient because extension names can be prefixes of

6128

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

6129

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

6130

*/

6131

GLboolean glewGetExtension (const char* name)

6132

{

6133

GLubyte* p;

6134

GLubyte* end;

6135

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

6136

p = (GLubyte*)glGetString(GL_EXTENSIONS);

6137

if (0 == p) return GL_FALSE;

6138

end = p + _glewStrLen(p);

6139

while (p < end)

6140

{

6141

GLuint n = _glewStrCLen(p, ' ');

6142

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

6143

p += n+1;

6144

}

6145

return GL_FALSE;

6146

}

6147

6148

/* ------------------------------------------------------------------------- */

6149

6150

#ifndef GLEW_MX

6151

static

6152

#endif

6153

GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)

6154

{

6155

const GLubyte* s;

6156

GLuint dot, major, minor;

6157

/* query opengl version */

6158

s = glGetString(GL_VERSION);

6159

dot = _glewStrCLen(s, '.');

6160

major = dot-1;

6161

minor = dot+1;

6162

if (dot == 0 || s[minor] == '\0')

6163

return GLEW_ERROR_NO_GL_VERSION;

6164

if (s[major] == '1' && s[minor] == '0')

6165

{

6166

return GLEW_ERROR_GL_VERSION_10_ONLY;

6167

}

6168

else

6169

{

6170

CONST_CAST(GLEW_VERSION_1_1) = GL_TRUE;

6171

if (s[major] >= '2')

6172

{

6173

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

6174

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

6175

CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;

6176

CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE;

6177

CONST_CAST(GLEW_VERSION_2_0) = GL_TRUE;

6178

if (s[minor] >= '1')

6179

{

6180

CONST_CAST(GLEW_VERSION_2_1) = GL_TRUE;

6181

}

6182

}

6183

else

6184

{

6185

if (s[minor] >= '5')

6186

{

6187

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

6188

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

6189

CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;

6190

CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE;

6191

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

6192

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

6193

}

6194

if (s[minor] == '4')

6195

{

6196

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

6197

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

6198

CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE;

6199

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

6200

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

6201

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

6202

}

6203

if (s[minor] == '3')

6204

{

6205

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

6206

CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE;

6207

CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;

6208

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

6209

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

6210

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

6211

}

6212

if (s[minor] == '2')

6213

{

6214

CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE;

6215

CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE;

6216

CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;

6217

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

6218

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

6219

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

6220

}

6221

if (s[minor] < '2')

6222

{

6223

CONST_CAST(GLEW_VERSION_1_2) = GL_FALSE;

6224

CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE;

6225

CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE;

6226

CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE;

6227

CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE;

6228

CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE;

6229

}

6230

}

6231

}

6232

/* initialize extensions */

6233

#ifdef GL_VERSION_1_2

6234

if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);

6235

#endif /* GL_VERSION_1_2 */

6236

#ifdef GL_VERSION_1_3

6237

if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);

6238

#endif /* GL_VERSION_1_3 */

6239

#ifdef GL_VERSION_1_4

6240

if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);

6241

#endif /* GL_VERSION_1_4 */

6242

#ifdef GL_VERSION_1_5

6243

if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);

6244

#endif /* GL_VERSION_1_5 */

6245

#ifdef GL_VERSION_2_0

6246

if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);

6247

#endif /* GL_VERSION_2_0 */

6248

#ifdef GL_VERSION_2_1

6249

if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT);

6250

#endif /* GL_VERSION_2_1 */

6251

#ifdef GL_VERSION_3_0

6252

if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT);

6253

#endif /* GL_VERSION_3_0 */

6254

#ifdef GL_3DFX_multisample

6255

CONST_CAST(GLEW_3DFX_multisample) = glewGetExtension("GL_3DFX_multisample");

6256

#endif /* GL_3DFX_multisample */

6257

#ifdef GL_3DFX_tbuffer

6258

CONST_CAST(GLEW_3DFX_tbuffer) = glewGetExtension("GL_3DFX_tbuffer");

6259

if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

6260

#endif /* GL_3DFX_tbuffer */

6261

#ifdef GL_3DFX_texture_compression_FXT1

6262

CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = glewGetExtension("GL_3DFX_texture_compression_FXT1");

6263

#endif /* GL_3DFX_texture_compression_FXT1 */

6264

#ifdef GL_APPLE_client_storage

6265

CONST_CAST(GLEW_APPLE_client_storage) = glewGetExtension("GL_APPLE_client_storage");

6266

#endif /* GL_APPLE_client_storage */

6267

#ifdef GL_APPLE_element_array

6268

CONST_CAST(GLEW_APPLE_element_array) = glewGetExtension("GL_APPLE_element_array");

6269

if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT);

6270

#endif /* GL_APPLE_element_array */

6271

#ifdef GL_APPLE_fence

6272

CONST_CAST(GLEW_APPLE_fence) = glewGetExtension("GL_APPLE_fence");

6273

if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT);

6274

#endif /* GL_APPLE_fence */

6275

#ifdef GL_APPLE_float_pixels

6276

CONST_CAST(GLEW_APPLE_float_pixels) = glewGetExtension("GL_APPLE_float_pixels");

6277

#endif /* GL_APPLE_float_pixels */

6278

#ifdef GL_APPLE_flush_buffer_range

6279

CONST_CAST(GLEW_APPLE_flush_buffer_range) = glewGetExtension("GL_APPLE_flush_buffer_range");

6280

if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);

6281

#endif /* GL_APPLE_flush_buffer_range */

6282

#ifdef GL_APPLE_pixel_buffer

6283

CONST_CAST(GLEW_APPLE_pixel_buffer) = glewGetExtension("GL_APPLE_pixel_buffer");

6284

#endif /* GL_APPLE_pixel_buffer */

6285

#ifdef GL_APPLE_specular_vector

6286

CONST_CAST(GLEW_APPLE_specular_vector) = glewGetExtension("GL_APPLE_specular_vector");

6287

#endif /* GL_APPLE_specular_vector */

6288

#ifdef GL_APPLE_texture_range

6289

CONST_CAST(GLEW_APPLE_texture_range) = glewGetExtension("GL_APPLE_texture_range");

6290

if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT);

6291

#endif /* GL_APPLE_texture_range */

6292

#ifdef GL_APPLE_transform_hint

6293

CONST_CAST(GLEW_APPLE_transform_hint) = glewGetExtension("GL_APPLE_transform_hint");

6294

#endif /* GL_APPLE_transform_hint */

6295

#ifdef GL_APPLE_vertex_array_object

6296

CONST_CAST(GLEW_APPLE_vertex_array_object) = glewGetExtension("GL_APPLE_vertex_array_object");

6297

if (glewExperimental || GLEW_APPLE_vertex_array_object) CONST_CAST(GLEW_APPLE_vertex_array_object) = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

6298

#endif /* GL_APPLE_vertex_array_object */

6299

#ifdef GL_APPLE_vertex_array_range

6300

CONST_CAST(GLEW_APPLE_vertex_array_range) = glewGetExtension("GL_APPLE_vertex_array_range");

6301

if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

6302

#endif /* GL_APPLE_vertex_array_range */

6303

#ifdef GL_APPLE_ycbcr_422

6304

CONST_CAST(GLEW_APPLE_ycbcr_422) = glewGetExtension("GL_APPLE_ycbcr_422");

6305

#endif /* GL_APPLE_ycbcr_422 */

6306

#ifdef GL_ARB_color_buffer_float

6307

CONST_CAST(GLEW_ARB_color_buffer_float) = glewGetExtension("GL_ARB_color_buffer_float");

6308

if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);

6309

#endif /* GL_ARB_color_buffer_float */

6310

#ifdef GL_ARB_depth_buffer_float

6311

CONST_CAST(GLEW_ARB_depth_buffer_float) = glewGetExtension("GL_ARB_depth_buffer_float");

6312

#endif /* GL_ARB_depth_buffer_float */

6313

#ifdef GL_ARB_depth_texture

6314

CONST_CAST(GLEW_ARB_depth_texture) = glewGetExtension("GL_ARB_depth_texture");

6315

#endif /* GL_ARB_depth_texture */

6316

#ifdef GL_ARB_draw_buffers

6317

CONST_CAST(GLEW_ARB_draw_buffers) = glewGetExtension("GL_ARB_draw_buffers");

6318

if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

6319

#endif /* GL_ARB_draw_buffers */

6320

#ifdef GL_ARB_draw_instanced

6321

CONST_CAST(GLEW_ARB_draw_instanced) = glewGetExtension("GL_ARB_draw_instanced");

6322

if (glewExperimental || GLEW_ARB_draw_instanced) CONST_CAST(GLEW_ARB_draw_instanced) = !_glewInit_GL_ARB_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);

6323

#endif /* GL_ARB_draw_instanced */

6324

#ifdef GL_ARB_fragment_program

6325

CONST_CAST(GLEW_ARB_fragment_program) = glewGetExtension("GL_ARB_fragment_program");

6326

#endif /* GL_ARB_fragment_program */

6327

#ifdef GL_ARB_fragment_program_shadow

6328

CONST_CAST(GLEW_ARB_fragment_program_shadow) = glewGetExtension("GL_ARB_fragment_program_shadow");

6329

#endif /* GL_ARB_fragment_program_shadow */

6330

#ifdef GL_ARB_fragment_shader

6331

CONST_CAST(GLEW_ARB_fragment_shader) = glewGetExtension("GL_ARB_fragment_shader");

6332

#endif /* GL_ARB_fragment_shader */

6333

#ifdef GL_ARB_framebuffer_object

6334

CONST_CAST(GLEW_ARB_framebuffer_object) = glewGetExtension("GL_ARB_framebuffer_object");

6335

if (glewExperimental || GLEW_ARB_framebuffer_object) CONST_CAST(GLEW_ARB_framebuffer_object) = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

6336

#endif /* GL_ARB_framebuffer_object */

6337

#ifdef GL_ARB_framebuffer_sRGB

6338

CONST_CAST(GLEW_ARB_framebuffer_sRGB) = glewGetExtension("GL_ARB_framebuffer_sRGB");

6339

#endif /* GL_ARB_framebuffer_sRGB */

6340

#ifdef GL_ARB_geometry_shader4

6341

CONST_CAST(GLEW_ARB_geometry_shader4) = glewGetExtension("GL_ARB_geometry_shader4");

6342

if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);

6343

#endif /* GL_ARB_geometry_shader4 */

6344

#ifdef GL_ARB_half_float_pixel

6345

CONST_CAST(GLEW_ARB_half_float_pixel) = glewGetExtension("GL_ARB_half_float_pixel");

6346

#endif /* GL_ARB_half_float_pixel */

6347

#ifdef GL_ARB_half_float_vertex

6348

CONST_CAST(GLEW_ARB_half_float_vertex) = glewGetExtension("GL_ARB_half_float_vertex");

6349

#endif /* GL_ARB_half_float_vertex */

6350

#ifdef GL_ARB_imaging

6351

CONST_CAST(GLEW_ARB_imaging) = glewGetExtension("GL_ARB_imaging");

6352

if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT);

6353

#endif /* GL_ARB_imaging */

6354

#ifdef GL_ARB_instanced_arrays

6355

CONST_CAST(GLEW_ARB_instanced_arrays) = glewGetExtension("GL_ARB_instanced_arrays");

6356

if (glewExperimental || GLEW_ARB_instanced_arrays) CONST_CAST(GLEW_ARB_instanced_arrays) = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

6357

#endif /* GL_ARB_instanced_arrays */

6358

#ifdef GL_ARB_map_buffer_range

6359

CONST_CAST(GLEW_ARB_map_buffer_range) = glewGetExtension("GL_ARB_map_buffer_range");

6360

if (glewExperimental || GLEW_ARB_map_buffer_range) CONST_CAST(GLEW_ARB_map_buffer_range) = !_glewInit_GL_ARB_map_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);

6361

#endif /* GL_ARB_map_buffer_range */

6362

#ifdef GL_ARB_matrix_palette

6363

CONST_CAST(GLEW_ARB_matrix_palette) = glewGetExtension("GL_ARB_matrix_palette");

6364

if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT);

6365

#endif /* GL_ARB_matrix_palette */

6366

#ifdef GL_ARB_multisample

6367

CONST_CAST(GLEW_ARB_multisample) = glewGetExtension("GL_ARB_multisample");

6368

if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

6369

#endif /* GL_ARB_multisample */

6370

#ifdef GL_ARB_multitexture

6371

CONST_CAST(GLEW_ARB_multitexture) = glewGetExtension("GL_ARB_multitexture");

6372

if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);

6373

#endif /* GL_ARB_multitexture */

6374

#ifdef GL_ARB_occlusion_query

6375

CONST_CAST(GLEW_ARB_occlusion_query) = glewGetExtension("GL_ARB_occlusion_query");

6376

if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);

6377

#endif /* GL_ARB_occlusion_query */

6378

#ifdef GL_ARB_pixel_buffer_object

6379

CONST_CAST(GLEW_ARB_pixel_buffer_object) = glewGetExtension("GL_ARB_pixel_buffer_object");

6380

#endif /* GL_ARB_pixel_buffer_object */

6381

#ifdef GL_ARB_point_parameters

6382

CONST_CAST(GLEW_ARB_point_parameters) = glewGetExtension("GL_ARB_point_parameters");

6383

if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

6384

#endif /* GL_ARB_point_parameters */

6385

#ifdef GL_ARB_point_sprite

6386

CONST_CAST(GLEW_ARB_point_sprite) = glewGetExtension("GL_ARB_point_sprite");

6387

#endif /* GL_ARB_point_sprite */

6388

#ifdef GL_ARB_shader_objects

6389

CONST_CAST(GLEW_ARB_shader_objects) = glewGetExtension("GL_ARB_shader_objects");

6390

if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);

6391

#endif /* GL_ARB_shader_objects */

6392

#ifdef GL_ARB_shading_language_100

6393

CONST_CAST(GLEW_ARB_shading_language_100) = glewGetExtension("GL_ARB_shading_language_100");

6394

#endif /* GL_ARB_shading_language_100 */

6395

#ifdef GL_ARB_shadow

6396

CONST_CAST(GLEW_ARB_shadow) = glewGetExtension("GL_ARB_shadow");

6397

#endif /* GL_ARB_shadow */

6398

#ifdef GL_ARB_shadow_ambient

6399

CONST_CAST(GLEW_ARB_shadow_ambient) = glewGetExtension("GL_ARB_shadow_ambient");

6400

#endif /* GL_ARB_shadow_ambient */

6401

#ifdef GL_ARB_texture_border_clamp

6402

CONST_CAST(GLEW_ARB_texture_border_clamp) = glewGetExtension("GL_ARB_texture_border_clamp");

6403

#endif /* GL_ARB_texture_border_clamp */

6404

#ifdef GL_ARB_texture_buffer_object

6405

CONST_CAST(GLEW_ARB_texture_buffer_object) = glewGetExtension("GL_ARB_texture_buffer_object");

6406

if (glewExperimental || GLEW_ARB_texture_buffer_object) CONST_CAST(GLEW_ARB_texture_buffer_object) = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

6407

#endif /* GL_ARB_texture_buffer_object */

6408

#ifdef GL_ARB_texture_compression

6409

CONST_CAST(GLEW_ARB_texture_compression) = glewGetExtension("GL_ARB_texture_compression");

6410

if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);

6411

#endif /* GL_ARB_texture_compression */

6412

#ifdef GL_ARB_texture_compression_rgtc

6413

CONST_CAST(GLEW_ARB_texture_compression_rgtc) = glewGetExtension("GL_ARB_texture_compression_rgtc");

6414

#endif /* GL_ARB_texture_compression_rgtc */

6415

#ifdef GL_ARB_texture_cube_map

6416

CONST_CAST(GLEW_ARB_texture_cube_map) = glewGetExtension("GL_ARB_texture_cube_map");

6417

#endif /* GL_ARB_texture_cube_map */

6418

#ifdef GL_ARB_texture_env_add

6419

CONST_CAST(GLEW_ARB_texture_env_add) = glewGetExtension("GL_ARB_texture_env_add");

6420

#endif /* GL_ARB_texture_env_add */

6421

#ifdef GL_ARB_texture_env_combine

6422

CONST_CAST(GLEW_ARB_texture_env_combine) = glewGetExtension("GL_ARB_texture_env_combine");

6423

#endif /* GL_ARB_texture_env_combine */

6424

#ifdef GL_ARB_texture_env_crossbar

6425

CONST_CAST(GLEW_ARB_texture_env_crossbar) = glewGetExtension("GL_ARB_texture_env_crossbar");

6426

#endif /* GL_ARB_texture_env_crossbar */

6427

#ifdef GL_ARB_texture_env_dot3

6428

CONST_CAST(GLEW_ARB_texture_env_dot3) = glewGetExtension("GL_ARB_texture_env_dot3");

6429

#endif /* GL_ARB_texture_env_dot3 */

6430

#ifdef GL_ARB_texture_float

6431

CONST_CAST(GLEW_ARB_texture_float) = glewGetExtension("GL_ARB_texture_float");

6432

#endif /* GL_ARB_texture_float */

6433

#ifdef GL_ARB_texture_mirrored_repeat

6434

CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = glewGetExtension("GL_ARB_texture_mirrored_repeat");

6435

#endif /* GL_ARB_texture_mirrored_repeat */

6436

#ifdef GL_ARB_texture_non_power_of_two

6437

CONST_CAST(GLEW_ARB_texture_non_power_of_two) = glewGetExtension("GL_ARB_texture_non_power_of_two");

6438

#endif /* GL_ARB_texture_non_power_of_two */

6439

#ifdef GL_ARB_texture_rectangle

6440

CONST_CAST(GLEW_ARB_texture_rectangle) = glewGetExtension("GL_ARB_texture_rectangle");

6441

#endif /* GL_ARB_texture_rectangle */

6442

#ifdef GL_ARB_texture_rg

6443

CONST_CAST(GLEW_ARB_texture_rg) = glewGetExtension("GL_ARB_texture_rg");

6444

#endif /* GL_ARB_texture_rg */

6445

#ifdef GL_ARB_transpose_matrix

6446

CONST_CAST(GLEW_ARB_transpose_matrix) = glewGetExtension("GL_ARB_transpose_matrix");

6447

if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT);

6448

#endif /* GL_ARB_transpose_matrix */

6449

#ifdef GL_ARB_vertex_array_object

6450

CONST_CAST(GLEW_ARB_vertex_array_object) = glewGetExtension("GL_ARB_vertex_array_object");

6451

if (glewExperimental || GLEW_ARB_vertex_array_object) CONST_CAST(GLEW_ARB_vertex_array_object) = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

6452

#endif /* GL_ARB_vertex_array_object */

6453

#ifdef GL_ARB_vertex_blend

6454

CONST_CAST(GLEW_ARB_vertex_blend) = glewGetExtension("GL_ARB_vertex_blend");

6455

if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT);

6456

#endif /* GL_ARB_vertex_blend */

6457

#ifdef GL_ARB_vertex_buffer_object

6458

CONST_CAST(GLEW_ARB_vertex_buffer_object) = glewGetExtension("GL_ARB_vertex_buffer_object");

6459

if (glewExperimental || GLEW_ARB_vertex_buffer_object) CONST_CAST(GLEW_ARB_vertex_buffer_object) = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

6460

#endif /* GL_ARB_vertex_buffer_object */

6461

#ifdef GL_ARB_vertex_program

6462

CONST_CAST(GLEW_ARB_vertex_program) = glewGetExtension("GL_ARB_vertex_program");

6463

if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);

6464

#endif /* GL_ARB_vertex_program */

6465

#ifdef GL_ARB_vertex_shader

6466

CONST_CAST(GLEW_ARB_vertex_shader) = glewGetExtension("GL_ARB_vertex_shader");

6467

if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);

6468

#endif /* GL_ARB_vertex_shader */

6469

#ifdef GL_ARB_window_pos

6470

CONST_CAST(GLEW_ARB_window_pos) = glewGetExtension("GL_ARB_window_pos");

6471

if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);

6472

#endif /* GL_ARB_window_pos */

6473

#ifdef GL_ATIX_point_sprites

6474

CONST_CAST(GLEW_ATIX_point_sprites) = glewGetExtension("GL_ATIX_point_sprites");

6475

#endif /* GL_ATIX_point_sprites */

6476

#ifdef GL_ATIX_texture_env_combine3

6477

CONST_CAST(GLEW_ATIX_texture_env_combine3) = glewGetExtension("GL_ATIX_texture_env_combine3");

6478

#endif /* GL_ATIX_texture_env_combine3 */

6479

#ifdef GL_ATIX_texture_env_route

6480

CONST_CAST(GLEW_ATIX_texture_env_route) = glewGetExtension("GL_ATIX_texture_env_route");

6481

#endif /* GL_ATIX_texture_env_route */

6482

#ifdef GL_ATIX_vertex_shader_output_point_size

6483

CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = glewGetExtension("GL_ATIX_vertex_shader_output_point_size");

6484

#endif /* GL_ATIX_vertex_shader_output_point_size */

6485

#ifdef GL_ATI_draw_buffers

6486

CONST_CAST(GLEW_ATI_draw_buffers) = glewGetExtension("GL_ATI_draw_buffers");

6487

if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

6488

#endif /* GL_ATI_draw_buffers */

6489

#ifdef GL_ATI_element_array

6490

CONST_CAST(GLEW_ATI_element_array) = glewGetExtension("GL_ATI_element_array");

6491

if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT);

6492

#endif /* GL_ATI_element_array */

6493

#ifdef GL_ATI_envmap_bumpmap

6494

CONST_CAST(GLEW_ATI_envmap_bumpmap) = glewGetExtension("GL_ATI_envmap_bumpmap");

6495

if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT);

6496

#endif /* GL_ATI_envmap_bumpmap */

6497

#ifdef GL_ATI_fragment_shader

6498

CONST_CAST(GLEW_ATI_fragment_shader) = glewGetExtension("GL_ATI_fragment_shader");

6499

if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);

6500

#endif /* GL_ATI_fragment_shader */

6501

#ifdef GL_ATI_map_object_buffer

6502

CONST_CAST(GLEW_ATI_map_object_buffer) = glewGetExtension("GL_ATI_map_object_buffer");

6503

if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

6504

#endif /* GL_ATI_map_object_buffer */

6505

#ifdef GL_ATI_pn_triangles

6506

CONST_CAST(GLEW_ATI_pn_triangles) = glewGetExtension("GL_ATI_pn_triangles");

6507

if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);

6508

#endif /* GL_ATI_pn_triangles */

6509

#ifdef GL_ATI_separate_stencil

6510

CONST_CAST(GLEW_ATI_separate_stencil) = glewGetExtension("GL_ATI_separate_stencil");

6511

if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT);

6512

#endif /* GL_ATI_separate_stencil */

6513

#ifdef GL_ATI_shader_texture_lod

6514

CONST_CAST(GLEW_ATI_shader_texture_lod) = glewGetExtension("GL_ATI_shader_texture_lod");

6515

#endif /* GL_ATI_shader_texture_lod */

6516

#ifdef GL_ATI_text_fragment_shader

6517

CONST_CAST(GLEW_ATI_text_fragment_shader) = glewGetExtension("GL_ATI_text_fragment_shader");

6518

#endif /* GL_ATI_text_fragment_shader */

6519

#ifdef GL_ATI_texture_compression_3dc

6520

CONST_CAST(GLEW_ATI_texture_compression_3dc) = glewGetExtension("GL_ATI_texture_compression_3dc");

6521

#endif /* GL_ATI_texture_compression_3dc */

6522

#ifdef GL_ATI_texture_env_combine3

6523

CONST_CAST(GLEW_ATI_texture_env_combine3) = glewGetExtension("GL_ATI_texture_env_combine3");

6524

#endif /* GL_ATI_texture_env_combine3 */

6525

#ifdef GL_ATI_texture_float

6526

CONST_CAST(GLEW_ATI_texture_float) = glewGetExtension("GL_ATI_texture_float");

6527

#endif /* GL_ATI_texture_float */

6528

#ifdef GL_ATI_texture_mirror_once

6529

CONST_CAST(GLEW_ATI_texture_mirror_once) = glewGetExtension("GL_ATI_texture_mirror_once");

6530

#endif /* GL_ATI_texture_mirror_once */

6531

#ifdef GL_ATI_vertex_array_object

6532

CONST_CAST(GLEW_ATI_vertex_array_object) = glewGetExtension("GL_ATI_vertex_array_object");

6533

if (glewExperimental || GLEW_ATI_vertex_array_object) CONST_CAST(GLEW_ATI_vertex_array_object) = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

6534

#endif /* GL_ATI_vertex_array_object */

6535

#ifdef GL_ATI_vertex_attrib_array_object

6536

CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = glewGetExtension("GL_ATI_vertex_attrib_array_object");

6537

if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

6538

#endif /* GL_ATI_vertex_attrib_array_object */

6539

#ifdef GL_ATI_vertex_streams

6540

CONST_CAST(GLEW_ATI_vertex_streams) = glewGetExtension("GL_ATI_vertex_streams");

6541

if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT);

6542

#endif /* GL_ATI_vertex_streams */

6543

#ifdef GL_EXT_422_pixels

6544

CONST_CAST(GLEW_EXT_422_pixels) = glewGetExtension("GL_EXT_422_pixels");

6545

#endif /* GL_EXT_422_pixels */

6546

#ifdef GL_EXT_Cg_shader

6547

CONST_CAST(GLEW_EXT_Cg_shader) = glewGetExtension("GL_EXT_Cg_shader");

6548

#endif /* GL_EXT_Cg_shader */

6549

#ifdef GL_EXT_abgr

6550

CONST_CAST(GLEW_EXT_abgr) = glewGetExtension("GL_EXT_abgr");

6551

#endif /* GL_EXT_abgr */

6552

#ifdef GL_EXT_bgra

6553

CONST_CAST(GLEW_EXT_bgra) = glewGetExtension("GL_EXT_bgra");

6554

#endif /* GL_EXT_bgra */

6555

#ifdef GL_EXT_bindable_uniform

6556

CONST_CAST(GLEW_EXT_bindable_uniform) = glewGetExtension("GL_EXT_bindable_uniform");

6557

if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT);

6558

#endif /* GL_EXT_bindable_uniform */

6559

#ifdef GL_EXT_blend_color

6560

CONST_CAST(GLEW_EXT_blend_color) = glewGetExtension("GL_EXT_blend_color");

6561

if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT);

6562

#endif /* GL_EXT_blend_color */

6563

#ifdef GL_EXT_blend_equation_separate

6564

CONST_CAST(GLEW_EXT_blend_equation_separate) = glewGetExtension("GL_EXT_blend_equation_separate");

6565

if (glewExperimental || GLEW_EXT_blend_equation_separate) CONST_CAST(GLEW_EXT_blend_equation_separate) = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT);

6566

#endif /* GL_EXT_blend_equation_separate */

6567

#ifdef GL_EXT_blend_func_separate

6568

CONST_CAST(GLEW_EXT_blend_func_separate) = glewGetExtension("GL_EXT_blend_func_separate");

6569

if (glewExperimental || GLEW_EXT_blend_func_separate) CONST_CAST(GLEW_EXT_blend_func_separate) = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT);

6570

#endif /* GL_EXT_blend_func_separate */

6571

#ifdef GL_EXT_blend_logic_op

6572

CONST_CAST(GLEW_EXT_blend_logic_op) = glewGetExtension("GL_EXT_blend_logic_op");

6573

#endif /* GL_EXT_blend_logic_op */

6574

#ifdef GL_EXT_blend_minmax

6575

CONST_CAST(GLEW_EXT_blend_minmax) = glewGetExtension("GL_EXT_blend_minmax");

6576

if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT);

6577

#endif /* GL_EXT_blend_minmax */

6578

#ifdef GL_EXT_blend_subtract

6579

CONST_CAST(GLEW_EXT_blend_subtract) = glewGetExtension("GL_EXT_blend_subtract");

6580

#endif /* GL_EXT_blend_subtract */

6581

#ifdef GL_EXT_clip_volume_hint

6582

CONST_CAST(GLEW_EXT_clip_volume_hint) = glewGetExtension("GL_EXT_clip_volume_hint");

6583

#endif /* GL_EXT_clip_volume_hint */

6584

#ifdef GL_EXT_cmyka

6585

CONST_CAST(GLEW_EXT_cmyka) = glewGetExtension("GL_EXT_cmyka");

6586

#endif /* GL_EXT_cmyka */

6587

#ifdef GL_EXT_color_subtable

6588

CONST_CAST(GLEW_EXT_color_subtable) = glewGetExtension("GL_EXT_color_subtable");

6589

if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT);

6590

#endif /* GL_EXT_color_subtable */

6591

#ifdef GL_EXT_compiled_vertex_array

6592

CONST_CAST(GLEW_EXT_compiled_vertex_array) = glewGetExtension("GL_EXT_compiled_vertex_array");

6593

if (glewExperimental || GLEW_EXT_compiled_vertex_array) CONST_CAST(GLEW_EXT_compiled_vertex_array) = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);

6594

#endif /* GL_EXT_compiled_vertex_array */

6595

#ifdef GL_EXT_convolution

6596

CONST_CAST(GLEW_EXT_convolution) = glewGetExtension("GL_EXT_convolution");

6597

if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT);

6598

#endif /* GL_EXT_convolution */

6599

#ifdef GL_EXT_coordinate_frame

6600

CONST_CAST(GLEW_EXT_coordinate_frame) = glewGetExtension("GL_EXT_coordinate_frame");

6601

if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT);

6602

#endif /* GL_EXT_coordinate_frame */

6603

#ifdef GL_EXT_copy_texture

6604

CONST_CAST(GLEW_EXT_copy_texture) = glewGetExtension("GL_EXT_copy_texture");

6605

if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6606

#endif /* GL_EXT_copy_texture */

6607

#ifdef GL_EXT_cull_vertex

6608

CONST_CAST(GLEW_EXT_cull_vertex) = glewGetExtension("GL_EXT_cull_vertex");

6609

if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT);

6610

#endif /* GL_EXT_cull_vertex */

6611

#ifdef GL_EXT_depth_bounds_test

6612

CONST_CAST(GLEW_EXT_depth_bounds_test) = glewGetExtension("GL_EXT_depth_bounds_test");

6613

if (glewExperimental || GLEW_EXT_depth_bounds_test) CONST_CAST(GLEW_EXT_depth_bounds_test) = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT);

6614

#endif /* GL_EXT_depth_bounds_test */

6615

#ifdef GL_EXT_direct_state_access

6616

CONST_CAST(GLEW_EXT_direct_state_access) = glewGetExtension("GL_EXT_direct_state_access");

6617

if (glewExperimental || GLEW_EXT_direct_state_access) CONST_CAST(GLEW_EXT_direct_state_access) = !_glewInit_GL_EXT_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT);

6618

#endif /* GL_EXT_direct_state_access */

6619

#ifdef GL_EXT_draw_buffers2

6620

CONST_CAST(GLEW_EXT_draw_buffers2) = glewGetExtension("GL_EXT_draw_buffers2");

6621

if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT);

6622

#endif /* GL_EXT_draw_buffers2 */

6623

#ifdef GL_EXT_draw_instanced

6624

CONST_CAST(GLEW_EXT_draw_instanced) = glewGetExtension("GL_EXT_draw_instanced");

6625

if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);

6626

#endif /* GL_EXT_draw_instanced */

6627

#ifdef GL_EXT_draw_range_elements

6628

CONST_CAST(GLEW_EXT_draw_range_elements) = glewGetExtension("GL_EXT_draw_range_elements");

6629

if (glewExperimental || GLEW_EXT_draw_range_elements) CONST_CAST(GLEW_EXT_draw_range_elements) = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT);

6630

#endif /* GL_EXT_draw_range_elements */

6631

#ifdef GL_EXT_fog_coord

6632

CONST_CAST(GLEW_EXT_fog_coord) = glewGetExtension("GL_EXT_fog_coord");

6633

if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT);

6634

#endif /* GL_EXT_fog_coord */

6635

#ifdef GL_EXT_fragment_lighting

6636

CONST_CAST(GLEW_EXT_fragment_lighting) = glewGetExtension("GL_EXT_fragment_lighting");

6637

if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT);

6638

#endif /* GL_EXT_fragment_lighting */

6639

#ifdef GL_EXT_framebuffer_blit

6640

CONST_CAST(GLEW_EXT_framebuffer_blit) = glewGetExtension("GL_EXT_framebuffer_blit");

6641

if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT);

6642

#endif /* GL_EXT_framebuffer_blit */

6643

#ifdef GL_EXT_framebuffer_multisample

6644

CONST_CAST(GLEW_EXT_framebuffer_multisample) = glewGetExtension("GL_EXT_framebuffer_multisample");

6645

if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

6646

#endif /* GL_EXT_framebuffer_multisample */

6647

#ifdef GL_EXT_framebuffer_object

6648

CONST_CAST(GLEW_EXT_framebuffer_object) = glewGetExtension("GL_EXT_framebuffer_object");

6649

if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

6650

#endif /* GL_EXT_framebuffer_object */

6651

#ifdef GL_EXT_framebuffer_sRGB

6652

CONST_CAST(GLEW_EXT_framebuffer_sRGB) = glewGetExtension("GL_EXT_framebuffer_sRGB");

6653

#endif /* GL_EXT_framebuffer_sRGB */

6654

#ifdef GL_EXT_geometry_shader4

6655

CONST_CAST(GLEW_EXT_geometry_shader4) = glewGetExtension("GL_EXT_geometry_shader4");

6656

if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);

6657

#endif /* GL_EXT_geometry_shader4 */

6658

#ifdef GL_EXT_gpu_program_parameters

6659

CONST_CAST(GLEW_EXT_gpu_program_parameters) = glewGetExtension("GL_EXT_gpu_program_parameters");

6660

if (glewExperimental || GLEW_EXT_gpu_program_parameters) CONST_CAST(GLEW_EXT_gpu_program_parameters) = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

6661

#endif /* GL_EXT_gpu_program_parameters */

6662

#ifdef GL_EXT_gpu_shader4

6663

CONST_CAST(GLEW_EXT_gpu_shader4) = glewGetExtension("GL_EXT_gpu_shader4");

6664

if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT);

6665

#endif /* GL_EXT_gpu_shader4 */

6666

#ifdef GL_EXT_histogram

6667

CONST_CAST(GLEW_EXT_histogram) = glewGetExtension("GL_EXT_histogram");

6668

if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT);

6669

#endif /* GL_EXT_histogram */

6670

#ifdef GL_EXT_index_array_formats

6671

CONST_CAST(GLEW_EXT_index_array_formats) = glewGetExtension("GL_EXT_index_array_formats");

6672

#endif /* GL_EXT_index_array_formats */

6673

#ifdef GL_EXT_index_func

6674

CONST_CAST(GLEW_EXT_index_func) = glewGetExtension("GL_EXT_index_func");

6675

if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT);

6676

#endif /* GL_EXT_index_func */

6677

#ifdef GL_EXT_index_material

6678

CONST_CAST(GLEW_EXT_index_material) = glewGetExtension("GL_EXT_index_material");

6679

if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT);

6680

#endif /* GL_EXT_index_material */

6681

#ifdef GL_EXT_index_texture

6682

CONST_CAST(GLEW_EXT_index_texture) = glewGetExtension("GL_EXT_index_texture");

6683

#endif /* GL_EXT_index_texture */

6684

#ifdef GL_EXT_light_texture

6685

CONST_CAST(GLEW_EXT_light_texture) = glewGetExtension("GL_EXT_light_texture");

6686

if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6687

#endif /* GL_EXT_light_texture */

6688

#ifdef GL_EXT_misc_attribute

6689

CONST_CAST(GLEW_EXT_misc_attribute) = glewGetExtension("GL_EXT_misc_attribute");

6690

#endif /* GL_EXT_misc_attribute */

6691

#ifdef GL_EXT_multi_draw_arrays

6692

CONST_CAST(GLEW_EXT_multi_draw_arrays) = glewGetExtension("GL_EXT_multi_draw_arrays");

6693

if (glewExperimental || GLEW_EXT_multi_draw_arrays) CONST_CAST(GLEW_EXT_multi_draw_arrays) = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

6694

#endif /* GL_EXT_multi_draw_arrays */

6695

#ifdef GL_EXT_multisample

6696

CONST_CAST(GLEW_EXT_multisample) = glewGetExtension("GL_EXT_multisample");

6697

if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

6698

#endif /* GL_EXT_multisample */

6699

#ifdef GL_EXT_packed_depth_stencil

6700

CONST_CAST(GLEW_EXT_packed_depth_stencil) = glewGetExtension("GL_EXT_packed_depth_stencil");

6701

#endif /* GL_EXT_packed_depth_stencil */

6702

#ifdef GL_EXT_packed_float

6703

CONST_CAST(GLEW_EXT_packed_float) = glewGetExtension("GL_EXT_packed_float");

6704

#endif /* GL_EXT_packed_float */

6705

#ifdef GL_EXT_packed_pixels

6706

CONST_CAST(GLEW_EXT_packed_pixels) = glewGetExtension("GL_EXT_packed_pixels");

6707

#endif /* GL_EXT_packed_pixels */

6708

#ifdef GL_EXT_paletted_texture

6709

CONST_CAST(GLEW_EXT_paletted_texture) = glewGetExtension("GL_EXT_paletted_texture");

6710

if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6711

#endif /* GL_EXT_paletted_texture */

6712

#ifdef GL_EXT_pixel_buffer_object

6713

CONST_CAST(GLEW_EXT_pixel_buffer_object) = glewGetExtension("GL_EXT_pixel_buffer_object");

6714

#endif /* GL_EXT_pixel_buffer_object */

6715

#ifdef GL_EXT_pixel_transform

6716

CONST_CAST(GLEW_EXT_pixel_transform) = glewGetExtension("GL_EXT_pixel_transform");

6717

if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT);

6718

#endif /* GL_EXT_pixel_transform */

6719

#ifdef GL_EXT_pixel_transform_color_table

6720

CONST_CAST(GLEW_EXT_pixel_transform_color_table) = glewGetExtension("GL_EXT_pixel_transform_color_table");

6721

#endif /* GL_EXT_pixel_transform_color_table */

6722

#ifdef GL_EXT_point_parameters

6723

CONST_CAST(GLEW_EXT_point_parameters) = glewGetExtension("GL_EXT_point_parameters");

6724

if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

6725

#endif /* GL_EXT_point_parameters */

6726

#ifdef GL_EXT_polygon_offset

6727

CONST_CAST(GLEW_EXT_polygon_offset) = glewGetExtension("GL_EXT_polygon_offset");

6728

if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);

6729

#endif /* GL_EXT_polygon_offset */

6730

#ifdef GL_EXT_rescale_normal

6731

CONST_CAST(GLEW_EXT_rescale_normal) = glewGetExtension("GL_EXT_rescale_normal");

6732

#endif /* GL_EXT_rescale_normal */

6733

#ifdef GL_EXT_scene_marker

6734

CONST_CAST(GLEW_EXT_scene_marker) = glewGetExtension("GL_EXT_scene_marker");

6735

if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT);

6736

#endif /* GL_EXT_scene_marker */

6737

#ifdef GL_EXT_secondary_color

6738

CONST_CAST(GLEW_EXT_secondary_color) = glewGetExtension("GL_EXT_secondary_color");

6739

if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);

6740

#endif /* GL_EXT_secondary_color */

6741

#ifdef GL_EXT_separate_specular_color

6742

CONST_CAST(GLEW_EXT_separate_specular_color) = glewGetExtension("GL_EXT_separate_specular_color");

6743

#endif /* GL_EXT_separate_specular_color */

6744

#ifdef GL_EXT_shadow_funcs

6745

CONST_CAST(GLEW_EXT_shadow_funcs) = glewGetExtension("GL_EXT_shadow_funcs");

6746

#endif /* GL_EXT_shadow_funcs */

6747

#ifdef GL_EXT_shared_texture_palette

6748

CONST_CAST(GLEW_EXT_shared_texture_palette) = glewGetExtension("GL_EXT_shared_texture_palette");

6749

#endif /* GL_EXT_shared_texture_palette */

6750

#ifdef GL_EXT_stencil_clear_tag

6751

CONST_CAST(GLEW_EXT_stencil_clear_tag) = glewGetExtension("GL_EXT_stencil_clear_tag");

6752

#endif /* GL_EXT_stencil_clear_tag */

6753

#ifdef GL_EXT_stencil_two_side

6754

CONST_CAST(GLEW_EXT_stencil_two_side) = glewGetExtension("GL_EXT_stencil_two_side");

6755

if (glewExperimental || GLEW_EXT_stencil_two_side) CONST_CAST(GLEW_EXT_stencil_two_side) = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT);

6756

#endif /* GL_EXT_stencil_two_side */

6757

#ifdef GL_EXT_stencil_wrap

6758

CONST_CAST(GLEW_EXT_stencil_wrap) = glewGetExtension("GL_EXT_stencil_wrap");

6759

#endif /* GL_EXT_stencil_wrap */

6760

#ifdef GL_EXT_subtexture

6761

CONST_CAST(GLEW_EXT_subtexture) = glewGetExtension("GL_EXT_subtexture");

6762

if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT);

6763

#endif /* GL_EXT_subtexture */

6764

#ifdef GL_EXT_texture

6765

CONST_CAST(GLEW_EXT_texture) = glewGetExtension("GL_EXT_texture");

6766

#endif /* GL_EXT_texture */

6767

#ifdef GL_EXT_texture3D

6768

CONST_CAST(GLEW_EXT_texture3D) = glewGetExtension("GL_EXT_texture3D");

6769

if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT);

6770

#endif /* GL_EXT_texture3D */

6771

#ifdef GL_EXT_texture_array

6772

CONST_CAST(GLEW_EXT_texture_array) = glewGetExtension("GL_EXT_texture_array");

6773

#endif /* GL_EXT_texture_array */

6774

#ifdef GL_EXT_texture_buffer_object

6775

CONST_CAST(GLEW_EXT_texture_buffer_object) = glewGetExtension("GL_EXT_texture_buffer_object");

6776

if (glewExperimental || GLEW_EXT_texture_buffer_object) CONST_CAST(GLEW_EXT_texture_buffer_object) = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

6777

#endif /* GL_EXT_texture_buffer_object */

6778

#ifdef GL_EXT_texture_compression_dxt1

6779

CONST_CAST(GLEW_EXT_texture_compression_dxt1) = glewGetExtension("GL_EXT_texture_compression_dxt1");

6780

#endif /* GL_EXT_texture_compression_dxt1 */

6781

#ifdef GL_EXT_texture_compression_latc

6782

CONST_CAST(GLEW_EXT_texture_compression_latc) = glewGetExtension("GL_EXT_texture_compression_latc");

6783

#endif /* GL_EXT_texture_compression_latc */

6784

#ifdef GL_EXT_texture_compression_rgtc

6785

CONST_CAST(GLEW_EXT_texture_compression_rgtc) = glewGetExtension("GL_EXT_texture_compression_rgtc");

6786

#endif /* GL_EXT_texture_compression_rgtc */

6787

#ifdef GL_EXT_texture_compression_s3tc

6788

CONST_CAST(GLEW_EXT_texture_compression_s3tc) = glewGetExtension("GL_EXT_texture_compression_s3tc");

6789

#endif /* GL_EXT_texture_compression_s3tc */

6790

#ifdef GL_EXT_texture_cube_map

6791

CONST_CAST(GLEW_EXT_texture_cube_map) = glewGetExtension("GL_EXT_texture_cube_map");

6792

#endif /* GL_EXT_texture_cube_map */

6793

#ifdef GL_EXT_texture_edge_clamp

6794

CONST_CAST(GLEW_EXT_texture_edge_clamp) = glewGetExtension("GL_EXT_texture_edge_clamp");

6795

#endif /* GL_EXT_texture_edge_clamp */

6796

#ifdef GL_EXT_texture_env

6797

CONST_CAST(GLEW_EXT_texture_env) = glewGetExtension("GL_EXT_texture_env");

6798

#endif /* GL_EXT_texture_env */

6799

#ifdef GL_EXT_texture_env_add

6800

CONST_CAST(GLEW_EXT_texture_env_add) = glewGetExtension("GL_EXT_texture_env_add");

6801

#endif /* GL_EXT_texture_env_add */

6802

#ifdef GL_EXT_texture_env_combine

6803

CONST_CAST(GLEW_EXT_texture_env_combine) = glewGetExtension("GL_EXT_texture_env_combine");

6804

#endif /* GL_EXT_texture_env_combine */

6805

#ifdef GL_EXT_texture_env_dot3

6806

CONST_CAST(GLEW_EXT_texture_env_dot3) = glewGetExtension("GL_EXT_texture_env_dot3");

6807

#endif /* GL_EXT_texture_env_dot3 */

6808

#ifdef GL_EXT_texture_filter_anisotropic

6809

CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = glewGetExtension("GL_EXT_texture_filter_anisotropic");

6810

#endif /* GL_EXT_texture_filter_anisotropic */

6811

#ifdef GL_EXT_texture_integer

6812

CONST_CAST(GLEW_EXT_texture_integer) = glewGetExtension("GL_EXT_texture_integer");

6813

if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT);

6814

#endif /* GL_EXT_texture_integer */

6815

#ifdef GL_EXT_texture_lod_bias

6816

CONST_CAST(GLEW_EXT_texture_lod_bias) = glewGetExtension("GL_EXT_texture_lod_bias");

6817

#endif /* GL_EXT_texture_lod_bias */

6818

#ifdef GL_EXT_texture_mirror_clamp

6819

CONST_CAST(GLEW_EXT_texture_mirror_clamp) = glewGetExtension("GL_EXT_texture_mirror_clamp");

6820

#endif /* GL_EXT_texture_mirror_clamp */

6821

#ifdef GL_EXT_texture_object

6822

CONST_CAST(GLEW_EXT_texture_object) = glewGetExtension("GL_EXT_texture_object");

6823

if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT);

6824

#endif /* GL_EXT_texture_object */

6825

#ifdef GL_EXT_texture_perturb_normal

6826

CONST_CAST(GLEW_EXT_texture_perturb_normal) = glewGetExtension("GL_EXT_texture_perturb_normal");

6827

if (glewExperimental || GLEW_EXT_texture_perturb_normal) CONST_CAST(GLEW_EXT_texture_perturb_normal) = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT);

6828

#endif /* GL_EXT_texture_perturb_normal */

6829

#ifdef GL_EXT_texture_rectangle

6830

CONST_CAST(GLEW_EXT_texture_rectangle) = glewGetExtension("GL_EXT_texture_rectangle");

6831

#endif /* GL_EXT_texture_rectangle */

6832

#ifdef GL_EXT_texture_sRGB

6833

CONST_CAST(GLEW_EXT_texture_sRGB) = glewGetExtension("GL_EXT_texture_sRGB");

6834

#endif /* GL_EXT_texture_sRGB */

6835

#ifdef GL_EXT_texture_shared_exponent

6836

CONST_CAST(GLEW_EXT_texture_shared_exponent) = glewGetExtension("GL_EXT_texture_shared_exponent");

6837

#endif /* GL_EXT_texture_shared_exponent */

6838

#ifdef GL_EXT_texture_swizzle

6839

CONST_CAST(GLEW_EXT_texture_swizzle) = glewGetExtension("GL_EXT_texture_swizzle");

6840

#endif /* GL_EXT_texture_swizzle */

6841

#ifdef GL_EXT_timer_query

6842

CONST_CAST(GLEW_EXT_timer_query) = glewGetExtension("GL_EXT_timer_query");

6843

if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);

6844

#endif /* GL_EXT_timer_query */

6845

#ifdef GL_EXT_transform_feedback

6846

CONST_CAST(GLEW_EXT_transform_feedback) = glewGetExtension("GL_EXT_transform_feedback");

6847

if (glewExperimental || GLEW_EXT_transform_feedback) CONST_CAST(GLEW_EXT_transform_feedback) = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);

6848

#endif /* GL_EXT_transform_feedback */

6849

#ifdef GL_EXT_vertex_array

6850

CONST_CAST(GLEW_EXT_vertex_array) = glewGetExtension("GL_EXT_vertex_array");

6851

if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);

6852

#endif /* GL_EXT_vertex_array */

6853

#ifdef GL_EXT_vertex_array_bgra

6854

CONST_CAST(GLEW_EXT_vertex_array_bgra) = glewGetExtension("GL_EXT_vertex_array_bgra");

6855

#endif /* GL_EXT_vertex_array_bgra */

6856

#ifdef GL_EXT_vertex_shader

6857

CONST_CAST(GLEW_EXT_vertex_shader) = glewGetExtension("GL_EXT_vertex_shader");

6858

if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);

6859

#endif /* GL_EXT_vertex_shader */

6860

#ifdef GL_EXT_vertex_weighting

6861

CONST_CAST(GLEW_EXT_vertex_weighting) = glewGetExtension("GL_EXT_vertex_weighting");

6862

if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT);

6863

#endif /* GL_EXT_vertex_weighting */

6864

#ifdef GL_GREMEDY_frame_terminator

6865

CONST_CAST(GLEW_GREMEDY_frame_terminator) = glewGetExtension("GL_GREMEDY_frame_terminator");

6866

if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT);

6867

#endif /* GL_GREMEDY_frame_terminator */

6868

#ifdef GL_GREMEDY_string_marker

6869

CONST_CAST(GLEW_GREMEDY_string_marker) = glewGetExtension("GL_GREMEDY_string_marker");

6870

if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT);

6871

#endif /* GL_GREMEDY_string_marker */

6872

#ifdef GL_HP_convolution_border_modes

6873

CONST_CAST(GLEW_HP_convolution_border_modes) = glewGetExtension("GL_HP_convolution_border_modes");

6874

#endif /* GL_HP_convolution_border_modes */

6875

#ifdef GL_HP_image_transform

6876

CONST_CAST(GLEW_HP_image_transform) = glewGetExtension("GL_HP_image_transform");

6877

if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT);

6878

#endif /* GL_HP_image_transform */

6879

#ifdef GL_HP_occlusion_test

6880

CONST_CAST(GLEW_HP_occlusion_test) = glewGetExtension("GL_HP_occlusion_test");

6881

#endif /* GL_HP_occlusion_test */

6882

#ifdef GL_HP_texture_lighting

6883

CONST_CAST(GLEW_HP_texture_lighting) = glewGetExtension("GL_HP_texture_lighting");

6884

#endif /* GL_HP_texture_lighting */

6885

#ifdef GL_IBM_cull_vertex

6886

CONST_CAST(GLEW_IBM_cull_vertex) = glewGetExtension("GL_IBM_cull_vertex");

6887

#endif /* GL_IBM_cull_vertex */

6888

#ifdef GL_IBM_multimode_draw_arrays

6889

CONST_CAST(GLEW_IBM_multimode_draw_arrays) = glewGetExtension("GL_IBM_multimode_draw_arrays");

6890

if (glewExperimental || GLEW_IBM_multimode_draw_arrays) CONST_CAST(GLEW_IBM_multimode_draw_arrays) = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

6891

#endif /* GL_IBM_multimode_draw_arrays */

6892

#ifdef GL_IBM_rasterpos_clip

6893

CONST_CAST(GLEW_IBM_rasterpos_clip) = glewGetExtension("GL_IBM_rasterpos_clip");

6894

#endif /* GL_IBM_rasterpos_clip */

6895

#ifdef GL_IBM_static_data

6896

CONST_CAST(GLEW_IBM_static_data) = glewGetExtension("GL_IBM_static_data");

6897

#endif /* GL_IBM_static_data */

6898

#ifdef GL_IBM_texture_mirrored_repeat

6899

CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = glewGetExtension("GL_IBM_texture_mirrored_repeat");

6900

#endif /* GL_IBM_texture_mirrored_repeat */

6901

#ifdef GL_IBM_vertex_array_lists

6902

CONST_CAST(GLEW_IBM_vertex_array_lists) = glewGetExtension("GL_IBM_vertex_array_lists");

6903

if (glewExperimental || GLEW_IBM_vertex_array_lists) CONST_CAST(GLEW_IBM_vertex_array_lists) = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT);

6904

#endif /* GL_IBM_vertex_array_lists */

6905

#ifdef GL_INGR_color_clamp

6906

CONST_CAST(GLEW_INGR_color_clamp) = glewGetExtension("GL_INGR_color_clamp");

6907

#endif /* GL_INGR_color_clamp */

6908

#ifdef GL_INGR_interlace_read

6909

CONST_CAST(GLEW_INGR_interlace_read) = glewGetExtension("GL_INGR_interlace_read");

6910

#endif /* GL_INGR_interlace_read */

6911

#ifdef GL_INTEL_parallel_arrays

6912

CONST_CAST(GLEW_INTEL_parallel_arrays) = glewGetExtension("GL_INTEL_parallel_arrays");

6913

if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

6914

#endif /* GL_INTEL_parallel_arrays */

6915

#ifdef GL_INTEL_texture_scissor

6916

CONST_CAST(GLEW_INTEL_texture_scissor) = glewGetExtension("GL_INTEL_texture_scissor");

6917

if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT);

6918

#endif /* GL_INTEL_texture_scissor */

6919

#ifdef GL_KTX_buffer_region

6920

CONST_CAST(GLEW_KTX_buffer_region) = glewGetExtension("GL_KTX_buffer_region");

6921

if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);

6922

#endif /* GL_KTX_buffer_region */

6923

#ifdef GL_MESAX_texture_stack

6924

CONST_CAST(GLEW_MESAX_texture_stack) = glewGetExtension("GL_MESAX_texture_stack");

6925

#endif /* GL_MESAX_texture_stack */

6926

#ifdef GL_MESA_pack_invert

6927

CONST_CAST(GLEW_MESA_pack_invert) = glewGetExtension("GL_MESA_pack_invert");

6928

#endif /* GL_MESA_pack_invert */

6929

#ifdef GL_MESA_resize_buffers

6930

CONST_CAST(GLEW_MESA_resize_buffers) = glewGetExtension("GL_MESA_resize_buffers");

6931

if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

6932

#endif /* GL_MESA_resize_buffers */

6933

#ifdef GL_MESA_window_pos

6934

CONST_CAST(GLEW_MESA_window_pos) = glewGetExtension("GL_MESA_window_pos");

6935

if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);

6936

#endif /* GL_MESA_window_pos */

6937

#ifdef GL_MESA_ycbcr_texture

6938

CONST_CAST(GLEW_MESA_ycbcr_texture) = glewGetExtension("GL_MESA_ycbcr_texture");

6939

#endif /* GL_MESA_ycbcr_texture */

6940

#ifdef GL_NV_blend_square

6941

CONST_CAST(GLEW_NV_blend_square) = glewGetExtension("GL_NV_blend_square");

6942

#endif /* GL_NV_blend_square */

6943

#ifdef GL_NV_conditional_render

6944

CONST_CAST(GLEW_NV_conditional_render) = glewGetExtension("GL_NV_conditional_render");

6945

if (glewExperimental || GLEW_NV_conditional_render) CONST_CAST(GLEW_NV_conditional_render) = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT);

6946

#endif /* GL_NV_conditional_render */

6947

#ifdef GL_NV_copy_depth_to_color

6948

CONST_CAST(GLEW_NV_copy_depth_to_color) = glewGetExtension("GL_NV_copy_depth_to_color");

6949

#endif /* GL_NV_copy_depth_to_color */

6950

#ifdef GL_NV_depth_buffer_float

6951

CONST_CAST(GLEW_NV_depth_buffer_float) = glewGetExtension("GL_NV_depth_buffer_float");

6952

if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);

6953

#endif /* GL_NV_depth_buffer_float */

6954

#ifdef GL_NV_depth_clamp

6955

CONST_CAST(GLEW_NV_depth_clamp) = glewGetExtension("GL_NV_depth_clamp");

6956

#endif /* GL_NV_depth_clamp */

6957

#ifdef GL_NV_depth_range_unclamped

6958

CONST_CAST(GLEW_NV_depth_range_unclamped) = glewGetExtension("GL_NV_depth_range_unclamped");

6959

#endif /* GL_NV_depth_range_unclamped */

6960

#ifdef GL_NV_evaluators

6961

CONST_CAST(GLEW_NV_evaluators) = glewGetExtension("GL_NV_evaluators");

6962

if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);

6963

#endif /* GL_NV_evaluators */

6964

#ifdef GL_NV_explicit_multisample

6965

CONST_CAST(GLEW_NV_explicit_multisample) = glewGetExtension("GL_NV_explicit_multisample");

6966

if (glewExperimental || GLEW_NV_explicit_multisample) CONST_CAST(GLEW_NV_explicit_multisample) = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

6967

#endif /* GL_NV_explicit_multisample */

6968

#ifdef GL_NV_fence

6969

CONST_CAST(GLEW_NV_fence) = glewGetExtension("GL_NV_fence");

6970

if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT);

6971

#endif /* GL_NV_fence */

6972

#ifdef GL_NV_float_buffer

6973

CONST_CAST(GLEW_NV_float_buffer) = glewGetExtension("GL_NV_float_buffer");

6974

#endif /* GL_NV_float_buffer */

6975

#ifdef GL_NV_fog_distance

6976

CONST_CAST(GLEW_NV_fog_distance) = glewGetExtension("GL_NV_fog_distance");

6977

#endif /* GL_NV_fog_distance */

6978

#ifdef GL_NV_fragment_program

6979

CONST_CAST(GLEW_NV_fragment_program) = glewGetExtension("GL_NV_fragment_program");

6980

if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);

6981

#endif /* GL_NV_fragment_program */

6982

#ifdef GL_NV_fragment_program2

6983

CONST_CAST(GLEW_NV_fragment_program2) = glewGetExtension("GL_NV_fragment_program2");

6984

#endif /* GL_NV_fragment_program2 */

6985

#ifdef GL_NV_fragment_program4

6986

CONST_CAST(GLEW_NV_fragment_program4) = glewGetExtension("GL_NV_fragment_program4");

6987

#endif /* GL_NV_fragment_program4 */

6988

#ifdef GL_NV_fragment_program_option

6989

CONST_CAST(GLEW_NV_fragment_program_option) = glewGetExtension("GL_NV_fragment_program_option");

6990

#endif /* GL_NV_fragment_program_option */

6991

#ifdef GL_NV_framebuffer_multisample_coverage

6992

CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = glewGetExtension("GL_NV_framebuffer_multisample_coverage");

6993

if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT);

6994

#endif /* GL_NV_framebuffer_multisample_coverage */

6995

#ifdef GL_NV_geometry_program4

6996

CONST_CAST(GLEW_NV_geometry_program4) = glewGetExtension("GL_NV_geometry_program4");

6997

if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT);

6998

#endif /* GL_NV_geometry_program4 */

6999

#ifdef GL_NV_geometry_shader4

7000

CONST_CAST(GLEW_NV_geometry_shader4) = glewGetExtension("GL_NV_geometry_shader4");

7001

#endif /* GL_NV_geometry_shader4 */

7002

#ifdef GL_NV_gpu_program4

7003

CONST_CAST(GLEW_NV_gpu_program4) = glewGetExtension("GL_NV_gpu_program4");

7004

if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT);

7005

#endif /* GL_NV_gpu_program4 */

7006

#ifdef GL_NV_half_float

7007

CONST_CAST(GLEW_NV_half_float) = glewGetExtension("GL_NV_half_float");

7008

if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);

7009

#endif /* GL_NV_half_float */

7010

#ifdef GL_NV_light_max_exponent

7011

CONST_CAST(GLEW_NV_light_max_exponent) = glewGetExtension("GL_NV_light_max_exponent");

7012

#endif /* GL_NV_light_max_exponent */

7013

#ifdef GL_NV_multisample_filter_hint

7014

CONST_CAST(GLEW_NV_multisample_filter_hint) = glewGetExtension("GL_NV_multisample_filter_hint");

7015

#endif /* GL_NV_multisample_filter_hint */

7016

#ifdef GL_NV_occlusion_query

7017

CONST_CAST(GLEW_NV_occlusion_query) = glewGetExtension("GL_NV_occlusion_query");

7018

if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);

7019

#endif /* GL_NV_occlusion_query */

7020

#ifdef GL_NV_packed_depth_stencil

7021

CONST_CAST(GLEW_NV_packed_depth_stencil) = glewGetExtension("GL_NV_packed_depth_stencil");

7022

#endif /* GL_NV_packed_depth_stencil */

7023

#ifdef GL_NV_parameter_buffer_object

7024

CONST_CAST(GLEW_NV_parameter_buffer_object) = glewGetExtension("GL_NV_parameter_buffer_object");

7025

if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

7026

#endif /* GL_NV_parameter_buffer_object */

7027

#ifdef GL_NV_pixel_data_range

7028

CONST_CAST(GLEW_NV_pixel_data_range) = glewGetExtension("GL_NV_pixel_data_range");

7029

if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT);

7030

#endif /* GL_NV_pixel_data_range */

7031

#ifdef GL_NV_point_sprite

7032

CONST_CAST(GLEW_NV_point_sprite) = glewGetExtension("GL_NV_point_sprite");

7033

if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT);

7034

#endif /* GL_NV_point_sprite */

7035

#ifdef GL_NV_present_video

7036

CONST_CAST(GLEW_NV_present_video) = glewGetExtension("GL_NV_present_video");

7037

if (glewExperimental || GLEW_NV_present_video) CONST_CAST(GLEW_NV_present_video) = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);

7038

#endif /* GL_NV_present_video */

7039

#ifdef GL_NV_primitive_restart

7040

CONST_CAST(GLEW_NV_primitive_restart) = glewGetExtension("GL_NV_primitive_restart");

7041

if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT);

7042

#endif /* GL_NV_primitive_restart */

7043

#ifdef GL_NV_register_combiners

7044

CONST_CAST(GLEW_NV_register_combiners) = glewGetExtension("GL_NV_register_combiners");

7045

if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);

7046

#endif /* GL_NV_register_combiners */

7047

#ifdef GL_NV_register_combiners2

7048

CONST_CAST(GLEW_NV_register_combiners2) = glewGetExtension("GL_NV_register_combiners2");

7049

if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);

7050

#endif /* GL_NV_register_combiners2 */

7051

#ifdef GL_NV_texgen_emboss

7052

CONST_CAST(GLEW_NV_texgen_emboss) = glewGetExtension("GL_NV_texgen_emboss");

7053

#endif /* GL_NV_texgen_emboss */

7054

#ifdef GL_NV_texgen_reflection

7055

CONST_CAST(GLEW_NV_texgen_reflection) = glewGetExtension("GL_NV_texgen_reflection");

7056

#endif /* GL_NV_texgen_reflection */

7057

#ifdef GL_NV_texture_compression_vtc

7058

CONST_CAST(GLEW_NV_texture_compression_vtc) = glewGetExtension("GL_NV_texture_compression_vtc");

7059

#endif /* GL_NV_texture_compression_vtc */

7060

#ifdef GL_NV_texture_env_combine4

7061

CONST_CAST(GLEW_NV_texture_env_combine4) = glewGetExtension("GL_NV_texture_env_combine4");

7062

#endif /* GL_NV_texture_env_combine4 */

7063

#ifdef GL_NV_texture_expand_normal

7064

CONST_CAST(GLEW_NV_texture_expand_normal) = glewGetExtension("GL_NV_texture_expand_normal");

7065

#endif /* GL_NV_texture_expand_normal */

7066

#ifdef GL_NV_texture_rectangle

7067

CONST_CAST(GLEW_NV_texture_rectangle) = glewGetExtension("GL_NV_texture_rectangle");

7068

#endif /* GL_NV_texture_rectangle */

7069

#ifdef GL_NV_texture_shader

7070

CONST_CAST(GLEW_NV_texture_shader) = glewGetExtension("GL_NV_texture_shader");

7071

#endif /* GL_NV_texture_shader */

7072

#ifdef GL_NV_texture_shader2

7073

CONST_CAST(GLEW_NV_texture_shader2) = glewGetExtension("GL_NV_texture_shader2");

7074

#endif /* GL_NV_texture_shader2 */

7075

#ifdef GL_NV_texture_shader3

7076

CONST_CAST(GLEW_NV_texture_shader3) = glewGetExtension("GL_NV_texture_shader3");

7077

#endif /* GL_NV_texture_shader3 */

7078

#ifdef GL_NV_transform_feedback

7079

CONST_CAST(GLEW_NV_transform_feedback) = glewGetExtension("GL_NV_transform_feedback");

7080

if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);

7081

#endif /* GL_NV_transform_feedback */

7082

#ifdef GL_NV_vertex_array_range

7083

CONST_CAST(GLEW_NV_vertex_array_range) = glewGetExtension("GL_NV_vertex_array_range");

7084

if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

7085

#endif /* GL_NV_vertex_array_range */

7086

#ifdef GL_NV_vertex_array_range2

7087

CONST_CAST(GLEW_NV_vertex_array_range2) = glewGetExtension("GL_NV_vertex_array_range2");

7088

#endif /* GL_NV_vertex_array_range2 */

7089

#ifdef GL_NV_vertex_program

7090

CONST_CAST(GLEW_NV_vertex_program) = glewGetExtension("GL_NV_vertex_program");

7091

if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);

7092

#endif /* GL_NV_vertex_program */

7093

#ifdef GL_NV_vertex_program1_1

7094

CONST_CAST(GLEW_NV_vertex_program1_1) = glewGetExtension("GL_NV_vertex_program1_1");

7095

#endif /* GL_NV_vertex_program1_1 */

7096

#ifdef GL_NV_vertex_program2

7097

CONST_CAST(GLEW_NV_vertex_program2) = glewGetExtension("GL_NV_vertex_program2");

7098

#endif /* GL_NV_vertex_program2 */

7099

#ifdef GL_NV_vertex_program2_option

7100

CONST_CAST(GLEW_NV_vertex_program2_option) = glewGetExtension("GL_NV_vertex_program2_option");

7101

#endif /* GL_NV_vertex_program2_option */

7102

#ifdef GL_NV_vertex_program3

7103

CONST_CAST(GLEW_NV_vertex_program3) = glewGetExtension("GL_NV_vertex_program3");

7104

#endif /* GL_NV_vertex_program3 */

7105

#ifdef GL_NV_vertex_program4

7106

CONST_CAST(GLEW_NV_vertex_program4) = glewGetExtension("GL_NV_vertex_program4");

7107

#endif /* GL_NV_vertex_program4 */

7108

#ifdef GL_OES_byte_coordinates

7109

CONST_CAST(GLEW_OES_byte_coordinates) = glewGetExtension("GL_OES_byte_coordinates");

7110

#endif /* GL_OES_byte_coordinates */

7111

#ifdef GL_OES_compressed_paletted_texture

7112

CONST_CAST(GLEW_OES_compressed_paletted_texture) = glewGetExtension("GL_OES_compressed_paletted_texture");

7113

#endif /* GL_OES_compressed_paletted_texture */

7114

#ifdef GL_OES_read_format

7115

CONST_CAST(GLEW_OES_read_format) = glewGetExtension("GL_OES_read_format");

7116

#endif /* GL_OES_read_format */

7117

#ifdef GL_OES_single_precision

7118

CONST_CAST(GLEW_OES_single_precision) = glewGetExtension("GL_OES_single_precision");

7119

if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT);

7120

#endif /* GL_OES_single_precision */

7121

#ifdef GL_OML_interlace

7122

CONST_CAST(GLEW_OML_interlace) = glewGetExtension("GL_OML_interlace");

7123

#endif /* GL_OML_interlace */

7124

#ifdef GL_OML_resample

7125

CONST_CAST(GLEW_OML_resample) = glewGetExtension("GL_OML_resample");

7126

#endif /* GL_OML_resample */

7127

#ifdef GL_OML_subsample

7128

CONST_CAST(GLEW_OML_subsample) = glewGetExtension("GL_OML_subsample");

7129

#endif /* GL_OML_subsample */

7130

#ifdef GL_PGI_misc_hints

7131

CONST_CAST(GLEW_PGI_misc_hints) = glewGetExtension("GL_PGI_misc_hints");

7132

#endif /* GL_PGI_misc_hints */

7133

#ifdef GL_PGI_vertex_hints

7134

CONST_CAST(GLEW_PGI_vertex_hints) = glewGetExtension("GL_PGI_vertex_hints");

7135

#endif /* GL_PGI_vertex_hints */

7136

#ifdef GL_REND_screen_coordinates

7137

CONST_CAST(GLEW_REND_screen_coordinates) = glewGetExtension("GL_REND_screen_coordinates");

7138

#endif /* GL_REND_screen_coordinates */

7139

#ifdef GL_S3_s3tc

7140

CONST_CAST(GLEW_S3_s3tc) = glewGetExtension("GL_S3_s3tc");

7141

#endif /* GL_S3_s3tc */

7142

#ifdef GL_SGIS_color_range

7143

CONST_CAST(GLEW_SGIS_color_range) = glewGetExtension("GL_SGIS_color_range");

7144

#endif /* GL_SGIS_color_range */

7145

#ifdef GL_SGIS_detail_texture

7146

CONST_CAST(GLEW_SGIS_detail_texture) = glewGetExtension("GL_SGIS_detail_texture");

7147

if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT);

7148

#endif /* GL_SGIS_detail_texture */

7149

#ifdef GL_SGIS_fog_function

7150

CONST_CAST(GLEW_SGIS_fog_function) = glewGetExtension("GL_SGIS_fog_function");

7151

if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT);

7152

#endif /* GL_SGIS_fog_function */

7153

#ifdef GL_SGIS_generate_mipmap

7154

CONST_CAST(GLEW_SGIS_generate_mipmap) = glewGetExtension("GL_SGIS_generate_mipmap");

7155

#endif /* GL_SGIS_generate_mipmap */

7156

#ifdef GL_SGIS_multisample

7157

CONST_CAST(GLEW_SGIS_multisample) = glewGetExtension("GL_SGIS_multisample");

7158

if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

7159

#endif /* GL_SGIS_multisample */

7160

#ifdef GL_SGIS_pixel_texture

7161

CONST_CAST(GLEW_SGIS_pixel_texture) = glewGetExtension("GL_SGIS_pixel_texture");

7162

#endif /* GL_SGIS_pixel_texture */

7163

#ifdef GL_SGIS_point_line_texgen

7164

CONST_CAST(GLEW_SGIS_point_line_texgen) = glewGetExtension("GL_SGIS_point_line_texgen");

7165

#endif /* GL_SGIS_point_line_texgen */

7166

#ifdef GL_SGIS_sharpen_texture

7167

CONST_CAST(GLEW_SGIS_sharpen_texture) = glewGetExtension("GL_SGIS_sharpen_texture");

7168

if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT);

7169

#endif /* GL_SGIS_sharpen_texture */

7170

#ifdef GL_SGIS_texture4D

7171

CONST_CAST(GLEW_SGIS_texture4D) = glewGetExtension("GL_SGIS_texture4D");

7172

if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT);

7173

#endif /* GL_SGIS_texture4D */

7174

#ifdef GL_SGIS_texture_border_clamp

7175

CONST_CAST(GLEW_SGIS_texture_border_clamp) = glewGetExtension("GL_SGIS_texture_border_clamp");

7176

#endif /* GL_SGIS_texture_border_clamp */

7177

#ifdef GL_SGIS_texture_edge_clamp

7178

CONST_CAST(GLEW_SGIS_texture_edge_clamp) = glewGetExtension("GL_SGIS_texture_edge_clamp");

7179

#endif /* GL_SGIS_texture_edge_clamp */

7180

#ifdef GL_SGIS_texture_filter4

7181

CONST_CAST(GLEW_SGIS_texture_filter4) = glewGetExtension("GL_SGIS_texture_filter4");

7182

if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT);

7183

#endif /* GL_SGIS_texture_filter4 */

7184

#ifdef GL_SGIS_texture_lod

7185

CONST_CAST(GLEW_SGIS_texture_lod) = glewGetExtension("GL_SGIS_texture_lod");

7186

#endif /* GL_SGIS_texture_lod */

7187

#ifdef GL_SGIS_texture_select

7188

CONST_CAST(GLEW_SGIS_texture_select) = glewGetExtension("GL_SGIS_texture_select");

7189

#endif /* GL_SGIS_texture_select */

7190

#ifdef GL_SGIX_async

7191

CONST_CAST(GLEW_SGIX_async) = glewGetExtension("GL_SGIX_async");

7192

if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT);

7193

#endif /* GL_SGIX_async */

7194

#ifdef GL_SGIX_async_histogram

7195

CONST_CAST(GLEW_SGIX_async_histogram) = glewGetExtension("GL_SGIX_async_histogram");

7196

#endif /* GL_SGIX_async_histogram */

7197

#ifdef GL_SGIX_async_pixel

7198

CONST_CAST(GLEW_SGIX_async_pixel) = glewGetExtension("GL_SGIX_async_pixel");

7199

#endif /* GL_SGIX_async_pixel */

7200

#ifdef GL_SGIX_blend_alpha_minmax

7201

CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = glewGetExtension("GL_SGIX_blend_alpha_minmax");

7202

#endif /* GL_SGIX_blend_alpha_minmax */

7203

#ifdef GL_SGIX_clipmap

7204

CONST_CAST(GLEW_SGIX_clipmap) = glewGetExtension("GL_SGIX_clipmap");

7205

#endif /* GL_SGIX_clipmap */

7206

#ifdef GL_SGIX_convolution_accuracy

7207

CONST_CAST(GLEW_SGIX_convolution_accuracy) = glewGetExtension("GL_SGIX_convolution_accuracy");

7208

#endif /* GL_SGIX_convolution_accuracy */

7209

#ifdef GL_SGIX_depth_texture

7210

CONST_CAST(GLEW_SGIX_depth_texture) = glewGetExtension("GL_SGIX_depth_texture");

7211

#endif /* GL_SGIX_depth_texture */

7212

#ifdef GL_SGIX_flush_raster

7213

CONST_CAST(GLEW_SGIX_flush_raster) = glewGetExtension("GL_SGIX_flush_raster");

7214

if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT);

7215

#endif /* GL_SGIX_flush_raster */

7216

#ifdef GL_SGIX_fog_offset

7217

CONST_CAST(GLEW_SGIX_fog_offset) = glewGetExtension("GL_SGIX_fog_offset");

7218

#endif /* GL_SGIX_fog_offset */

7219

#ifdef GL_SGIX_fog_texture

7220

CONST_CAST(GLEW_SGIX_fog_texture) = glewGetExtension("GL_SGIX_fog_texture");

7221

if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT);

7222

#endif /* GL_SGIX_fog_texture */

7223

#ifdef GL_SGIX_fragment_specular_lighting

7224

CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = glewGetExtension("GL_SGIX_fragment_specular_lighting");

7225

if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT);

7226

#endif /* GL_SGIX_fragment_specular_lighting */

7227

#ifdef GL_SGIX_framezoom

7228

CONST_CAST(GLEW_SGIX_framezoom) = glewGetExtension("GL_SGIX_framezoom");

7229

if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT);

7230

#endif /* GL_SGIX_framezoom */

7231

#ifdef GL_SGIX_interlace

7232

CONST_CAST(GLEW_SGIX_interlace) = glewGetExtension("GL_SGIX_interlace");

7233

#endif /* GL_SGIX_interlace */

7234

#ifdef GL_SGIX_ir_instrument1

7235

CONST_CAST(GLEW_SGIX_ir_instrument1) = glewGetExtension("GL_SGIX_ir_instrument1");

7236

#endif /* GL_SGIX_ir_instrument1 */

7237

#ifdef GL_SGIX_list_priority

7238

CONST_CAST(GLEW_SGIX_list_priority) = glewGetExtension("GL_SGIX_list_priority");

7239

#endif /* GL_SGIX_list_priority */

7240

#ifdef GL_SGIX_pixel_texture

7241

CONST_CAST(GLEW_SGIX_pixel_texture) = glewGetExtension("GL_SGIX_pixel_texture");

7242

if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT);

7243

#endif /* GL_SGIX_pixel_texture */

7244

#ifdef GL_SGIX_pixel_texture_bits

7245

CONST_CAST(GLEW_SGIX_pixel_texture_bits) = glewGetExtension("GL_SGIX_pixel_texture_bits");

7246

#endif /* GL_SGIX_pixel_texture_bits */

7247

#ifdef GL_SGIX_reference_plane

7248

CONST_CAST(GLEW_SGIX_reference_plane) = glewGetExtension("GL_SGIX_reference_plane");

7249

if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT);

7250

#endif /* GL_SGIX_reference_plane */

7251

#ifdef GL_SGIX_resample

7252

CONST_CAST(GLEW_SGIX_resample) = glewGetExtension("GL_SGIX_resample");

7253

#endif /* GL_SGIX_resample */

7254

#ifdef GL_SGIX_shadow

7255

CONST_CAST(GLEW_SGIX_shadow) = glewGetExtension("GL_SGIX_shadow");

7256

#endif /* GL_SGIX_shadow */

7257

#ifdef GL_SGIX_shadow_ambient

7258

CONST_CAST(GLEW_SGIX_shadow_ambient) = glewGetExtension("GL_SGIX_shadow_ambient");

7259

#endif /* GL_SGIX_shadow_ambient */

7260

#ifdef GL_SGIX_sprite

7261

CONST_CAST(GLEW_SGIX_sprite) = glewGetExtension("GL_SGIX_sprite");

7262

if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT);

7263

#endif /* GL_SGIX_sprite */

7264

#ifdef GL_SGIX_tag_sample_buffer

7265

CONST_CAST(GLEW_SGIX_tag_sample_buffer) = glewGetExtension("GL_SGIX_tag_sample_buffer");

7266

if (glewExperimental || GLEW_SGIX_tag_sample_buffer) CONST_CAST(GLEW_SGIX_tag_sample_buffer) = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

7267

#endif /* GL_SGIX_tag_sample_buffer */

7268

#ifdef GL_SGIX_texture_add_env

7269

CONST_CAST(GLEW_SGIX_texture_add_env) = glewGetExtension("GL_SGIX_texture_add_env");

7270

#endif /* GL_SGIX_texture_add_env */

7271

#ifdef GL_SGIX_texture_coordinate_clamp

7272

CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = glewGetExtension("GL_SGIX_texture_coordinate_clamp");

7273

#endif /* GL_SGIX_texture_coordinate_clamp */

7274

#ifdef GL_SGIX_texture_lod_bias

7275

CONST_CAST(GLEW_SGIX_texture_lod_bias) = glewGetExtension("GL_SGIX_texture_lod_bias");

7276

#endif /* GL_SGIX_texture_lod_bias */

7277

#ifdef GL_SGIX_texture_multi_buffer

7278

CONST_CAST(GLEW_SGIX_texture_multi_buffer) = glewGetExtension("GL_SGIX_texture_multi_buffer");

7279

#endif /* GL_SGIX_texture_multi_buffer */

7280

#ifdef GL_SGIX_texture_range

7281

CONST_CAST(GLEW_SGIX_texture_range) = glewGetExtension("GL_SGIX_texture_range");

7282

#endif /* GL_SGIX_texture_range */

7283

#ifdef GL_SGIX_texture_scale_bias

7284

CONST_CAST(GLEW_SGIX_texture_scale_bias) = glewGetExtension("GL_SGIX_texture_scale_bias");

7285

#endif /* GL_SGIX_texture_scale_bias */

7286

#ifdef GL_SGIX_vertex_preclip

7287

CONST_CAST(GLEW_SGIX_vertex_preclip) = glewGetExtension("GL_SGIX_vertex_preclip");

7288

#endif /* GL_SGIX_vertex_preclip */

7289

#ifdef GL_SGIX_vertex_preclip_hint

7290

CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = glewGetExtension("GL_SGIX_vertex_preclip_hint");

7291

#endif /* GL_SGIX_vertex_preclip_hint */

7292

#ifdef GL_SGIX_ycrcb

7293

CONST_CAST(GLEW_SGIX_ycrcb) = glewGetExtension("GL_SGIX_ycrcb");

7294

#endif /* GL_SGIX_ycrcb */

7295

#ifdef GL_SGI_color_matrix

7296

CONST_CAST(GLEW_SGI_color_matrix) = glewGetExtension("GL_SGI_color_matrix");

7297

#endif /* GL_SGI_color_matrix */

7298

#ifdef GL_SGI_color_table

7299

CONST_CAST(GLEW_SGI_color_table) = glewGetExtension("GL_SGI_color_table");

7300

if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT);

7301

#endif /* GL_SGI_color_table */

7302

#ifdef GL_SGI_texture_color_table

7303

CONST_CAST(GLEW_SGI_texture_color_table) = glewGetExtension("GL_SGI_texture_color_table");

7304

#endif /* GL_SGI_texture_color_table */

7305

#ifdef GL_SUNX_constant_data

7306

CONST_CAST(GLEW_SUNX_constant_data) = glewGetExtension("GL_SUNX_constant_data");

7307

if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT);

7308

#endif /* GL_SUNX_constant_data */

7309

#ifdef GL_SUN_convolution_border_modes

7310

CONST_CAST(GLEW_SUN_convolution_border_modes) = glewGetExtension("GL_SUN_convolution_border_modes");

7311

#endif /* GL_SUN_convolution_border_modes */

7312

#ifdef GL_SUN_global_alpha

7313

CONST_CAST(GLEW_SUN_global_alpha) = glewGetExtension("GL_SUN_global_alpha");

7314

if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT);

7315

#endif /* GL_SUN_global_alpha */

7316

#ifdef GL_SUN_mesh_array

7317

CONST_CAST(GLEW_SUN_mesh_array) = glewGetExtension("GL_SUN_mesh_array");

7318

#endif /* GL_SUN_mesh_array */

7319

#ifdef GL_SUN_read_video_pixels

7320

CONST_CAST(GLEW_SUN_read_video_pixels) = glewGetExtension("GL_SUN_read_video_pixels");

7321

if (glewExperimental || GLEW_SUN_read_video_pixels) CONST_CAST(GLEW_SUN_read_video_pixels) = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT);

7322

#endif /* GL_SUN_read_video_pixels */

7323

#ifdef GL_SUN_slice_accum

7324

CONST_CAST(GLEW_SUN_slice_accum) = glewGetExtension("GL_SUN_slice_accum");

7325

#endif /* GL_SUN_slice_accum */

7326

#ifdef GL_SUN_triangle_list

7327

CONST_CAST(GLEW_SUN_triangle_list) = glewGetExtension("GL_SUN_triangle_list");

7328

if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT);

7329

#endif /* GL_SUN_triangle_list */

7330

#ifdef GL_SUN_vertex

7331

CONST_CAST(GLEW_SUN_vertex) = glewGetExtension("GL_SUN_vertex");

7332

if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT);

7333

#endif /* GL_SUN_vertex */

7334

#ifdef GL_WIN_phong_shading

7335

CONST_CAST(GLEW_WIN_phong_shading) = glewGetExtension("GL_WIN_phong_shading");

7336

#endif /* GL_WIN_phong_shading */

7337

#ifdef GL_WIN_specular_fog

7338

CONST_CAST(GLEW_WIN_specular_fog) = glewGetExtension("GL_WIN_specular_fog");

7339

#endif /* GL_WIN_specular_fog */

7340

#ifdef GL_WIN_swap_hint

7341

CONST_CAST(GLEW_WIN_swap_hint) = glewGetExtension("GL_WIN_swap_hint");

7342

if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT);

7343

#endif /* GL_WIN_swap_hint */

7344

7345

return GLEW_OK;

7346

}

7347

7348

7349

#if defined(_WIN32)

7350

7351

#if !defined(GLEW_MX)

7352

7353

PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;

7354

7355

PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;

7356

PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;

7357

PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;

7358

PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;

7359

7360

PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL;

7361

7362

PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;

7363

7364

PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;

7365

PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;

7366

7367

PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;

7368

PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;

7369

PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;

7370

PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;

7371

PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;

7372

7373

PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;

7374

PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;

7375

PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;

7376

7377

PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;

7378

PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;

7379

PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;

7380

7381

PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;

7382

PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;

7383

PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;

7384

PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;

7385

7386

PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;

7387

7388

PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;

7389

PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;

7390

7391

PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;

7392

PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;

7393

PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;

7394

PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;

7395

PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;

7396

7397

PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;

7398

PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;

7399

PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;

7400

7401

PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;

7402

PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;

7403

7404

PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;

7405

PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;

7406

7407

PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;

7408

PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;

7409

PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;

7410

PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;

7411

7412

PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;

7413

PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;

7414

PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;

7415

PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;

7416

PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;

7417

PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;

7418

PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;

7419

PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;

7420

PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;

7421

PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;

7422

PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;

7423

PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;

7424

7425

PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;

7426

PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;

7427

PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;

7428

PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;

7429

7430

PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;

7431

PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;

7432

PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;

7433

PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;

7434

7435

PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;

7436

PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;

7437

PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;

7438

PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;

7439

7440

PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;

7441

PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;

7442

PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;

7443

PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL;

7444

PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL;

7445

7446

PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL;

7447

PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL;

7448

PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL;

7449

7450

PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL;

7451

PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL;

7452

PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL;

7453

PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL;

7454

PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL;

7455

PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL;

7456

7457

PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;

7458

PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;

7459

7460

PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL;

7461

PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL;

7462

PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL;

7463

PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL;

7464

PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL;

7465

PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL;

7466

7467

PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;

7468

PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;

7469

PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;

7470

PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;

7471

PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;

7472

PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;

7473

GLboolean __WGLEW_3DFX_multisample = GL_FALSE;

7474

GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;

7475

GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;

7476

GLboolean __WGLEW_ARB_create_context = GL_FALSE;

7477

GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;

7478

GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE;

7479

GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;

7480

GLboolean __WGLEW_ARB_multisample = GL_FALSE;

7481

GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;

7482

GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;

7483

GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;

7484

GLboolean __WGLEW_ARB_render_texture = GL_FALSE;

7485

GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;

7486

GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;

7487

GLboolean __WGLEW_EXT_depth_float = GL_FALSE;

7488

GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;

7489

GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;

7490

GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE;

7491

GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;

7492

GLboolean __WGLEW_EXT_multisample = GL_FALSE;

7493

GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;

7494

GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;

7495

GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE;

7496

GLboolean __WGLEW_EXT_swap_control = GL_FALSE;

7497

GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;

7498

GLboolean __WGLEW_I3D_gamma = GL_FALSE;

7499

GLboolean __WGLEW_I3D_genlock = GL_FALSE;

7500

GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;

7501

GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;

7502

GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;

7503

GLboolean __WGLEW_NV_float_buffer = GL_FALSE;

7504

GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;

7505

GLboolean __WGLEW_NV_present_video = GL_FALSE;

7506

GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;

7507

GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;

7508

GLboolean __WGLEW_NV_swap_group = GL_FALSE;

7509

GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;

7510

GLboolean __WGLEW_NV_video_output = GL_FALSE;

7511

GLboolean __WGLEW_OML_sync_control = GL_FALSE;

7512

7513

#endif /* !GLEW_MX */

7514

7515

#ifdef WGL_3DFX_multisample

7516

7517

#endif /* WGL_3DFX_multisample */

7518

7519

#ifdef WGL_3DL_stereo_control

7520

7521

static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT)

7522

{

7523

GLboolean r = GL_FALSE;

7524

7525

r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r;

7526

7527

return r;

7528

}

7529

7530

#endif /* WGL_3DL_stereo_control */

7531

7532

#ifdef WGL_ARB_buffer_region

7533

7534

static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)

7535

{

7536

GLboolean r = GL_FALSE;

7537

7538

r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;

7539

r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;

7540

r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;

7541

r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;

7542

7543

return r;

7544

}

7545

7546

#endif /* WGL_ARB_buffer_region */

7547

7548

#ifdef WGL_ARB_create_context

7549

7550

static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT)

7551

{

7552

GLboolean r = GL_FALSE;

7553

7554

r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r;

7555

7556

return r;

7557

}

7558

7559

#endif /* WGL_ARB_create_context */

7560

7561

#ifdef WGL_ARB_extensions_string

7562

7563

static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)

7564

{

7565

GLboolean r = GL_FALSE;

7566

7567

r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;

7568

7569

return r;

7570

}

7571

7572

#endif /* WGL_ARB_extensions_string */

7573

7574

#ifdef WGL_ARB_framebuffer_sRGB

7575

7576

#endif /* WGL_ARB_framebuffer_sRGB */

7577

7578

#ifdef WGL_ARB_make_current_read

7579

7580

static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)

7581

{

7582

GLboolean r = GL_FALSE;

7583

7584

r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;

7585

r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;

7586

7587

return r;

7588

}

7589

7590

#endif /* WGL_ARB_make_current_read */

7591

7592

#ifdef WGL_ARB_multisample

7593

7594

#endif /* WGL_ARB_multisample */

7595

7596

#ifdef WGL_ARB_pbuffer

7597

7598

static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)

7599

{

7600

GLboolean r = GL_FALSE;

7601

7602

r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;

7603

r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;

7604

r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;

7605

r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;

7606

r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;

7607

7608

return r;

7609

}

7610

7611

#endif /* WGL_ARB_pbuffer */

7612

7613

#ifdef WGL_ARB_pixel_format

7614

7615

static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)

7616

{

7617

GLboolean r = GL_FALSE;

7618

7619

r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;

7620

r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;

7621

r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;

7622

7623

return r;

7624

}

7625

7626

#endif /* WGL_ARB_pixel_format */

7627

7628

#ifdef WGL_ARB_pixel_format_float

7629

7630

#endif /* WGL_ARB_pixel_format_float */

7631

7632

#ifdef WGL_ARB_render_texture

7633

7634

static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)

7635

{

7636

GLboolean r = GL_FALSE;

7637

7638

r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;

7639

r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;

7640

r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;

7641

7642

return r;

7643

}

7644

7645

#endif /* WGL_ARB_render_texture */

7646

7647

#ifdef WGL_ATI_pixel_format_float

7648

7649

#endif /* WGL_ATI_pixel_format_float */

7650

7651

#ifdef WGL_ATI_render_texture_rectangle

7652

7653

#endif /* WGL_ATI_render_texture_rectangle */

7654

7655

#ifdef WGL_EXT_depth_float

7656

7657

#endif /* WGL_EXT_depth_float */

7658

7659

#ifdef WGL_EXT_display_color_table

7660

7661

static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT)

7662

{

7663

GLboolean r = GL_FALSE;

7664

7665

r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;

7666

r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;

7667

r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;

7668

r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;

7669

7670

return r;

7671

}

7672

7673

#endif /* WGL_EXT_display_color_table */

7674

7675

#ifdef WGL_EXT_extensions_string

7676

7677

static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)

7678

{

7679

GLboolean r = GL_FALSE;

7680

7681

r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;

7682

7683

return r;

7684

}

7685

7686

#endif /* WGL_EXT_extensions_string */

7687

7688

#ifdef WGL_EXT_framebuffer_sRGB

7689

7690

#endif /* WGL_EXT_framebuffer_sRGB */

7691

7692

#ifdef WGL_EXT_make_current_read

7693

7694

static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)

7695

{

7696

GLboolean r = GL_FALSE;

7697

7698

r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;

7699

r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;

7700

7701

return r;

7702

}

7703

7704

#endif /* WGL_EXT_make_current_read */

7705

7706

#ifdef WGL_EXT_multisample

7707

7708

#endif /* WGL_EXT_multisample */

7709

7710

#ifdef WGL_EXT_pbuffer

7711

7712

static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)

7713

{

7714

GLboolean r = GL_FALSE;

7715

7716

r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;

7717

r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;

7718

r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;

7719

r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;

7720

r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;

7721

7722

return r;

7723

}

7724

7725

#endif /* WGL_EXT_pbuffer */

7726

7727

#ifdef WGL_EXT_pixel_format

7728

7729

static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)

7730

{

7731

GLboolean r = GL_FALSE;

7732

7733

r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;

7734

r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;

7735

r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;

7736

7737

return r;

7738

}

7739

7740

#endif /* WGL_EXT_pixel_format */

7741

7742

#ifdef WGL_EXT_pixel_format_packed_float

7743

7744

#endif /* WGL_EXT_pixel_format_packed_float */

7745

7746

#ifdef WGL_EXT_swap_control

7747

7748

static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)

7749

{

7750

GLboolean r = GL_FALSE;

7751

7752

r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;

7753

r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;

7754

7755

return r;

7756

}

7757

7758

#endif /* WGL_EXT_swap_control */

7759

7760

#ifdef WGL_I3D_digital_video_control

7761

7762

static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT)

7763

{

7764

GLboolean r = GL_FALSE;

7765

7766

r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;

7767

r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;

7768

7769

return r;

7770

}

7771

7772

#endif /* WGL_I3D_digital_video_control */

7773

7774

#ifdef WGL_I3D_gamma

7775

7776

static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT)

7777

{

7778

GLboolean r = GL_FALSE;

7779

7780

r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;

7781

r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;

7782

r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;

7783

r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;

7784

7785

return r;

7786

}

7787

7788

#endif /* WGL_I3D_gamma */

7789

7790

#ifdef WGL_I3D_genlock

7791

7792

static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT)

7793

{

7794

GLboolean r = GL_FALSE;

7795

7796

r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;

7797

r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;

7798

r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;

7799

r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;

7800

r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;

7801

r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;

7802

r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;

7803

r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;

7804

r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;

7805

r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;

7806

r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;

7807

r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;

7808

7809

return r;

7810

}

7811

7812

#endif /* WGL_I3D_genlock */

7813

7814

#ifdef WGL_I3D_image_buffer

7815

7816

static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT)

7817

{

7818

GLboolean r = GL_FALSE;

7819

7820

r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;

7821

r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;

7822

r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;

7823

r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;

7824

7825

return r;

7826

}

7827

7828

#endif /* WGL_I3D_image_buffer */

7829

7830

#ifdef WGL_I3D_swap_frame_lock

7831

7832

static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT)

7833

{

7834

GLboolean r = GL_FALSE;

7835

7836

r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;

7837

r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;

7838

r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;

7839

r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;

7840

7841

return r;

7842

}

7843

7844

#endif /* WGL_I3D_swap_frame_lock */

7845

7846

#ifdef WGL_I3D_swap_frame_usage

7847

7848

static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)

7849

{

7850

GLboolean r = GL_FALSE;

7851

7852

r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;

7853

r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;

7854

r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;

7855

r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;

7856

7857

return r;

7858

}

7859

7860

#endif /* WGL_I3D_swap_frame_usage */

7861

7862

#ifdef WGL_NV_float_buffer

7863

7864

#endif /* WGL_NV_float_buffer */

7865

7866

#ifdef WGL_NV_gpu_affinity

7867

7868

static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT)

7869

{

7870

GLboolean r = GL_FALSE;

7871

7872

r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r;

7873

r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r;

7874

r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r;

7875

r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r;

7876

r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r;

7877

7878

return r;

7879

}

7880

7881

#endif /* WGL_NV_gpu_affinity */

7882

7883

#ifdef WGL_NV_present_video

7884

7885

static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT)

7886

{

7887

GLboolean r = GL_FALSE;

7888

7889

r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r;

7890

r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r;

7891

r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r;

7892

7893

return r;

7894

}

7895

7896

#endif /* WGL_NV_present_video */

7897

7898

#ifdef WGL_NV_render_depth_texture

7899

7900

#endif /* WGL_NV_render_depth_texture */

7901

7902

#ifdef WGL_NV_render_texture_rectangle

7903

7904

#endif /* WGL_NV_render_texture_rectangle */

7905

7906

#ifdef WGL_NV_swap_group

7907

7908

static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT)

7909

{

7910

GLboolean r = GL_FALSE;

7911

7912

r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r;

7913

r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r;

7914

r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r;

7915

r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r;

7916

r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r;

7917

r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r;

7918

7919

return r;

7920

}

7921

7922

#endif /* WGL_NV_swap_group */

7923

7924

#ifdef WGL_NV_vertex_array_range

7925

7926

static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT)

7927

{

7928

GLboolean r = GL_FALSE;

7929

7930

r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;

7931

r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;

7932

7933

return r;

7934

}

7935

7936

#endif /* WGL_NV_vertex_array_range */

7937

7938

#ifdef WGL_NV_video_output

7939

7940

static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT)

7941

{

7942

GLboolean r = GL_FALSE;

7943

7944

r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r;

7945

r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r;

7946

r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r;

7947

r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r;

7948

r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r;

7949

r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r;

7950

7951

return r;

7952

}

7953

7954

#endif /* WGL_NV_video_output */

7955

7956

#ifdef WGL_OML_sync_control

7957

7958

static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT)

7959

{

7960

GLboolean r = GL_FALSE;

7961

7962

r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;

7963

r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;

7964

r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;

7965

r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;

7966

r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;

7967

r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;

7968

7969

return r;

7970

}

7971

7972

#endif /* WGL_OML_sync_control */

7973

7974

/* ------------------------------------------------------------------------- */

7975

7976

static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;

7977

static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;

7978

7979

GLboolean wglewGetExtension (const char* name)

7980

{

7981

GLubyte* p;

7982

GLubyte* end;

7983

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

7984

if (_wglewGetExtensionsStringARB == NULL)

7985

if (_wglewGetExtensionsStringEXT == NULL)

7986

return GL_FALSE;

7987

else

7988

p = (GLubyte*)_wglewGetExtensionsStringEXT();

7989

else

7990

p = (GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());

7991

if (0 == p) return GL_FALSE;

7992

end = p + _glewStrLen(p);

7993

while (p < end)

7994

{

7995

GLuint n = _glewStrCLen(p, ' ');

7996

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

7997

p += n+1;

7998

}

7999

return GL_FALSE;

8000

}

8001

8002

GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)

8003

{

8004

GLboolean crippled;

8005

/* find wgl extension string query functions */

8006

_wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");

8007

_wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");

8008

/* initialize extensions */

8009

crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;

8010

#ifdef WGL_3DFX_multisample

8011

CONST_CAST(WGLEW_3DFX_multisample) = wglewGetExtension("WGL_3DFX_multisample");

8012

#endif /* WGL_3DFX_multisample */

8013

#ifdef WGL_3DL_stereo_control

8014

CONST_CAST(WGLEW_3DL_stereo_control) = wglewGetExtension("WGL_3DL_stereo_control");

8015

if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT);

8016

#endif /* WGL_3DL_stereo_control */

8017

#ifdef WGL_ARB_buffer_region

8018

CONST_CAST(WGLEW_ARB_buffer_region) = wglewGetExtension("WGL_ARB_buffer_region");

8019

if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);

8020

#endif /* WGL_ARB_buffer_region */

8021

#ifdef WGL_ARB_create_context

8022

CONST_CAST(WGLEW_ARB_create_context) = wglewGetExtension("WGL_ARB_create_context");

8023

if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);

8024

#endif /* WGL_ARB_create_context */

8025

#ifdef WGL_ARB_extensions_string

8026

CONST_CAST(WGLEW_ARB_extensions_string) = wglewGetExtension("WGL_ARB_extensions_string");

8027

if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);

8028

#endif /* WGL_ARB_extensions_string */

8029

#ifdef WGL_ARB_framebuffer_sRGB

8030

CONST_CAST(WGLEW_ARB_framebuffer_sRGB) = wglewGetExtension("WGL_ARB_framebuffer_sRGB");

8031

#endif /* WGL_ARB_framebuffer_sRGB */

8032

#ifdef WGL_ARB_make_current_read

8033

CONST_CAST(WGLEW_ARB_make_current_read) = wglewGetExtension("WGL_ARB_make_current_read");

8034

if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) CONST_CAST(WGLEW_ARB_make_current_read)= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

8035

#endif /* WGL_ARB_make_current_read */

8036

#ifdef WGL_ARB_multisample

8037

CONST_CAST(WGLEW_ARB_multisample) = wglewGetExtension("WGL_ARB_multisample");

8038

#endif /* WGL_ARB_multisample */

8039

#ifdef WGL_ARB_pbuffer

8040

CONST_CAST(WGLEW_ARB_pbuffer) = wglewGetExtension("WGL_ARB_pbuffer");

8041

if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

8042

#endif /* WGL_ARB_pbuffer */

8043

#ifdef WGL_ARB_pixel_format

8044

CONST_CAST(WGLEW_ARB_pixel_format) = wglewGetExtension("WGL_ARB_pixel_format");

8045

if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);

8046

#endif /* WGL_ARB_pixel_format */

8047

#ifdef WGL_ARB_pixel_format_float

8048

CONST_CAST(WGLEW_ARB_pixel_format_float) = wglewGetExtension("WGL_ARB_pixel_format_float");

8049

#endif /* WGL_ARB_pixel_format_float */

8050

#ifdef WGL_ARB_render_texture

8051

CONST_CAST(WGLEW_ARB_render_texture) = wglewGetExtension("WGL_ARB_render_texture");

8052

if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);

8053

#endif /* WGL_ARB_render_texture */

8054

#ifdef WGL_ATI_pixel_format_float

8055

CONST_CAST(WGLEW_ATI_pixel_format_float) = wglewGetExtension("WGL_ATI_pixel_format_float");

8056

#endif /* WGL_ATI_pixel_format_float */

8057

#ifdef WGL_ATI_render_texture_rectangle

8058

CONST_CAST(WGLEW_ATI_render_texture_rectangle) = wglewGetExtension("WGL_ATI_render_texture_rectangle");

8059

#endif /* WGL_ATI_render_texture_rectangle */

8060

#ifdef WGL_EXT_depth_float

8061

CONST_CAST(WGLEW_EXT_depth_float) = wglewGetExtension("WGL_EXT_depth_float");

8062

#endif /* WGL_EXT_depth_float */

8063

#ifdef WGL_EXT_display_color_table

8064

CONST_CAST(WGLEW_EXT_display_color_table) = wglewGetExtension("WGL_EXT_display_color_table");

8065

if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) CONST_CAST(WGLEW_EXT_display_color_table)= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT);

8066

#endif /* WGL_EXT_display_color_table */

8067

#ifdef WGL_EXT_extensions_string

8068

CONST_CAST(WGLEW_EXT_extensions_string) = wglewGetExtension("WGL_EXT_extensions_string");

8069

if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);

8070

#endif /* WGL_EXT_extensions_string */

8071

#ifdef WGL_EXT_framebuffer_sRGB

8072

CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = wglewGetExtension("WGL_EXT_framebuffer_sRGB");

8073

#endif /* WGL_EXT_framebuffer_sRGB */

8074

#ifdef WGL_EXT_make_current_read

8075

CONST_CAST(WGLEW_EXT_make_current_read) = wglewGetExtension("WGL_EXT_make_current_read");

8076

if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) CONST_CAST(WGLEW_EXT_make_current_read)= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

8077

#endif /* WGL_EXT_make_current_read */

8078

#ifdef WGL_EXT_multisample

8079

CONST_CAST(WGLEW_EXT_multisample) = wglewGetExtension("WGL_EXT_multisample");

8080

#endif /* WGL_EXT_multisample */

8081

#ifdef WGL_EXT_pbuffer

8082

CONST_CAST(WGLEW_EXT_pbuffer) = wglewGetExtension("WGL_EXT_pbuffer");

8083

if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

8084

#endif /* WGL_EXT_pbuffer */

8085

#ifdef WGL_EXT_pixel_format

8086

CONST_CAST(WGLEW_EXT_pixel_format) = wglewGetExtension("WGL_EXT_pixel_format");

8087

if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);

8088

#endif /* WGL_EXT_pixel_format */

8089

#ifdef WGL_EXT_pixel_format_packed_float

8090

CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = wglewGetExtension("WGL_EXT_pixel_format_packed_float");

8091

#endif /* WGL_EXT_pixel_format_packed_float */

8092

#ifdef WGL_EXT_swap_control

8093

CONST_CAST(WGLEW_EXT_swap_control) = wglewGetExtension("WGL_EXT_swap_control");

8094

if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);

8095

#endif /* WGL_EXT_swap_control */

8096

#ifdef WGL_I3D_digital_video_control

8097

CONST_CAST(WGLEW_I3D_digital_video_control) = wglewGetExtension("WGL_I3D_digital_video_control");

8098

if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) CONST_CAST(WGLEW_I3D_digital_video_control)= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT);

8099

#endif /* WGL_I3D_digital_video_control */

8100

#ifdef WGL_I3D_gamma

8101

CONST_CAST(WGLEW_I3D_gamma) = wglewGetExtension("WGL_I3D_gamma");

8102

if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT);

8103

#endif /* WGL_I3D_gamma */

8104

#ifdef WGL_I3D_genlock

8105

CONST_CAST(WGLEW_I3D_genlock) = wglewGetExtension("WGL_I3D_genlock");

8106

if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT);

8107

#endif /* WGL_I3D_genlock */

8108

#ifdef WGL_I3D_image_buffer

8109

CONST_CAST(WGLEW_I3D_image_buffer) = wglewGetExtension("WGL_I3D_image_buffer");

8110

if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

8111

#endif /* WGL_I3D_image_buffer */

8112

#ifdef WGL_I3D_swap_frame_lock

8113

CONST_CAST(WGLEW_I3D_swap_frame_lock) = wglewGetExtension("WGL_I3D_swap_frame_lock");

8114

if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_lock)= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT);

8115

#endif /* WGL_I3D_swap_frame_lock */

8116

#ifdef WGL_I3D_swap_frame_usage

8117

CONST_CAST(WGLEW_I3D_swap_frame_usage) = wglewGetExtension("WGL_I3D_swap_frame_usage");

8118

if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT);

8119

#endif /* WGL_I3D_swap_frame_usage */

8120

#ifdef WGL_NV_float_buffer

8121

CONST_CAST(WGLEW_NV_float_buffer) = wglewGetExtension("WGL_NV_float_buffer");

8122

#endif /* WGL_NV_float_buffer */

8123

#ifdef WGL_NV_gpu_affinity

8124

CONST_CAST(WGLEW_NV_gpu_affinity) = wglewGetExtension("WGL_NV_gpu_affinity");

8125

if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT);

8126

#endif /* WGL_NV_gpu_affinity */

8127

#ifdef WGL_NV_present_video

8128

CONST_CAST(WGLEW_NV_present_video) = wglewGetExtension("WGL_NV_present_video");

8129

if (glewExperimental || WGLEW_NV_present_video|| crippled) CONST_CAST(WGLEW_NV_present_video)= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);

8130

#endif /* WGL_NV_present_video */

8131

#ifdef WGL_NV_render_depth_texture

8132

CONST_CAST(WGLEW_NV_render_depth_texture) = wglewGetExtension("WGL_NV_render_depth_texture");

8133

#endif /* WGL_NV_render_depth_texture */

8134

#ifdef WGL_NV_render_texture_rectangle

8135

CONST_CAST(WGLEW_NV_render_texture_rectangle) = wglewGetExtension("WGL_NV_render_texture_rectangle");

8136

#endif /* WGL_NV_render_texture_rectangle */

8137

#ifdef WGL_NV_swap_group

8138

CONST_CAST(WGLEW_NV_swap_group) = wglewGetExtension("WGL_NV_swap_group");

8139

if (glewExperimental || WGLEW_NV_swap_group|| crippled) CONST_CAST(WGLEW_NV_swap_group)= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);

8140

#endif /* WGL_NV_swap_group */

8141

#ifdef WGL_NV_vertex_array_range

8142

CONST_CAST(WGLEW_NV_vertex_array_range) = wglewGetExtension("WGL_NV_vertex_array_range");

8143

if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) CONST_CAST(WGLEW_NV_vertex_array_range)= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

8144

#endif /* WGL_NV_vertex_array_range */

8145

#ifdef WGL_NV_video_output

8146

CONST_CAST(WGLEW_NV_video_output) = wglewGetExtension("WGL_NV_video_output");

8147

if (glewExperimental || WGLEW_NV_video_output|| crippled) CONST_CAST(WGLEW_NV_video_output)= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);

8148

#endif /* WGL_NV_video_output */

8149

#ifdef WGL_OML_sync_control

8150

CONST_CAST(WGLEW_OML_sync_control) = wglewGetExtension("WGL_OML_sync_control");

8151

if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);

8152

#endif /* WGL_OML_sync_control */

8153

8154

return GLEW_OK;

8155

}

8156

8157

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

8158

8159

PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;

8160

8161

PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;

8162

PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;

8163

PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;

8164

PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;

8165

PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;

8166

PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;

8167

PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;

8168

PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;

8169

PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;

8170

PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;

8171

PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;

8172

PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;

8173

PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;

8174

PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;

8175

PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;

8176

PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;

8177

PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;

8178

8179

PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL;

8180

8181

PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;

8182

PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;

8183

PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;

8184

8185

PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;

8186

PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;

8187

PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;

8188

PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;

8189

8190

PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;

8191

PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;

8192

8193

PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;

8194

8195

PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;

8196

8197

PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;

8198

8199

PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;

8200

8201

PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;

8202

8203

PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL;

8204

PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL;

8205

8206

PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL;

8207

PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL;

8208

PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL;

8209

PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL;

8210

PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL;

8211

PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL;

8212

8213

PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;

8214

PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;

8215

8216

PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL;

8217

PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL;

8218

PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL;

8219

PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL;

8220

PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL;

8221

PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL;

8222

8223

#ifdef GLX_OML_sync_control

8224

PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;

8225

PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;

8226

PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;

8227

PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;

8228

PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;

8229

#endif

8230

8231

PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;

8232

PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;

8233

PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;

8234

PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;

8235

PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;

8236

PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;

8237

8238

PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL;

8239

PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL;

8240

PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL;

8241

PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL;

8242

PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL;

8243

PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL;

8244

PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL;

8245

PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL;

8246

8247

PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;

8248

PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;

8249

PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;

8250

PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;

8251

PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;

8252

8253

PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;

8254

PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;

8255

8256

PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;

8257

8258

PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;

8259

PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;

8260

PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;

8261

PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;

8262

PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;

8263

8264

PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;

8265

8266

PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;

8267

PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;

8268

8269

PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;

8270

8271

PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;

8272

PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;

8273

8274

PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;

8275

8276

PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;

8277

PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;

8278

8279

#if !defined(GLEW_MX)

8280

8281

GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;

8282

GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;

8283

GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;

8284

GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;

8285

GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;

8286

GLboolean __GLXEW_3DFX_multisample = GL_FALSE;

8287

GLboolean __GLXEW_ARB_create_context = GL_FALSE;

8288

GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;

8289

GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE;

8290

GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;

8291

GLboolean __GLXEW_ARB_multisample = GL_FALSE;

8292

GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;

8293

GLboolean __GLXEW_ATI_render_texture = GL_FALSE;

8294

GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;

8295

GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;

8296

GLboolean __GLXEW_EXT_import_context = GL_FALSE;

8297

GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;

8298

GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;

8299

GLboolean __GLXEW_EXT_visual_info = GL_FALSE;

8300

GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;

8301

GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;

8302

GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;

8303

GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;

8304

GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;

8305

GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;

8306

GLboolean __GLXEW_NV_float_buffer = GL_FALSE;

8307

GLboolean __GLXEW_NV_present_video = GL_FALSE;

8308

GLboolean __GLXEW_NV_swap_group = GL_FALSE;

8309

GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;

8310

GLboolean __GLXEW_NV_video_output = GL_FALSE;

8311

GLboolean __GLXEW_OML_swap_method = GL_FALSE;

8312

#ifdef GLX_OML_sync_control

8313

GLboolean __GLXEW_OML_sync_control = GL_FALSE;

8314

#endif

8315

GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;

8316

GLboolean __GLXEW_SGIS_color_range = GL_FALSE;

8317

GLboolean __GLXEW_SGIS_multisample = GL_FALSE;

8318

GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;

8319

GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;

8320

GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE;

8321

GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;

8322

GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;

8323

GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;

8324

GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;

8325

GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;

8326

GLboolean __GLXEW_SGI_cushion = GL_FALSE;

8327

GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;

8328

GLboolean __GLXEW_SGI_swap_control = GL_FALSE;

8329

GLboolean __GLXEW_SGI_video_sync = GL_FALSE;

8330

GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;

8331

GLboolean __GLXEW_SUN_video_resize = GL_FALSE;

8332

8333

#endif /* !GLEW_MX */

8334

8335

#ifdef GLX_VERSION_1_2

8336

8337

static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT)

8338

{

8339

GLboolean r = GL_FALSE;

8340

8341

r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;

8342

8343

return r;

8344

}

8345

8346

#endif /* GLX_VERSION_1_2 */

8347

8348

#ifdef GLX_VERSION_1_3

8349

8350

static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT)

8351

{

8352

GLboolean r = GL_FALSE;

8353

8354

r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;

8355

r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;

8356

r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;

8357

r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;

8358

r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;

8359

r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;

8360

r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;

8361

r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;

8362

r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;

8363

r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;

8364

r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;

8365

r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;

8366

r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;

8367

r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;

8368

r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;

8369

r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;

8370

r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;

8371

8372

return r;

8373

}

8374

8375

#endif /* GLX_VERSION_1_3 */

8376

8377

#ifdef GLX_VERSION_1_4

8378

8379

#endif /* GLX_VERSION_1_4 */

8380

8381

#ifdef GLX_3DFX_multisample

8382

8383

#endif /* GLX_3DFX_multisample */

8384

8385

#ifdef GLX_ARB_create_context

8386

8387

static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT)

8388

{

8389

GLboolean r = GL_FALSE;

8390

8391

r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r;

8392

8393

return r;

8394

}

8395

8396

#endif /* GLX_ARB_create_context */

8397

8398

#ifdef GLX_ARB_fbconfig_float

8399

8400

#endif /* GLX_ARB_fbconfig_float */

8401

8402

#ifdef GLX_ARB_framebuffer_sRGB

8403

8404

#endif /* GLX_ARB_framebuffer_sRGB */

8405

8406

#ifdef GLX_ARB_get_proc_address

8407

8408

#endif /* GLX_ARB_get_proc_address */

8409

8410

#ifdef GLX_ARB_multisample

8411

8412

#endif /* GLX_ARB_multisample */

8413

8414

#ifdef GLX_ATI_pixel_format_float

8415

8416

#endif /* GLX_ATI_pixel_format_float */

8417

8418

#ifdef GLX_ATI_render_texture

8419

8420

static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT)

8421

{

8422

GLboolean r = GL_FALSE;

8423

8424

r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;

8425

r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;

8426

r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;

8427

8428

return r;

8429

}

8430

8431

#endif /* GLX_ATI_render_texture */

8432

8433

#ifdef GLX_EXT_fbconfig_packed_float

8434

8435

#endif /* GLX_EXT_fbconfig_packed_float */

8436

8437

#ifdef GLX_EXT_framebuffer_sRGB

8438

8439

#endif /* GLX_EXT_framebuffer_sRGB */

8440

8441

#ifdef GLX_EXT_import_context

8442

8443

static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)

8444

{

8445

GLboolean r = GL_FALSE;

8446

8447

r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;

8448

r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;

8449

r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;

8450

r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;

8451

8452

return r;

8453

}

8454

8455

#endif /* GLX_EXT_import_context */

8456

8457

#ifdef GLX_EXT_scene_marker

8458

8459

#endif /* GLX_EXT_scene_marker */

8460

8461

#ifdef GLX_EXT_texture_from_pixmap

8462

8463

static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT)

8464

{

8465

GLboolean r = GL_FALSE;

8466

8467

r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r;

8468

r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r;

8469

8470

return r;

8471

}

8472

8473

#endif /* GLX_EXT_texture_from_pixmap */

8474

8475

#ifdef GLX_EXT_visual_info

8476

8477

#endif /* GLX_EXT_visual_info */

8478

8479

#ifdef GLX_EXT_visual_rating

8480

8481

#endif /* GLX_EXT_visual_rating */

8482

8483

#ifdef GLX_MESA_agp_offset

8484

8485

static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)

8486

{

8487

GLboolean r = GL_FALSE;

8488

8489

r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;

8490

8491

return r;

8492

}

8493

8494

#endif /* GLX_MESA_agp_offset */

8495

8496

#ifdef GLX_MESA_copy_sub_buffer

8497

8498

static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT)

8499

{

8500

GLboolean r = GL_FALSE;

8501

8502

r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;

8503

8504

return r;

8505

}

8506

8507

#endif /* GLX_MESA_copy_sub_buffer */

8508

8509

#ifdef GLX_MESA_pixmap_colormap

8510

8511

static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT)

8512

{

8513

GLboolean r = GL_FALSE;

8514

8515

r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;

8516

8517

return r;

8518

}

8519

8520

#endif /* GLX_MESA_pixmap_colormap */

8521

8522

#ifdef GLX_MESA_release_buffers

8523

8524

static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT)

8525

{

8526

GLboolean r = GL_FALSE;

8527

8528

r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;

8529

8530

return r;

8531

}

8532

8533

#endif /* GLX_MESA_release_buffers */

8534

8535

#ifdef GLX_MESA_set_3dfx_mode

8536

8537

static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)

8538

{

8539

GLboolean r = GL_FALSE;

8540

8541

r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;

8542

8543

return r;

8544

}

8545

8546

#endif /* GLX_MESA_set_3dfx_mode */

8547

8548

#ifdef GLX_NV_float_buffer

8549

8550

#endif /* GLX_NV_float_buffer */

8551

8552

#ifdef GLX_NV_present_video

8553

8554

static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT)

8555

{

8556

GLboolean r = GL_FALSE;

8557

8558

r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;

8559

r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r;

8560

8561

return r;

8562

}

8563

8564

#endif /* GLX_NV_present_video */

8565

8566

#ifdef GLX_NV_swap_group

8567

8568

static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)

8569

{

8570

GLboolean r = GL_FALSE;

8571

8572

r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r;

8573

r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r;

8574

r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r;

8575

r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r;

8576

r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r;

8577

r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r;

8578

8579

return r;

8580

}

8581

8582

#endif /* GLX_NV_swap_group */

8583

8584

#ifdef GLX_NV_vertex_array_range

8585

8586

static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT)

8587

{

8588

GLboolean r = GL_FALSE;

8589

8590

r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;

8591

r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;

8592

8593

return r;

8594

}

8595

8596

#endif /* GLX_NV_vertex_array_range */

8597

8598

#ifdef GLX_NV_video_output

8599

8600

static GLboolean _glewInit_GLX_NV_video_output (GLXEW_CONTEXT_ARG_DEF_INIT)

8601

{

8602

GLboolean r = GL_FALSE;

8603

8604

r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r;

8605

r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r;

8606

r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r;

8607

r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r;

8608

r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r;

8609

r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r;

8610

8611

return r;

8612

}

8613

8614

#endif /* GLX_NV_video_output */

8615

8616

#ifdef GLX_OML_swap_method

8617

8618

#endif /* GLX_OML_swap_method */

8619

8620

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

8621

#include <inttypes.h>

8622

8623

static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT)

8624

{

8625

GLboolean r = GL_FALSE;

8626

8627

r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;

8628

r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;

8629

r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;

8630

r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;

8631

r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;

8632

8633

return r;

8634

}

8635

8636

#endif /* GLX_OML_sync_control */

8637

8638

#ifdef GLX_SGIS_blended_overlay

8639

8640

#endif /* GLX_SGIS_blended_overlay */

8641

8642

#ifdef GLX_SGIS_color_range

8643

8644

#endif /* GLX_SGIS_color_range */

8645

8646

#ifdef GLX_SGIS_multisample

8647

8648

#endif /* GLX_SGIS_multisample */

8649

8650

#ifdef GLX_SGIS_shared_multisample

8651

8652

#endif /* GLX_SGIS_shared_multisample */

8653

8654

#ifdef GLX_SGIX_fbconfig

8655

8656

static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT)

8657

{

8658

GLboolean r = GL_FALSE;

8659

8660

r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;

8661

r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;

8662

r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;

8663

r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;

8664

r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;

8665

r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;

8666

8667

return r;

8668

}

8669

8670

#endif /* GLX_SGIX_fbconfig */

8671

8672

#ifdef GLX_SGIX_hyperpipe

8673

8674

static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT)

8675

{

8676

GLboolean r = GL_FALSE;

8677

8678

r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r;

8679

r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r;

8680

r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r;

8681

r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r;

8682

r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r;

8683

r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r;

8684

r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r;

8685

r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r;

8686

8687

return r;

8688

}

8689

8690

#endif /* GLX_SGIX_hyperpipe */

8691

8692

#ifdef GLX_SGIX_pbuffer

8693

8694

static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT)

8695

{

8696

GLboolean r = GL_FALSE;

8697

8698

r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;

8699

r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;

8700

r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;

8701

r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;

8702

r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;

8703

8704

return r;

8705

}

8706

8707

#endif /* GLX_SGIX_pbuffer */

8708

8709

#ifdef GLX_SGIX_swap_barrier

8710

8711

static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT)

8712

{

8713

GLboolean r = GL_FALSE;

8714

8715

r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;

8716

r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;

8717

8718

return r;

8719

}

8720

8721

#endif /* GLX_SGIX_swap_barrier */

8722

8723

#ifdef GLX_SGIX_swap_group

8724

8725

static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)

8726

{

8727

GLboolean r = GL_FALSE;

8728

8729

r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;

8730

8731

return r;

8732

}

8733

8734

#endif /* GLX_SGIX_swap_group */

8735

8736

#ifdef GLX_SGIX_video_resize

8737

8738

static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)

8739

{

8740

GLboolean r = GL_FALSE;

8741

8742

r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;

8743

r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;

8744

r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;

8745

r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;

8746

r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;

8747

8748

return r;

8749

}

8750

8751

#endif /* GLX_SGIX_video_resize */

8752

8753

#ifdef GLX_SGIX_visual_select_group

8754

8755

#endif /* GLX_SGIX_visual_select_group */

8756

8757

#ifdef GLX_SGI_cushion

8758

8759

static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT)

8760

{

8761

GLboolean r = GL_FALSE;

8762

8763

r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;

8764

8765

return r;

8766

}

8767

8768

#endif /* GLX_SGI_cushion */

8769

8770

#ifdef GLX_SGI_make_current_read

8771

8772

static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT)

8773

{

8774

GLboolean r = GL_FALSE;

8775

8776

r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;

8777

r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;

8778

8779

return r;

8780

}

8781

8782

#endif /* GLX_SGI_make_current_read */

8783

8784

#ifdef GLX_SGI_swap_control

8785

8786

static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)

8787

{

8788

GLboolean r = GL_FALSE;

8789

8790

r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;

8791

8792

return r;

8793

}

8794

8795

#endif /* GLX_SGI_swap_control */

8796

8797

#ifdef GLX_SGI_video_sync

8798

8799

static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT)

8800

{

8801

GLboolean r = GL_FALSE;

8802

8803

r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;

8804

r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;

8805

8806

return r;

8807

}

8808

8809

#endif /* GLX_SGI_video_sync */

8810

8811

#ifdef GLX_SUN_get_transparent_index

8812

8813

static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT)

8814

{

8815

GLboolean r = GL_FALSE;

8816

8817

r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;

8818

8819

return r;

8820

}

8821

8822

#endif /* GLX_SUN_get_transparent_index */

8823

8824

#ifdef GLX_SUN_video_resize

8825

8826

static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)

8827

{

8828

GLboolean r = GL_FALSE;

8829

8830

r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;

8831

r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;

8832

8833

return r;

8834

}

8835

8836

#endif /* GLX_SUN_video_resize */

8837

8838

/* ------------------------------------------------------------------------ */

8839

8840

GLboolean glxewGetExtension (const char* name)

8841

{

8842

GLubyte* p;

8843

GLubyte* end;

8844

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

8845

/* if (glXQueryExtensionsString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE; */

8846

/* p = (GLubyte*)glXQueryExtensionsString(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay())); */

8847

if (glXGetClientString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE;

8848

p = (GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);

8849

if (0 == p) return GL_FALSE;

8850

end = p + _glewStrLen(p);

8851

while (p < end)

8852

{

8853

GLuint n = _glewStrCLen(p, ' ');

8854

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

8855

p += n+1;

8856

}

8857

return GL_FALSE;

8858

}

8859

8860

GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)

8861

{

8862

int major, minor;

8863

/* initialize core GLX 1.2 */

8864

if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY;

8865

/* initialize flags */

8866

CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE;

8867

CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE;

8868

CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE;

8869

CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE;

8870

CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE;

8871

/* query GLX version */

8872

glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);

8873

if (major == 1 && minor <= 3)

8874

{

8875

switch (minor)

8876

{

8877

case 3:

8878

CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;

8879

break;

8880

case 2:

8881

CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;

8882

CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE;

8883

break;

8884

default:

8885

return GLEW_ERROR_GLX_VERSION_11_ONLY;

8886

break;

8887

}

8888

}

8889

/* initialize extensions */

8890

#ifdef GLX_VERSION_1_3

8891

if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);

8892

#endif /* GLX_VERSION_1_3 */

8893

#ifdef GLX_3DFX_multisample

8894

CONST_CAST(GLXEW_3DFX_multisample) = glxewGetExtension("GLX_3DFX_multisample");

8895

#endif /* GLX_3DFX_multisample */

8896

#ifdef GLX_ARB_create_context

8897

CONST_CAST(GLXEW_ARB_create_context) = glxewGetExtension("GLX_ARB_create_context");

8898

if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);

8899

#endif /* GLX_ARB_create_context */

8900

#ifdef GLX_ARB_fbconfig_float

8901

CONST_CAST(GLXEW_ARB_fbconfig_float) = glxewGetExtension("GLX_ARB_fbconfig_float");

8902

#endif /* GLX_ARB_fbconfig_float */

8903

#ifdef GLX_ARB_framebuffer_sRGB

8904

CONST_CAST(GLXEW_ARB_framebuffer_sRGB) = glxewGetExtension("GLX_ARB_framebuffer_sRGB");

8905

#endif /* GLX_ARB_framebuffer_sRGB */

8906

#ifdef GLX_ARB_get_proc_address

8907

CONST_CAST(GLXEW_ARB_get_proc_address) = glxewGetExtension("GLX_ARB_get_proc_address");

8908

#endif /* GLX_ARB_get_proc_address */

8909

#ifdef GLX_ARB_multisample

8910

CONST_CAST(GLXEW_ARB_multisample) = glxewGetExtension("GLX_ARB_multisample");

8911

#endif /* GLX_ARB_multisample */

8912

#ifdef GLX_ATI_pixel_format_float

8913

CONST_CAST(GLXEW_ATI_pixel_format_float) = glxewGetExtension("GLX_ATI_pixel_format_float");

8914

#endif /* GLX_ATI_pixel_format_float */

8915

#ifdef GLX_ATI_render_texture

8916

CONST_CAST(GLXEW_ATI_render_texture) = glxewGetExtension("GLX_ATI_render_texture");

8917

if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);

8918

#endif /* GLX_ATI_render_texture */

8919

#ifdef GLX_EXT_fbconfig_packed_float

8920

CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = glxewGetExtension("GLX_EXT_fbconfig_packed_float");

8921

#endif /* GLX_EXT_fbconfig_packed_float */

8922

#ifdef GLX_EXT_framebuffer_sRGB

8923

CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = glxewGetExtension("GLX_EXT_framebuffer_sRGB");

8924

#endif /* GLX_EXT_framebuffer_sRGB */

8925

#ifdef GLX_EXT_import_context

8926

CONST_CAST(GLXEW_EXT_import_context) = glxewGetExtension("GLX_EXT_import_context");

8927

if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT);

8928

#endif /* GLX_EXT_import_context */

8929

#ifdef GLX_EXT_scene_marker

8930

CONST_CAST(GLXEW_EXT_scene_marker) = glxewGetExtension("GLX_EXT_scene_marker");

8931

#endif /* GLX_EXT_scene_marker */

8932

#ifdef GLX_EXT_texture_from_pixmap

8933

CONST_CAST(GLXEW_EXT_texture_from_pixmap) = glxewGetExtension("GLX_EXT_texture_from_pixmap");

8934

if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT);

8935

#endif /* GLX_EXT_texture_from_pixmap */

8936

#ifdef GLX_EXT_visual_info

8937

CONST_CAST(GLXEW_EXT_visual_info) = glxewGetExtension("GLX_EXT_visual_info");

8938

#endif /* GLX_EXT_visual_info */

8939

#ifdef GLX_EXT_visual_rating

8940

CONST_CAST(GLXEW_EXT_visual_rating) = glxewGetExtension("GLX_EXT_visual_rating");

8941

#endif /* GLX_EXT_visual_rating */

8942

#ifdef GLX_MESA_agp_offset

8943

CONST_CAST(GLXEW_MESA_agp_offset) = glxewGetExtension("GLX_MESA_agp_offset");

8944

if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);

8945

#endif /* GLX_MESA_agp_offset */

8946

#ifdef GLX_MESA_copy_sub_buffer

8947

CONST_CAST(GLXEW_MESA_copy_sub_buffer) = glxewGetExtension("GLX_MESA_copy_sub_buffer");

8948

if (glewExperimental || GLXEW_MESA_copy_sub_buffer) CONST_CAST(GLXEW_MESA_copy_sub_buffer) = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

8949

#endif /* GLX_MESA_copy_sub_buffer */

8950

#ifdef GLX_MESA_pixmap_colormap

8951

CONST_CAST(GLXEW_MESA_pixmap_colormap) = glxewGetExtension("GLX_MESA_pixmap_colormap");

8952

if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT);

8953

#endif /* GLX_MESA_pixmap_colormap */

8954

#ifdef GLX_MESA_release_buffers

8955

CONST_CAST(GLXEW_MESA_release_buffers) = glxewGetExtension("GLX_MESA_release_buffers");

8956

if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

8957

#endif /* GLX_MESA_release_buffers */

8958

#ifdef GLX_MESA_set_3dfx_mode

8959

CONST_CAST(GLXEW_MESA_set_3dfx_mode) = glxewGetExtension("GLX_MESA_set_3dfx_mode");

8960

if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT);

8961

#endif /* GLX_MESA_set_3dfx_mode */

8962

#ifdef GLX_NV_float_buffer

8963

CONST_CAST(GLXEW_NV_float_buffer) = glxewGetExtension("GLX_NV_float_buffer");

8964

#endif /* GLX_NV_float_buffer */

8965

#ifdef GLX_NV_present_video

8966

CONST_CAST(GLXEW_NV_present_video) = glxewGetExtension("GLX_NV_present_video");

8967

if (glewExperimental || GLXEW_NV_present_video) CONST_CAST(GLXEW_NV_present_video) = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);

8968

#endif /* GLX_NV_present_video */

8969

#ifdef GLX_NV_swap_group

8970

CONST_CAST(GLXEW_NV_swap_group) = glxewGetExtension("GLX_NV_swap_group");

8971

if (glewExperimental || GLXEW_NV_swap_group) CONST_CAST(GLXEW_NV_swap_group) = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);

8972

#endif /* GLX_NV_swap_group */

8973

#ifdef GLX_NV_vertex_array_range

8974

CONST_CAST(GLXEW_NV_vertex_array_range) = glxewGetExtension("GLX_NV_vertex_array_range");

8975

if (glewExperimental || GLXEW_NV_vertex_array_range) CONST_CAST(GLXEW_NV_vertex_array_range) = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

8976

#endif /* GLX_NV_vertex_array_range */

8977

#ifdef GLX_NV_video_output

8978

CONST_CAST(GLXEW_NV_video_output) = glxewGetExtension("GLX_NV_video_output");

8979

if (glewExperimental || GLXEW_NV_video_output) CONST_CAST(GLXEW_NV_video_output) = !_glewInit_GLX_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);

8980

#endif /* GLX_NV_video_output */

8981

#ifdef GLX_OML_swap_method

8982

CONST_CAST(GLXEW_OML_swap_method) = glxewGetExtension("GLX_OML_swap_method");

8983

#endif /* GLX_OML_swap_method */

8984

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

8985

#include <inttypes.h>

8986

CONST_CAST(GLXEW_OML_sync_control) = glxewGetExtension("GLX_OML_sync_control");

8987

if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);

8988

#endif /* GLX_OML_sync_control */

8989

#ifdef GLX_SGIS_blended_overlay

8990

CONST_CAST(GLXEW_SGIS_blended_overlay) = glxewGetExtension("GLX_SGIS_blended_overlay");

8991

#endif /* GLX_SGIS_blended_overlay */

8992

#ifdef GLX_SGIS_color_range

8993

CONST_CAST(GLXEW_SGIS_color_range) = glxewGetExtension("GLX_SGIS_color_range");

8994

#endif /* GLX_SGIS_color_range */

8995

#ifdef GLX_SGIS_multisample

8996

CONST_CAST(GLXEW_SGIS_multisample) = glxewGetExtension("GLX_SGIS_multisample");

8997

#endif /* GLX_SGIS_multisample */

8998

#ifdef GLX_SGIS_shared_multisample

8999

CONST_CAST(GLXEW_SGIS_shared_multisample) = glxewGetExtension("GLX_SGIS_shared_multisample");

9000

#endif /* GLX_SGIS_shared_multisample */

9001

#ifdef GLX_SGIX_fbconfig

9002

CONST_CAST(GLXEW_SGIX_fbconfig) = glxewGetExtension("GLX_SGIX_fbconfig");

9003

if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT);

9004

#endif /* GLX_SGIX_fbconfig */

9005

#ifdef GLX_SGIX_hyperpipe

9006

CONST_CAST(GLXEW_SGIX_hyperpipe) = glxewGetExtension("GLX_SGIX_hyperpipe");

9007

if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT);

9008

#endif /* GLX_SGIX_hyperpipe */

9009

#ifdef GLX_SGIX_pbuffer

9010

CONST_CAST(GLXEW_SGIX_pbuffer) = glxewGetExtension("GLX_SGIX_pbuffer");

9011

if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

9012

#endif /* GLX_SGIX_pbuffer */

9013

#ifdef GLX_SGIX_swap_barrier

9014

CONST_CAST(GLXEW_SGIX_swap_barrier) = glxewGetExtension("GLX_SGIX_swap_barrier");

9015

if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT);

9016

#endif /* GLX_SGIX_swap_barrier */

9017

#ifdef GLX_SGIX_swap_group

9018

CONST_CAST(GLXEW_SGIX_swap_group) = glxewGetExtension("GLX_SGIX_swap_group");

9019

if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);

9020

#endif /* GLX_SGIX_swap_group */

9021

#ifdef GLX_SGIX_video_resize

9022

CONST_CAST(GLXEW_SGIX_video_resize) = glxewGetExtension("GLX_SGIX_video_resize");

9023

if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);

9024

#endif /* GLX_SGIX_video_resize */

9025

#ifdef GLX_SGIX_visual_select_group

9026

CONST_CAST(GLXEW_SGIX_visual_select_group) = glxewGetExtension("GLX_SGIX_visual_select_group");

9027

#endif /* GLX_SGIX_visual_select_group */

9028

#ifdef GLX_SGI_cushion

9029

CONST_CAST(GLXEW_SGI_cushion) = glxewGetExtension("GLX_SGI_cushion");

9030

if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT);

9031

#endif /* GLX_SGI_cushion */

9032

#ifdef GLX_SGI_make_current_read

9033

CONST_CAST(GLXEW_SGI_make_current_read) = glxewGetExtension("GLX_SGI_make_current_read");

9034

if (glewExperimental || GLXEW_SGI_make_current_read) CONST_CAST(GLXEW_SGI_make_current_read) = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

9035

#endif /* GLX_SGI_make_current_read */

9036

#ifdef GLX_SGI_swap_control

9037

CONST_CAST(GLXEW_SGI_swap_control) = glxewGetExtension("GLX_SGI_swap_control");

9038

if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);

9039

#endif /* GLX_SGI_swap_control */

9040

#ifdef GLX_SGI_video_sync

9041

CONST_CAST(GLXEW_SGI_video_sync) = glxewGetExtension("GLX_SGI_video_sync");

9042

if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT);

9043

#endif /* GLX_SGI_video_sync */

9044

#ifdef GLX_SUN_get_transparent_index

9045

CONST_CAST(GLXEW_SUN_get_transparent_index) = glxewGetExtension("GLX_SUN_get_transparent_index");

9046

if (glewExperimental || GLXEW_SUN_get_transparent_index) CONST_CAST(GLXEW_SUN_get_transparent_index) = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT);

9047

#endif /* GLX_SUN_get_transparent_index */

9048

#ifdef GLX_SUN_video_resize

9049

CONST_CAST(GLXEW_SUN_video_resize) = glxewGetExtension("GLX_SUN_video_resize");

9050

if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);

9051

#endif /* GLX_SUN_video_resize */

9052

9053

return GLEW_OK;

9054

}

9055

9056

#endif /* !__APPLE__ || GLEW_APPLE_GLX */

9057

9058

/* ------------------------------------------------------------------------ */

9059

9060

const GLubyte* glewGetErrorString (GLenum error)

9061

{

9062

static const GLubyte* _glewErrorString[] =

9063

{

9064

(const GLubyte*)"No error",

9065

(const GLubyte*)"Missing GL version",

9066

(const GLubyte*)"GL 1.1 and up are not supported",

9067

(const GLubyte*)"GLX 1.2 and up are not supported",

9068

(const GLubyte*)"Unknown error"

9069

};

9070

const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;

9071

return _glewErrorString[(int)error > max_error ? max_error : (int)error];

9072

}

9073

9074

const GLubyte* glewGetString (GLenum name)

9075

{

9076

static const GLubyte* _glewString[] =

9077

{

9078

(const GLubyte*)NULL,

9079

(const GLubyte*)"1.5.1",

9080

(const GLubyte*)"1",

9081

(const GLubyte*)"5",

9082

(const GLubyte*)"1"

9083

};

9084

const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;

9085

return _glewString[(int)name > max_string ? 0 : (int)name];

9086

}

9087

9088

/* ------------------------------------------------------------------------ */

9089

9090

GLboolean glewExperimental = GL_FALSE;

9091

9092

#if !defined(GLEW_MX)

9093

9094

#if defined(_WIN32)

9095

extern GLenum wglewContextInit (void);

9096

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

9097

extern GLenum glxewContextInit (void);

9098

#endif /* _WIN32 */

9099

9100

GLenum glewInit ()

9101

{

9102

GLenum r;

9103

if ( (r = glewContextInit()) ) return r;

9104

#if defined(_WIN32)

9105

return wglewContextInit();

9106

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

9107

return glxewContextInit();

9108

#else

9109

return r;

9110

#endif /* _WIN32 */

9111

}

9112

9113

#endif /* !GLEW_MX */

9114

#ifdef GLEW_MX

9115

GLboolean glewContextIsSupported (GLEWContext* ctx, const char* name)

9116

#else

9117

GLboolean glewIsSupported (const char* name)

9118

#endif

9119

{

9120

GLubyte* pos = (GLubyte*)name;

9121

GLuint len = _glewStrLen(pos);

9122

GLboolean ret = GL_TRUE;

9123

while (ret && len > 0)

9124

{

9125

if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))

9126

{

9127

if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

9128

{

9129

#ifdef GL_VERSION_1_2

9130

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

9131

{

9132

ret = GLEW_VERSION_1_2;

9133

continue;

9134

}

9135

#endif

9136

#ifdef GL_VERSION_1_3

9137

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

9138

{

9139

ret = GLEW_VERSION_1_3;

9140

continue;

9141

}

9142

#endif

9143

#ifdef GL_VERSION_1_4

9144

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

9145

{

9146

ret = GLEW_VERSION_1_4;

9147

continue;

9148

}

9149

#endif

9150

#ifdef GL_VERSION_1_5

9151

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))

9152

{

9153

ret = GLEW_VERSION_1_5;

9154

continue;

9155

}

9156

#endif

9157

#ifdef GL_VERSION_2_0

9158

if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))

9159

{

9160

ret = GLEW_VERSION_2_0;

9161

continue;

9162

}

9163

#endif

9164

#ifdef GL_VERSION_2_1

9165

if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3))

9166

{

9167

ret = GLEW_VERSION_2_1;

9168

continue;

9169

}

9170

#endif

9171

#ifdef GL_VERSION_3_0

9172

if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3))

9173

{

9174

ret = GLEW_VERSION_3_0;

9175

continue;

9176

}

9177

#endif

9178

}

9179

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

9180

{

9181

#ifdef GL_3DFX_multisample

9182

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9183

{

9184

ret = GLEW_3DFX_multisample;

9185

continue;

9186

}

9187

#endif

9188

#ifdef GL_3DFX_tbuffer

9189

if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))

9190

{

9191

ret = GLEW_3DFX_tbuffer;

9192

continue;

9193

}

9194

#endif

9195

#ifdef GL_3DFX_texture_compression_FXT1

9196

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))

9197

{

9198

ret = GLEW_3DFX_texture_compression_FXT1;

9199

continue;

9200

}

9201

#endif

9202

}

9203

if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))

9204

{

9205

#ifdef GL_APPLE_client_storage

9206

if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))

9207

{

9208

ret = GLEW_APPLE_client_storage;

9209

continue;

9210

}

9211

#endif

9212

#ifdef GL_APPLE_element_array

9213

if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

9214

{

9215

ret = GLEW_APPLE_element_array;

9216

continue;

9217

}

9218

#endif

9219

#ifdef GL_APPLE_fence

9220

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

9221

{

9222

ret = GLEW_APPLE_fence;

9223

continue;

9224

}

9225

#endif

9226

#ifdef GL_APPLE_float_pixels

9227

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))

9228

{

9229

ret = GLEW_APPLE_float_pixels;

9230

continue;

9231

}

9232

#endif

9233

#ifdef GL_APPLE_flush_buffer_range

9234

if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18))

9235

{

9236

ret = GLEW_APPLE_flush_buffer_range;

9237

continue;

9238

}

9239

#endif

9240

#ifdef GL_APPLE_pixel_buffer

9241

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))

9242

{

9243

ret = GLEW_APPLE_pixel_buffer;

9244

continue;

9245

}

9246

#endif

9247

#ifdef GL_APPLE_specular_vector

9248

if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))

9249

{

9250

ret = GLEW_APPLE_specular_vector;

9251

continue;

9252

}

9253

#endif

9254

#ifdef GL_APPLE_texture_range

9255

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

9256

{

9257

ret = GLEW_APPLE_texture_range;

9258

continue;

9259

}

9260

#endif

9261

#ifdef GL_APPLE_transform_hint

9262

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))

9263

{

9264

ret = GLEW_APPLE_transform_hint;

9265

continue;

9266

}

9267

#endif

9268

#ifdef GL_APPLE_vertex_array_object

9269

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

9270

{

9271

ret = GLEW_APPLE_vertex_array_object;

9272

continue;

9273

}

9274

#endif

9275

#ifdef GL_APPLE_vertex_array_range

9276

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

9277

{

9278

ret = GLEW_APPLE_vertex_array_range;

9279

continue;

9280

}

9281

#endif

9282

#ifdef GL_APPLE_ycbcr_422

9283

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))

9284

{

9285

ret = GLEW_APPLE_ycbcr_422;

9286

continue;

9287

}

9288

#endif

9289

}

9290

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

9291

{

9292

#ifdef GL_ARB_color_buffer_float

9293

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))

9294

{

9295

ret = GLEW_ARB_color_buffer_float;

9296

continue;

9297

}

9298

#endif

9299

#ifdef GL_ARB_depth_buffer_float

9300

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))

9301

{

9302

ret = GLEW_ARB_depth_buffer_float;

9303

continue;

9304

}

9305

#endif

9306

#ifdef GL_ARB_depth_texture

9307

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

9308

{

9309

ret = GLEW_ARB_depth_texture;

9310

continue;

9311

}

9312

#endif

9313

#ifdef GL_ARB_draw_buffers

9314

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

9315

{

9316

ret = GLEW_ARB_draw_buffers;

9317

continue;

9318

}

9319

#endif

9320

#ifdef GL_ARB_draw_instanced

9321

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))

9322

{

9323

ret = GLEW_ARB_draw_instanced;

9324

continue;

9325

}

9326

#endif

9327

#ifdef GL_ARB_fragment_program

9328

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

9329

{

9330

ret = GLEW_ARB_fragment_program;

9331

continue;

9332

}

9333

#endif

9334

#ifdef GL_ARB_fragment_program_shadow

9335

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))

9336

{

9337

ret = GLEW_ARB_fragment_program_shadow;

9338

continue;

9339

}

9340

#endif

9341

#ifdef GL_ARB_fragment_shader

9342

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

9343

{

9344

ret = GLEW_ARB_fragment_shader;

9345

continue;

9346

}

9347

#endif

9348

#ifdef GL_ARB_framebuffer_object

9349

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))

9350

{

9351

ret = GLEW_ARB_framebuffer_object;

9352

continue;

9353

}

9354

#endif

9355

#ifdef GL_ARB_framebuffer_sRGB

9356

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

9357

{

9358

ret = GLEW_ARB_framebuffer_sRGB;

9359

continue;

9360

}

9361

#endif

9362

#ifdef GL_ARB_geometry_shader4

9363

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

9364

{

9365

ret = GLEW_ARB_geometry_shader4;

9366

continue;

9367

}

9368

#endif

9369

#ifdef GL_ARB_half_float_pixel

9370

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))

9371

{

9372

ret = GLEW_ARB_half_float_pixel;

9373

continue;

9374

}

9375

#endif

9376

#ifdef GL_ARB_half_float_vertex

9377

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17))

9378

{

9379

ret = GLEW_ARB_half_float_vertex;

9380

continue;

9381

}

9382

#endif

9383

#ifdef GL_ARB_imaging

9384

if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))

9385

{

9386

ret = GLEW_ARB_imaging;

9387

continue;

9388

}

9389

#endif

9390

#ifdef GL_ARB_instanced_arrays

9391

if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))

9392

{

9393

ret = GLEW_ARB_instanced_arrays;

9394

continue;

9395

}

9396

#endif

9397

#ifdef GL_ARB_map_buffer_range

9398

if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16))

9399

{

9400

ret = GLEW_ARB_map_buffer_range;

9401

continue;

9402

}

9403

#endif

9404

#ifdef GL_ARB_matrix_palette

9405

if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))

9406

{

9407

ret = GLEW_ARB_matrix_palette;

9408

continue;

9409

}

9410

#endif

9411

#ifdef GL_ARB_multisample

9412

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9413

{

9414

ret = GLEW_ARB_multisample;

9415

continue;

9416

}

9417

#endif

9418

#ifdef GL_ARB_multitexture

9419

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))

9420

{

9421

ret = GLEW_ARB_multitexture;

9422

continue;

9423

}

9424

#endif

9425

#ifdef GL_ARB_occlusion_query

9426

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

9427

{

9428

ret = GLEW_ARB_occlusion_query;

9429

continue;

9430

}

9431

#endif

9432

#ifdef GL_ARB_pixel_buffer_object

9433

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

9434

{

9435

ret = GLEW_ARB_pixel_buffer_object;

9436

continue;

9437

}

9438

#endif

9439

#ifdef GL_ARB_point_parameters

9440

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

9441

{

9442

ret = GLEW_ARB_point_parameters;

9443

continue;

9444

}

9445

#endif

9446

#ifdef GL_ARB_point_sprite

9447

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

9448

{

9449

ret = GLEW_ARB_point_sprite;

9450

continue;

9451

}

9452

#endif

9453

#ifdef GL_ARB_shader_objects

9454

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))

9455

{

9456

ret = GLEW_ARB_shader_objects;

9457

continue;

9458

}

9459

#endif

9460

#ifdef GL_ARB_shading_language_100

9461

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))

9462

{

9463

ret = GLEW_ARB_shading_language_100;

9464

continue;

9465

}

9466

#endif

9467

#ifdef GL_ARB_shadow

9468

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

9469

{

9470

ret = GLEW_ARB_shadow;

9471

continue;

9472

}

9473

#endif

9474

#ifdef GL_ARB_shadow_ambient

9475

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

9476

{

9477

ret = GLEW_ARB_shadow_ambient;

9478

continue;

9479

}

9480

#endif

9481

#ifdef GL_ARB_texture_border_clamp

9482

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

9483

{

9484

ret = GLEW_ARB_texture_border_clamp;

9485

continue;

9486

}

9487

#endif

9488

#ifdef GL_ARB_texture_buffer_object

9489

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))

9490

{

9491

ret = GLEW_ARB_texture_buffer_object;

9492

continue;

9493

}

9494

#endif

9495

#ifdef GL_ARB_texture_compression

9496

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))

9497

{

9498

ret = GLEW_ARB_texture_compression;

9499

continue;

9500

}

9501

#endif

9502

#ifdef GL_ARB_texture_compression_rgtc

9503

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))

9504

{

9505

ret = GLEW_ARB_texture_compression_rgtc;

9506

continue;

9507

}

9508

#endif

9509

#ifdef GL_ARB_texture_cube_map

9510

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

9511

{

9512

ret = GLEW_ARB_texture_cube_map;

9513

continue;

9514

}

9515

#endif

9516

#ifdef GL_ARB_texture_env_add

9517

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

9518

{

9519

ret = GLEW_ARB_texture_env_add;

9520

continue;

9521

}

9522

#endif

9523

#ifdef GL_ARB_texture_env_combine

9524

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

9525

{

9526

ret = GLEW_ARB_texture_env_combine;

9527

continue;

9528

}

9529

#endif

9530

#ifdef GL_ARB_texture_env_crossbar

9531

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))

9532

{

9533

ret = GLEW_ARB_texture_env_crossbar;

9534

continue;

9535

}

9536

#endif

9537

#ifdef GL_ARB_texture_env_dot3

9538

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

9539

{

9540

ret = GLEW_ARB_texture_env_dot3;

9541

continue;

9542

}

9543

#endif

9544

#ifdef GL_ARB_texture_float

9545

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

9546

{

9547

ret = GLEW_ARB_texture_float;

9548

continue;

9549

}

9550

#endif

9551

#ifdef GL_ARB_texture_mirrored_repeat

9552

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

9553

{

9554

ret = GLEW_ARB_texture_mirrored_repeat;

9555

continue;

9556

}

9557

#endif

9558

#ifdef GL_ARB_texture_non_power_of_two

9559

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))

9560

{

9561

ret = GLEW_ARB_texture_non_power_of_two;

9562

continue;

9563

}

9564

#endif

9565

#ifdef GL_ARB_texture_rectangle

9566

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

9567

{

9568

ret = GLEW_ARB_texture_rectangle;

9569

continue;

9570

}

9571

#endif

9572

#ifdef GL_ARB_texture_rg

9573

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10))

9574

{

9575

ret = GLEW_ARB_texture_rg;

9576

continue;

9577

}

9578

#endif

9579

#ifdef GL_ARB_transpose_matrix

9580

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))

9581

{

9582

ret = GLEW_ARB_transpose_matrix;

9583

continue;

9584

}

9585

#endif

9586

#ifdef GL_ARB_vertex_array_object

9587

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

9588

{

9589

ret = GLEW_ARB_vertex_array_object;

9590

continue;

9591

}

9592

#endif

9593

#ifdef GL_ARB_vertex_blend

9594

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))

9595

{

9596

ret = GLEW_ARB_vertex_blend;

9597

continue;

9598

}

9599

#endif

9600

#ifdef GL_ARB_vertex_buffer_object

9601

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))

9602

{

9603

ret = GLEW_ARB_vertex_buffer_object;

9604

continue;

9605

}

9606

#endif

9607

#ifdef GL_ARB_vertex_program

9608

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

9609

{

9610

ret = GLEW_ARB_vertex_program;

9611

continue;

9612

}

9613

#endif

9614

#ifdef GL_ARB_vertex_shader

9615

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

9616

{

9617

ret = GLEW_ARB_vertex_shader;

9618

continue;

9619

}

9620

#endif

9621

#ifdef GL_ARB_window_pos

9622

if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

9623

{

9624

ret = GLEW_ARB_window_pos;

9625

continue;

9626

}

9627

#endif

9628

}

9629

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))

9630

{

9631

#ifdef GL_ATIX_point_sprites

9632

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))

9633

{

9634

ret = GLEW_ATIX_point_sprites;

9635

continue;

9636

}

9637

#endif

9638

#ifdef GL_ATIX_texture_env_combine3

9639

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

9640

{

9641

ret = GLEW_ATIX_texture_env_combine3;

9642

continue;

9643

}

9644

#endif

9645

#ifdef GL_ATIX_texture_env_route

9646

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))

9647

{

9648

ret = GLEW_ATIX_texture_env_route;

9649

continue;

9650

}

9651

#endif

9652

#ifdef GL_ATIX_vertex_shader_output_point_size

9653

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))

9654

{

9655

ret = GLEW_ATIX_vertex_shader_output_point_size;

9656

continue;

9657

}

9658

#endif

9659

}

9660

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

9661

{

9662

#ifdef GL_ATI_draw_buffers

9663

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

9664

{

9665

ret = GLEW_ATI_draw_buffers;

9666

continue;

9667

}

9668

#endif

9669

#ifdef GL_ATI_element_array

9670

if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

9671

{

9672

ret = GLEW_ATI_element_array;

9673

continue;

9674

}

9675

#endif

9676

#ifdef GL_ATI_envmap_bumpmap

9677

if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))

9678

{

9679

ret = GLEW_ATI_envmap_bumpmap;

9680

continue;

9681

}

9682

#endif

9683

#ifdef GL_ATI_fragment_shader

9684

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

9685

{

9686

ret = GLEW_ATI_fragment_shader;

9687

continue;

9688

}

9689

#endif

9690

#ifdef GL_ATI_map_object_buffer

9691

if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))

9692

{

9693

ret = GLEW_ATI_map_object_buffer;

9694

continue;

9695

}

9696

#endif

9697

#ifdef GL_ATI_pn_triangles

9698

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))

9699

{

9700

ret = GLEW_ATI_pn_triangles;

9701

continue;

9702

}

9703

#endif

9704

#ifdef GL_ATI_separate_stencil

9705

if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))

9706

{

9707

ret = GLEW_ATI_separate_stencil;

9708

continue;

9709

}

9710

#endif

9711

#ifdef GL_ATI_shader_texture_lod

9712

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))

9713

{

9714

ret = GLEW_ATI_shader_texture_lod;

9715

continue;

9716

}

9717

#endif

9718

#ifdef GL_ATI_text_fragment_shader

9719

if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))

9720

{

9721

ret = GLEW_ATI_text_fragment_shader;

9722

continue;

9723

}

9724

#endif

9725

#ifdef GL_ATI_texture_compression_3dc

9726

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))

9727

{

9728

ret = GLEW_ATI_texture_compression_3dc;

9729

continue;

9730

}

9731

#endif

9732

#ifdef GL_ATI_texture_env_combine3

9733

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

9734

{

9735

ret = GLEW_ATI_texture_env_combine3;

9736

continue;

9737

}

9738

#endif

9739

#ifdef GL_ATI_texture_float

9740

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

9741

{

9742

ret = GLEW_ATI_texture_float;

9743

continue;

9744

}

9745

#endif

9746

#ifdef GL_ATI_texture_mirror_once

9747

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))

9748

{

9749

ret = GLEW_ATI_texture_mirror_once;

9750

continue;

9751

}

9752

#endif

9753

#ifdef GL_ATI_vertex_array_object

9754

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

9755

{

9756

ret = GLEW_ATI_vertex_array_object;

9757

continue;

9758

}

9759

#endif

9760

#ifdef GL_ATI_vertex_attrib_array_object

9761

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))

9762

{

9763

ret = GLEW_ATI_vertex_attrib_array_object;

9764

continue;

9765

}

9766

#endif

9767

#ifdef GL_ATI_vertex_streams

9768

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))

9769

{

9770

ret = GLEW_ATI_vertex_streams;

9771

continue;

9772

}

9773

#endif

9774

}

9775

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

9776

{

9777

#ifdef GL_EXT_422_pixels

9778

if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))

9779

{

9780

ret = GLEW_EXT_422_pixels;

9781

continue;

9782

}

9783

#endif

9784

#ifdef GL_EXT_Cg_shader

9785

if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))

9786

{

9787

ret = GLEW_EXT_Cg_shader;

9788

continue;

9789

}

9790

#endif

9791

#ifdef GL_EXT_abgr

9792

if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))

9793

{

9794

ret = GLEW_EXT_abgr;

9795

continue;

9796

}

9797

#endif

9798

#ifdef GL_EXT_bgra

9799

if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))

9800

{

9801

ret = GLEW_EXT_bgra;

9802

continue;

9803

}

9804

#endif

9805

#ifdef GL_EXT_bindable_uniform

9806

if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16))

9807

{

9808

ret = GLEW_EXT_bindable_uniform;

9809

continue;

9810

}

9811

#endif

9812

#ifdef GL_EXT_blend_color

9813

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))

9814

{

9815

ret = GLEW_EXT_blend_color;

9816

continue;

9817

}

9818

#endif

9819

#ifdef GL_EXT_blend_equation_separate

9820

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))

9821

{

9822

ret = GLEW_EXT_blend_equation_separate;

9823

continue;

9824

}

9825

#endif

9826

#ifdef GL_EXT_blend_func_separate

9827

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))

9828

{

9829

ret = GLEW_EXT_blend_func_separate;

9830

continue;

9831

}

9832

#endif

9833

#ifdef GL_EXT_blend_logic_op

9834

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))

9835

{

9836

ret = GLEW_EXT_blend_logic_op;

9837

continue;

9838

}

9839

#endif

9840

#ifdef GL_EXT_blend_minmax

9841

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))

9842

{

9843

ret = GLEW_EXT_blend_minmax;

9844

continue;

9845

}

9846

#endif

9847

#ifdef GL_EXT_blend_subtract

9848

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))

9849

{

9850

ret = GLEW_EXT_blend_subtract;

9851

continue;

9852

}

9853

#endif

9854

#ifdef GL_EXT_clip_volume_hint

9855

if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))

9856

{

9857

ret = GLEW_EXT_clip_volume_hint;

9858

continue;

9859

}

9860

#endif

9861

#ifdef GL_EXT_cmyka

9862

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))

9863

{

9864

ret = GLEW_EXT_cmyka;

9865

continue;

9866

}

9867

#endif

9868

#ifdef GL_EXT_color_subtable

9869

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))

9870

{

9871

ret = GLEW_EXT_color_subtable;

9872

continue;

9873

}

9874

#endif

9875

#ifdef GL_EXT_compiled_vertex_array

9876

if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))

9877

{

9878

ret = GLEW_EXT_compiled_vertex_array;

9879

continue;

9880

}

9881

#endif

9882

#ifdef GL_EXT_convolution

9883

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))

9884

{

9885

ret = GLEW_EXT_convolution;

9886

continue;

9887

}

9888

#endif

9889

#ifdef GL_EXT_coordinate_frame

9890

if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))

9891

{

9892

ret = GLEW_EXT_coordinate_frame;

9893

continue;

9894

}

9895

#endif

9896

#ifdef GL_EXT_copy_texture

9897

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))

9898

{

9899

ret = GLEW_EXT_copy_texture;

9900

continue;

9901

}

9902

#endif

9903

#ifdef GL_EXT_cull_vertex

9904

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

9905

{

9906

ret = GLEW_EXT_cull_vertex;

9907

continue;

9908

}

9909

#endif

9910

#ifdef GL_EXT_depth_bounds_test

9911

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))

9912

{

9913

ret = GLEW_EXT_depth_bounds_test;

9914

continue;

9915

}

9916

#endif

9917

#ifdef GL_EXT_direct_state_access

9918

if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19))

9919

{

9920

ret = GLEW_EXT_direct_state_access;

9921

continue;

9922

}

9923

#endif

9924

#ifdef GL_EXT_draw_buffers2

9925

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13))

9926

{

9927

ret = GLEW_EXT_draw_buffers2;

9928

continue;

9929

}

9930

#endif

9931

#ifdef GL_EXT_draw_instanced

9932

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))

9933

{

9934

ret = GLEW_EXT_draw_instanced;

9935

continue;

9936

}

9937

#endif

9938

#ifdef GL_EXT_draw_range_elements

9939

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))

9940

{

9941

ret = GLEW_EXT_draw_range_elements;

9942

continue;

9943

}

9944

#endif

9945

#ifdef GL_EXT_fog_coord

9946

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))

9947

{

9948

ret = GLEW_EXT_fog_coord;

9949

continue;

9950

}

9951

#endif

9952

#ifdef GL_EXT_fragment_lighting

9953

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))

9954

{

9955

ret = GLEW_EXT_fragment_lighting;

9956

continue;

9957

}

9958

#endif

9959

#ifdef GL_EXT_framebuffer_blit

9960

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))

9961

{

9962

ret = GLEW_EXT_framebuffer_blit;

9963

continue;

9964

}

9965

#endif

9966

#ifdef GL_EXT_framebuffer_multisample

9967

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))

9968

{

9969

ret = GLEW_EXT_framebuffer_multisample;

9970

continue;

9971

}

9972

#endif

9973

#ifdef GL_EXT_framebuffer_object

9974

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))

9975

{

9976

ret = GLEW_EXT_framebuffer_object;

9977

continue;

9978

}

9979

#endif

9980

#ifdef GL_EXT_framebuffer_sRGB

9981

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

9982

{

9983

ret = GLEW_EXT_framebuffer_sRGB;

9984

continue;

9985

}

9986

#endif

9987

#ifdef GL_EXT_geometry_shader4

9988

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

9989

{

9990

ret = GLEW_EXT_geometry_shader4;

9991

continue;

9992

}

9993

#endif

9994

#ifdef GL_EXT_gpu_program_parameters

9995

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22))

9996

{

9997

ret = GLEW_EXT_gpu_program_parameters;

9998

continue;

9999

}

10000

#endif

10001

#ifdef GL_EXT_gpu_shader4

10002

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11))

10003

{

10004

ret = GLEW_EXT_gpu_shader4;

10005

continue;

10006

}

10007

#endif

10008

#ifdef GL_EXT_histogram

10009

if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))

10010

{

10011

ret = GLEW_EXT_histogram;

10012

continue;

10013

}

10014

#endif

10015

#ifdef GL_EXT_index_array_formats

10016

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))

10017

{

10018

ret = GLEW_EXT_index_array_formats;

10019

continue;

10020

}

10021

#endif

10022

#ifdef GL_EXT_index_func

10023

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))

10024

{

10025

ret = GLEW_EXT_index_func;

10026

continue;

10027

}

10028

#endif

10029

#ifdef GL_EXT_index_material

10030

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))

10031

{

10032

ret = GLEW_EXT_index_material;

10033

continue;

10034

}

10035

#endif

10036

#ifdef GL_EXT_index_texture

10037

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))

10038

{

10039

ret = GLEW_EXT_index_texture;

10040

continue;

10041

}

10042

#endif

10043

#ifdef GL_EXT_light_texture

10044

if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))

10045

{

10046

ret = GLEW_EXT_light_texture;

10047

continue;

10048

}

10049

#endif

10050

#ifdef GL_EXT_misc_attribute

10051

if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))

10052

{

10053

ret = GLEW_EXT_misc_attribute;

10054

continue;

10055

}

10056

#endif

10057

#ifdef GL_EXT_multi_draw_arrays

10058

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))

10059

{

10060

ret = GLEW_EXT_multi_draw_arrays;

10061

continue;

10062

}

10063

#endif

10064

#ifdef GL_EXT_multisample

10065

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

10066

{

10067

ret = GLEW_EXT_multisample;

10068

continue;

10069

}

10070

#endif

10071

#ifdef GL_EXT_packed_depth_stencil

10072

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

10073

{

10074

ret = GLEW_EXT_packed_depth_stencil;

10075

continue;

10076

}

10077

#endif

10078

#ifdef GL_EXT_packed_float

10079

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))

10080

{

10081

ret = GLEW_EXT_packed_float;

10082

continue;

10083

}

10084

#endif

10085

#ifdef GL_EXT_packed_pixels

10086

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))

10087

{

10088

ret = GLEW_EXT_packed_pixels;

10089

continue;

10090

}

10091

#endif

10092

#ifdef GL_EXT_paletted_texture

10093

if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))

10094

{

10095

ret = GLEW_EXT_paletted_texture;

10096

continue;

10097

}

10098

#endif

10099

#ifdef GL_EXT_pixel_buffer_object

10100

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

10101

{

10102

ret = GLEW_EXT_pixel_buffer_object;

10103

continue;

10104

}

10105

#endif

10106

#ifdef GL_EXT_pixel_transform

10107

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))

10108

{

10109

ret = GLEW_EXT_pixel_transform;

10110

continue;

10111

}

10112

#endif

10113

#ifdef GL_EXT_pixel_transform_color_table

10114

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))

10115

{

10116

ret = GLEW_EXT_pixel_transform_color_table;

10117

continue;

10118

}

10119

#endif

10120

#ifdef GL_EXT_point_parameters

10121

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

10122

{

10123

ret = GLEW_EXT_point_parameters;

10124

continue;

10125

}

10126

#endif

10127

#ifdef GL_EXT_polygon_offset

10128

if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))

10129

{

10130

ret = GLEW_EXT_polygon_offset;

10131

continue;

10132

}

10133

#endif

10134

#ifdef GL_EXT_rescale_normal

10135

if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))

10136

{

10137

ret = GLEW_EXT_rescale_normal;

10138

continue;

10139

}

10140

#endif

10141

#ifdef GL_EXT_scene_marker

10142

if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

10143

{

10144

ret = GLEW_EXT_scene_marker;

10145

continue;

10146

}

10147

#endif

10148

#ifdef GL_EXT_secondary_color

10149

if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))

10150

{

10151

ret = GLEW_EXT_secondary_color;

10152

continue;

10153

}

10154

#endif

10155

#ifdef GL_EXT_separate_specular_color

10156

if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))

10157

{

10158

ret = GLEW_EXT_separate_specular_color;

10159

continue;

10160

}

10161

#endif

10162

#ifdef GL_EXT_shadow_funcs

10163

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))

10164

{

10165

ret = GLEW_EXT_shadow_funcs;

10166

continue;

10167

}

10168

#endif

10169

#ifdef GL_EXT_shared_texture_palette

10170

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))

10171

{

10172

ret = GLEW_EXT_shared_texture_palette;

10173

continue;

10174

}

10175

#endif

10176

#ifdef GL_EXT_stencil_clear_tag

10177

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17))

10178

{

10179

ret = GLEW_EXT_stencil_clear_tag;

10180

continue;

10181

}

10182

#endif

10183

#ifdef GL_EXT_stencil_two_side

10184

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))

10185

{

10186

ret = GLEW_EXT_stencil_two_side;

10187

continue;

10188

}

10189

#endif

10190

#ifdef GL_EXT_stencil_wrap

10191

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))

10192

{

10193

ret = GLEW_EXT_stencil_wrap;

10194

continue;

10195

}

10196

#endif

10197

#ifdef GL_EXT_subtexture

10198

if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))

10199

{

10200

ret = GLEW_EXT_subtexture;

10201

continue;

10202

}

10203

#endif

10204

#ifdef GL_EXT_texture

10205

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))

10206

{

10207

ret = GLEW_EXT_texture;

10208

continue;

10209

}

10210

#endif

10211

#ifdef GL_EXT_texture3D

10212

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))

10213

{

10214

ret = GLEW_EXT_texture3D;

10215

continue;

10216

}

10217

#endif

10218

#ifdef GL_EXT_texture_array

10219

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))

10220

{

10221

ret = GLEW_EXT_texture_array;

10222

continue;

10223

}

10224

#endif

10225

#ifdef GL_EXT_texture_buffer_object

10226

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))

10227

{

10228

ret = GLEW_EXT_texture_buffer_object;

10229

continue;

10230

}

10231

#endif

10232

#ifdef GL_EXT_texture_compression_dxt1

10233

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))

10234

{

10235

ret = GLEW_EXT_texture_compression_dxt1;

10236

continue;

10237

}

10238

#endif

10239

#ifdef GL_EXT_texture_compression_latc

10240

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))

10241

{

10242

ret = GLEW_EXT_texture_compression_latc;

10243

continue;

10244

}

10245

#endif

10246

#ifdef GL_EXT_texture_compression_rgtc

10247

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))

10248

{

10249

ret = GLEW_EXT_texture_compression_rgtc;

10250

continue;

10251

}

10252

#endif

10253

#ifdef GL_EXT_texture_compression_s3tc

10254

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))

10255

{

10256

ret = GLEW_EXT_texture_compression_s3tc;

10257

continue;

10258

}

10259

#endif

10260

#ifdef GL_EXT_texture_cube_map

10261

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

10262

{

10263

ret = GLEW_EXT_texture_cube_map;

10264

continue;

10265

}

10266

#endif

10267

#ifdef GL_EXT_texture_edge_clamp

10268

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

10269

{

10270

ret = GLEW_EXT_texture_edge_clamp;

10271

continue;

10272

}

10273

#endif

10274

#ifdef GL_EXT_texture_env

10275

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))

10276

{

10277

ret = GLEW_EXT_texture_env;

10278

continue;

10279

}

10280

#endif

10281

#ifdef GL_EXT_texture_env_add

10282

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

10283

{

10284

ret = GLEW_EXT_texture_env_add;

10285

continue;

10286

}

10287

#endif

10288

#ifdef GL_EXT_texture_env_combine

10289

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

10290

{

10291

ret = GLEW_EXT_texture_env_combine;

10292

continue;

10293

}

10294

#endif

10295

#ifdef GL_EXT_texture_env_dot3

10296

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

10297

{

10298

ret = GLEW_EXT_texture_env_dot3;

10299

continue;

10300

}

10301

#endif

10302

#ifdef GL_EXT_texture_filter_anisotropic

10303

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))

10304

{

10305

ret = GLEW_EXT_texture_filter_anisotropic;

10306

continue;

10307

}

10308

#endif

10309

#ifdef GL_EXT_texture_integer

10310

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15))

10311

{

10312

ret = GLEW_EXT_texture_integer;

10313

continue;

10314

}

10315

#endif

10316

#ifdef GL_EXT_texture_lod_bias

10317

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

10318

{

10319

ret = GLEW_EXT_texture_lod_bias;

10320

continue;

10321

}

10322

#endif

10323

#ifdef GL_EXT_texture_mirror_clamp

10324

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))

10325

{

10326

ret = GLEW_EXT_texture_mirror_clamp;

10327

continue;

10328

}

10329

#endif

10330

#ifdef GL_EXT_texture_object

10331

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))

10332

{

10333

ret = GLEW_EXT_texture_object;

10334

continue;

10335

}

10336

#endif

10337

#ifdef GL_EXT_texture_perturb_normal

10338

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))

10339

{

10340

ret = GLEW_EXT_texture_perturb_normal;

10341

continue;

10342

}

10343

#endif

10344

#ifdef GL_EXT_texture_rectangle

10345

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

10346

{

10347

ret = GLEW_EXT_texture_rectangle;

10348

continue;

10349

}

10350

#endif

10351

#ifdef GL_EXT_texture_sRGB

10352

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12))

10353

{

10354

ret = GLEW_EXT_texture_sRGB;

10355

continue;

10356

}

10357

#endif

10358

#ifdef GL_EXT_texture_shared_exponent

10359

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23))

10360

{

10361

ret = GLEW_EXT_texture_shared_exponent;

10362

continue;

10363

}

10364

#endif

10365

#ifdef GL_EXT_texture_swizzle

10366

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))

10367

{

10368

ret = GLEW_EXT_texture_swizzle;

10369

continue;

10370

}

10371

#endif

10372

#ifdef GL_EXT_timer_query

10373

if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))

10374

{

10375

ret = GLEW_EXT_timer_query;

10376

continue;

10377

}

10378

#endif

10379

#ifdef GL_EXT_transform_feedback

10380

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))

10381

{

10382

ret = GLEW_EXT_transform_feedback;

10383

continue;

10384

}

10385

#endif

10386

#ifdef GL_EXT_vertex_array

10387

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))

10388

{

10389

ret = GLEW_EXT_vertex_array;

10390

continue;

10391

}

10392

#endif

10393

#ifdef GL_EXT_vertex_array_bgra

10394

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))

10395

{

10396

ret = GLEW_EXT_vertex_array_bgra;

10397

continue;

10398

}

10399

#endif

10400

#ifdef GL_EXT_vertex_shader

10401

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

10402

{

10403

ret = GLEW_EXT_vertex_shader;

10404

continue;

10405

}

10406

#endif

10407

#ifdef GL_EXT_vertex_weighting

10408

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))

10409

{

10410

ret = GLEW_EXT_vertex_weighting;

10411

continue;

10412

}

10413

#endif

10414

}

10415

if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8))

10416

{

10417

#ifdef GL_GREMEDY_frame_terminator

10418

if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16))

10419

{

10420

ret = GLEW_GREMEDY_frame_terminator;

10421

continue;

10422

}

10423

#endif

10424

#ifdef GL_GREMEDY_string_marker

10425

if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13))

10426

{

10427

ret = GLEW_GREMEDY_string_marker;

10428

continue;

10429

}

10430

#endif

10431

}

10432

if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))

10433

{

10434

#ifdef GL_HP_convolution_border_modes

10435

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

10436

{

10437

ret = GLEW_HP_convolution_border_modes;

10438

continue;

10439

}

10440

#endif

10441

#ifdef GL_HP_image_transform

10442

if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))

10443

{

10444

ret = GLEW_HP_image_transform;

10445

continue;

10446

}

10447

#endif

10448

#ifdef GL_HP_occlusion_test

10449

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))

10450

{

10451

ret = GLEW_HP_occlusion_test;

10452

continue;

10453

}

10454

#endif

10455

#ifdef GL_HP_texture_lighting

10456

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))

10457

{

10458

ret = GLEW_HP_texture_lighting;

10459

continue;

10460

}

10461

#endif

10462

}

10463

if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))

10464

{

10465

#ifdef GL_IBM_cull_vertex

10466

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

10467

{

10468

ret = GLEW_IBM_cull_vertex;

10469

continue;

10470

}

10471

#endif

10472

#ifdef GL_IBM_multimode_draw_arrays

10473

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))

10474

{

10475

ret = GLEW_IBM_multimode_draw_arrays;

10476

continue;

10477

}

10478

#endif

10479

#ifdef GL_IBM_rasterpos_clip

10480

if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))

10481

{

10482

ret = GLEW_IBM_rasterpos_clip;

10483

continue;

10484

}

10485

#endif

10486

#ifdef GL_IBM_static_data

10487

if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))

10488

{

10489

ret = GLEW_IBM_static_data;

10490

continue;

10491

}

10492

#endif

10493

#ifdef GL_IBM_texture_mirrored_repeat

10494

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

10495

{

10496

ret = GLEW_IBM_texture_mirrored_repeat;

10497

continue;

10498

}

10499

#endif

10500

#ifdef GL_IBM_vertex_array_lists

10501

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))

10502

{

10503

ret = GLEW_IBM_vertex_array_lists;

10504

continue;

10505

}

10506

#endif

10507

}

10508

if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))

10509

{

10510

#ifdef GL_INGR_color_clamp

10511

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))

10512

{

10513

ret = GLEW_INGR_color_clamp;

10514

continue;

10515

}

10516

#endif

10517

#ifdef GL_INGR_interlace_read

10518

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))

10519

{

10520

ret = GLEW_INGR_interlace_read;

10521

continue;

10522

}

10523

#endif

10524

}

10525

if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))

10526

{

10527

#ifdef GL_INTEL_parallel_arrays

10528

if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))

10529

{

10530

ret = GLEW_INTEL_parallel_arrays;

10531

continue;

10532

}

10533

#endif

10534

#ifdef GL_INTEL_texture_scissor

10535

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))

10536

{

10537

ret = GLEW_INTEL_texture_scissor;

10538

continue;

10539

}

10540

#endif

10541

}

10542

if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))

10543

{

10544

#ifdef GL_KTX_buffer_region

10545

if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

10546

{

10547

ret = GLEW_KTX_buffer_region;

10548

continue;

10549

}

10550

#endif

10551

}

10552

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6))

10553

{

10554

#ifdef GL_MESAX_texture_stack

10555

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13))

10556

{

10557

ret = GLEW_MESAX_texture_stack;

10558

continue;

10559

}

10560

#endif

10561

}

10562

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

10563

{

10564

#ifdef GL_MESA_pack_invert

10565

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))

10566

{

10567

ret = GLEW_MESA_pack_invert;

10568

continue;

10569

}

10570

#endif

10571

#ifdef GL_MESA_resize_buffers

10572

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))

10573

{

10574

ret = GLEW_MESA_resize_buffers;

10575

continue;

10576

}

10577

#endif

10578

#ifdef GL_MESA_window_pos

10579

if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

10580

{

10581

ret = GLEW_MESA_window_pos;

10582

continue;

10583

}

10584

#endif

10585

#ifdef GL_MESA_ycbcr_texture

10586

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))

10587

{

10588

ret = GLEW_MESA_ycbcr_texture;

10589

continue;

10590

}

10591

#endif

10592

}

10593

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

10594

{

10595

#ifdef GL_NV_blend_square

10596

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))

10597

{

10598

ret = GLEW_NV_blend_square;

10599

continue;

10600

}

10601

#endif

10602

#ifdef GL_NV_conditional_render

10603

if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))

10604

{

10605

ret = GLEW_NV_conditional_render;

10606

continue;

10607

}

10608

#endif

10609

#ifdef GL_NV_copy_depth_to_color

10610

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))

10611

{

10612

ret = GLEW_NV_copy_depth_to_color;

10613

continue;

10614

}

10615

#endif

10616

#ifdef GL_NV_depth_buffer_float

10617

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))

10618

{

10619

ret = GLEW_NV_depth_buffer_float;

10620

continue;

10621

}

10622

#endif

10623

#ifdef GL_NV_depth_clamp

10624

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))

10625

{

10626

ret = GLEW_NV_depth_clamp;

10627

continue;

10628

}

10629

#endif

10630

#ifdef GL_NV_depth_range_unclamped

10631

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21))

10632

{

10633

ret = GLEW_NV_depth_range_unclamped;

10634

continue;

10635

}

10636

#endif

10637

#ifdef GL_NV_evaluators

10638

if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))

10639

{

10640

ret = GLEW_NV_evaluators;

10641

continue;

10642

}

10643

#endif

10644

#ifdef GL_NV_explicit_multisample

10645

if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20))

10646

{

10647

ret = GLEW_NV_explicit_multisample;

10648

continue;

10649

}

10650

#endif

10651

#ifdef GL_NV_fence

10652

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

10653

{

10654

ret = GLEW_NV_fence;

10655

continue;

10656

}

10657

#endif

10658

#ifdef GL_NV_float_buffer

10659

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

10660

{

10661

ret = GLEW_NV_float_buffer;

10662

continue;

10663

}

10664

#endif

10665

#ifdef GL_NV_fog_distance

10666

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))

10667

{

10668

ret = GLEW_NV_fog_distance;

10669

continue;

10670

}

10671

#endif

10672

#ifdef GL_NV_fragment_program

10673

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

10674

{

10675

ret = GLEW_NV_fragment_program;

10676

continue;

10677

}

10678

#endif

10679

#ifdef GL_NV_fragment_program2

10680

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))

10681

{

10682

ret = GLEW_NV_fragment_program2;

10683

continue;

10684

}

10685

#endif

10686

#ifdef GL_NV_fragment_program4

10687

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17))

10688

{

10689

ret = GLEW_NV_fragment_program4;

10690

continue;

10691

}

10692

#endif

10693

#ifdef GL_NV_fragment_program_option

10694

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))

10695

{

10696

ret = GLEW_NV_fragment_program_option;

10697

continue;

10698

}

10699

#endif

10700

#ifdef GL_NV_framebuffer_multisample_coverage

10701

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32))

10702

{

10703

ret = GLEW_NV_framebuffer_multisample_coverage;

10704

continue;

10705

}

10706

#endif

10707

#ifdef GL_NV_geometry_program4

10708

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17))

10709

{

10710

ret = GLEW_NV_geometry_program4;

10711

continue;

10712

}

10713

#endif

10714

#ifdef GL_NV_geometry_shader4

10715

if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))

10716

{

10717

ret = GLEW_NV_geometry_shader4;

10718

continue;

10719

}

10720

#endif

10721

#ifdef GL_NV_gpu_program4

10722

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12))

10723

{

10724

ret = GLEW_NV_gpu_program4;

10725

continue;

10726

}

10727

#endif

10728

#ifdef GL_NV_half_float

10729

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))

10730

{

10731

ret = GLEW_NV_half_float;

10732

continue;

10733

}

10734

#endif

10735

#ifdef GL_NV_light_max_exponent

10736

if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))

10737

{

10738

ret = GLEW_NV_light_max_exponent;

10739

continue;

10740

}

10741

#endif

10742

#ifdef GL_NV_multisample_filter_hint

10743

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))

10744

{

10745

ret = GLEW_NV_multisample_filter_hint;

10746

continue;

10747

}

10748

#endif

10749

#ifdef GL_NV_occlusion_query

10750

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

10751

{

10752

ret = GLEW_NV_occlusion_query;

10753

continue;

10754

}

10755

#endif

10756

#ifdef GL_NV_packed_depth_stencil

10757

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

10758

{

10759

ret = GLEW_NV_packed_depth_stencil;

10760

continue;

10761

}

10762

#endif

10763

#ifdef GL_NV_parameter_buffer_object

10764

if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23))

10765

{

10766

ret = GLEW_NV_parameter_buffer_object;

10767

continue;

10768

}

10769

#endif

10770

#ifdef GL_NV_pixel_data_range

10771

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))

10772

{

10773

ret = GLEW_NV_pixel_data_range;

10774

continue;

10775

}

10776

#endif

10777

#ifdef GL_NV_point_sprite

10778

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

10779

{

10780

ret = GLEW_NV_point_sprite;

10781

continue;

10782

}

10783

#endif

10784

#ifdef GL_NV_present_video

10785

if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))

10786

{

10787

ret = GLEW_NV_present_video;

10788

continue;

10789

}

10790

#endif

10791

#ifdef GL_NV_primitive_restart

10792

if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))

10793

{

10794

ret = GLEW_NV_primitive_restart;

10795

continue;

10796

}

10797

#endif

10798

#ifdef GL_NV_register_combiners

10799

if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))

10800

{

10801

ret = GLEW_NV_register_combiners;

10802

continue;

10803

}

10804

#endif

10805

#ifdef GL_NV_register_combiners2

10806

if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))

10807

{

10808

ret = GLEW_NV_register_combiners2;

10809

continue;

10810

}

10811

#endif

10812

#ifdef GL_NV_texgen_emboss

10813

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))

10814

{

10815

ret = GLEW_NV_texgen_emboss;

10816

continue;

10817

}

10818

#endif

10819

#ifdef GL_NV_texgen_reflection

10820

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))

10821

{

10822

ret = GLEW_NV_texgen_reflection;

10823

continue;

10824

}

10825

#endif

10826

#ifdef GL_NV_texture_compression_vtc

10827

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))

10828

{

10829

ret = GLEW_NV_texture_compression_vtc;

10830

continue;

10831

}

10832

#endif

10833

#ifdef GL_NV_texture_env_combine4

10834

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))

10835

{

10836

ret = GLEW_NV_texture_env_combine4;

10837

continue;

10838

}

10839

#endif

10840

#ifdef GL_NV_texture_expand_normal

10841

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))

10842

{

10843

ret = GLEW_NV_texture_expand_normal;

10844

continue;

10845

}

10846

#endif

10847

#ifdef GL_NV_texture_rectangle

10848

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

10849

{

10850

ret = GLEW_NV_texture_rectangle;

10851

continue;

10852

}

10853

#endif

10854

#ifdef GL_NV_texture_shader

10855

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))

10856

{

10857

ret = GLEW_NV_texture_shader;

10858

continue;

10859

}

10860

#endif

10861

#ifdef GL_NV_texture_shader2

10862

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))

10863

{

10864

ret = GLEW_NV_texture_shader2;

10865

continue;

10866

}

10867

#endif

10868

#ifdef GL_NV_texture_shader3

10869

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))

10870

{

10871

ret = GLEW_NV_texture_shader3;

10872

continue;

10873

}

10874

#endif

10875

#ifdef GL_NV_transform_feedback

10876

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))

10877

{

10878

ret = GLEW_NV_transform_feedback;

10879

continue;

10880

}

10881

#endif

10882

#ifdef GL_NV_vertex_array_range

10883

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

10884

{

10885

ret = GLEW_NV_vertex_array_range;

10886

continue;

10887

}

10888

#endif

10889

#ifdef GL_NV_vertex_array_range2

10890

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))

10891

{

10892

ret = GLEW_NV_vertex_array_range2;

10893

continue;

10894

}

10895

#endif

10896

#ifdef GL_NV_vertex_program

10897

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

10898

{

10899

ret = GLEW_NV_vertex_program;

10900

continue;

10901

}

10902

#endif

10903

#ifdef GL_NV_vertex_program1_1

10904

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))

10905

{

10906

ret = GLEW_NV_vertex_program1_1;

10907

continue;

10908

}

10909

#endif

10910

#ifdef GL_NV_vertex_program2

10911

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))

10912

{

10913

ret = GLEW_NV_vertex_program2;

10914

continue;

10915

}

10916

#endif

10917

#ifdef GL_NV_vertex_program2_option

10918

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))

10919

{

10920

ret = GLEW_NV_vertex_program2_option;

10921

continue;

10922

}

10923

#endif

10924

#ifdef GL_NV_vertex_program3

10925

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))

10926

{

10927

ret = GLEW_NV_vertex_program3;

10928

continue;

10929

}

10930

#endif

10931

#ifdef GL_NV_vertex_program4

10932

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15))

10933

{

10934

ret = GLEW_NV_vertex_program4;

10935

continue;

10936

}

10937

#endif

10938

}

10939

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4))

10940

{

10941

#ifdef GL_OES_byte_coordinates

10942

if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16))

10943

{

10944

ret = GLEW_OES_byte_coordinates;

10945

continue;

10946

}

10947

#endif

10948

#ifdef GL_OES_compressed_paletted_texture

10949

if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27))

10950

{

10951

ret = GLEW_OES_compressed_paletted_texture;

10952

continue;

10953

}

10954

#endif

10955

#ifdef GL_OES_read_format

10956

if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11))

10957

{

10958

ret = GLEW_OES_read_format;

10959

continue;

10960

}

10961

#endif

10962

#ifdef GL_OES_single_precision

10963

if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16))

10964

{

10965

ret = GLEW_OES_single_precision;

10966

continue;

10967

}

10968

#endif

10969

}

10970

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

10971

{

10972

#ifdef GL_OML_interlace

10973

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

10974

{

10975

ret = GLEW_OML_interlace;

10976

continue;

10977

}

10978

#endif

10979

#ifdef GL_OML_resample

10980

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

10981

{

10982

ret = GLEW_OML_resample;

10983

continue;

10984

}

10985

#endif

10986

#ifdef GL_OML_subsample

10987

if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))

10988

{

10989

ret = GLEW_OML_subsample;

10990

continue;

10991

}

10992

#endif

10993

}

10994

if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))

10995

{

10996

#ifdef GL_PGI_misc_hints

10997

if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))

10998

{

10999

ret = GLEW_PGI_misc_hints;

11000

continue;

11001

}

11002

#endif

11003

#ifdef GL_PGI_vertex_hints

11004

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))

11005

{

11006

ret = GLEW_PGI_vertex_hints;

11007

continue;

11008

}

11009

#endif

11010

}

11011

if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))

11012

{

11013

#ifdef GL_REND_screen_coordinates

11014

if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))

11015

{

11016

ret = GLEW_REND_screen_coordinates;

11017

continue;

11018

}

11019

#endif

11020

}

11021

if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))

11022

{

11023

#ifdef GL_S3_s3tc

11024

if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))

11025

{

11026

ret = GLEW_S3_s3tc;

11027

continue;

11028

}

11029

#endif

11030

}

11031

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

11032

{

11033

#ifdef GL_SGIS_color_range

11034

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

11035

{

11036

ret = GLEW_SGIS_color_range;

11037

continue;

11038

}

11039

#endif

11040

#ifdef GL_SGIS_detail_texture

11041

if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))

11042

{

11043

ret = GLEW_SGIS_detail_texture;

11044

continue;

11045

}

11046

#endif

11047

#ifdef GL_SGIS_fog_function

11048

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))

11049

{

11050

ret = GLEW_SGIS_fog_function;

11051

continue;

11052

}

11053

#endif

11054

#ifdef GL_SGIS_generate_mipmap

11055

if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))

11056

{

11057

ret = GLEW_SGIS_generate_mipmap;

11058

continue;

11059

}

11060

#endif

11061

#ifdef GL_SGIS_multisample

11062

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

11063

{

11064

ret = GLEW_SGIS_multisample;

11065

continue;

11066

}

11067

#endif

11068

#ifdef GL_SGIS_pixel_texture

11069

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

11070

{

11071

ret = GLEW_SGIS_pixel_texture;

11072

continue;

11073

}

11074

#endif

11075

#ifdef GL_SGIS_point_line_texgen

11076

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17))

11077

{

11078

ret = GLEW_SGIS_point_line_texgen;

11079

continue;

11080

}

11081

#endif

11082

#ifdef GL_SGIS_sharpen_texture

11083

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))

11084

{

11085

ret = GLEW_SGIS_sharpen_texture;

11086

continue;

11087

}

11088

#endif

11089

#ifdef GL_SGIS_texture4D

11090

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))

11091

{

11092

ret = GLEW_SGIS_texture4D;

11093

continue;

11094

}

11095

#endif

11096

#ifdef GL_SGIS_texture_border_clamp

11097

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

11098

{

11099

ret = GLEW_SGIS_texture_border_clamp;

11100

continue;

11101

}

11102

#endif

11103

#ifdef GL_SGIS_texture_edge_clamp

11104

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

11105

{

11106

ret = GLEW_SGIS_texture_edge_clamp;

11107

continue;

11108

}

11109

#endif

11110

#ifdef GL_SGIS_texture_filter4

11111

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))

11112

{

11113

ret = GLEW_SGIS_texture_filter4;

11114

continue;

11115

}

11116

#endif

11117

#ifdef GL_SGIS_texture_lod

11118

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))

11119

{

11120

ret = GLEW_SGIS_texture_lod;

11121

continue;

11122

}

11123

#endif

11124

#ifdef GL_SGIS_texture_select

11125

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))

11126

{

11127

ret = GLEW_SGIS_texture_select;

11128

continue;

11129

}

11130

#endif

11131

}

11132

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

11133

{

11134

#ifdef GL_SGIX_async

11135

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))

11136

{

11137

ret = GLEW_SGIX_async;

11138

continue;

11139

}

11140

#endif

11141

#ifdef GL_SGIX_async_histogram

11142

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))

11143

{

11144

ret = GLEW_SGIX_async_histogram;

11145

continue;

11146

}

11147

#endif

11148

#ifdef GL_SGIX_async_pixel

11149

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))

11150

{

11151

ret = GLEW_SGIX_async_pixel;

11152

continue;

11153

}

11154

#endif

11155

#ifdef GL_SGIX_blend_alpha_minmax

11156

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))

11157

{

11158

ret = GLEW_SGIX_blend_alpha_minmax;

11159

continue;

11160

}

11161

#endif

11162

#ifdef GL_SGIX_clipmap

11163

if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))

11164

{

11165

ret = GLEW_SGIX_clipmap;

11166

continue;

11167

}

11168

#endif

11169

#ifdef GL_SGIX_convolution_accuracy

11170

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20))

11171

{

11172

ret = GLEW_SGIX_convolution_accuracy;

11173

continue;

11174

}

11175

#endif

11176

#ifdef GL_SGIX_depth_texture

11177

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

11178

{

11179

ret = GLEW_SGIX_depth_texture;

11180

continue;

11181

}

11182

#endif

11183

#ifdef GL_SGIX_flush_raster

11184

if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))

11185

{

11186

ret = GLEW_SGIX_flush_raster;

11187

continue;

11188

}

11189

#endif

11190

#ifdef GL_SGIX_fog_offset

11191

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))

11192

{

11193

ret = GLEW_SGIX_fog_offset;

11194

continue;

11195

}

11196

#endif

11197

#ifdef GL_SGIX_fog_texture

11198

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))

11199

{

11200

ret = GLEW_SGIX_fog_texture;

11201

continue;

11202

}

11203

#endif

11204

#ifdef GL_SGIX_fragment_specular_lighting

11205

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))

11206

{

11207

ret = GLEW_SGIX_fragment_specular_lighting;

11208

continue;

11209

}

11210

#endif

11211

#ifdef GL_SGIX_framezoom

11212

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))

11213

{

11214

ret = GLEW_SGIX_framezoom;

11215

continue;

11216

}

11217

#endif

11218

#ifdef GL_SGIX_interlace

11219

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

11220

{

11221

ret = GLEW_SGIX_interlace;

11222

continue;

11223

}

11224

#endif

11225

#ifdef GL_SGIX_ir_instrument1

11226

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))

11227

{

11228

ret = GLEW_SGIX_ir_instrument1;

11229

continue;

11230

}

11231

#endif

11232

#ifdef GL_SGIX_list_priority

11233

if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))

11234

{

11235

ret = GLEW_SGIX_list_priority;

11236

continue;

11237

}

11238

#endif

11239

#ifdef GL_SGIX_pixel_texture

11240

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

11241

{

11242

ret = GLEW_SGIX_pixel_texture;

11243

continue;

11244

}

11245

#endif

11246

#ifdef GL_SGIX_pixel_texture_bits

11247

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))

11248

{

11249

ret = GLEW_SGIX_pixel_texture_bits;

11250

continue;

11251

}

11252

#endif

11253

#ifdef GL_SGIX_reference_plane

11254

if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))

11255

{

11256

ret = GLEW_SGIX_reference_plane;

11257

continue;

11258

}

11259

#endif

11260

#ifdef GL_SGIX_resample

11261

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

11262

{

11263

ret = GLEW_SGIX_resample;

11264

continue;

11265

}

11266

#endif

11267

#ifdef GL_SGIX_shadow

11268

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

11269

{

11270

ret = GLEW_SGIX_shadow;

11271

continue;

11272

}

11273

#endif

11274

#ifdef GL_SGIX_shadow_ambient

11275

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

11276

{

11277

ret = GLEW_SGIX_shadow_ambient;

11278

continue;

11279

}

11280

#endif

11281

#ifdef GL_SGIX_sprite

11282

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))

11283

{

11284

ret = GLEW_SGIX_sprite;

11285

continue;

11286

}

11287

#endif

11288

#ifdef GL_SGIX_tag_sample_buffer

11289

if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))

11290

{

11291

ret = GLEW_SGIX_tag_sample_buffer;

11292

continue;

11293

}

11294

#endif

11295

#ifdef GL_SGIX_texture_add_env

11296

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))

11297

{

11298

ret = GLEW_SGIX_texture_add_env;

11299

continue;

11300

}

11301

#endif

11302

#ifdef GL_SGIX_texture_coordinate_clamp

11303

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))

11304

{

11305

ret = GLEW_SGIX_texture_coordinate_clamp;

11306

continue;

11307

}

11308

#endif

11309

#ifdef GL_SGIX_texture_lod_bias

11310

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

11311

{

11312

ret = GLEW_SGIX_texture_lod_bias;

11313

continue;

11314

}

11315

#endif

11316

#ifdef GL_SGIX_texture_multi_buffer

11317

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))

11318

{

11319

ret = GLEW_SGIX_texture_multi_buffer;

11320

continue;

11321

}

11322

#endif

11323

#ifdef GL_SGIX_texture_range

11324

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

11325

{

11326

ret = GLEW_SGIX_texture_range;

11327

continue;

11328

}

11329

#endif

11330

#ifdef GL_SGIX_texture_scale_bias

11331

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))

11332

{

11333

ret = GLEW_SGIX_texture_scale_bias;

11334

continue;

11335

}

11336

#endif

11337

#ifdef GL_SGIX_vertex_preclip

11338

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))

11339

{

11340

ret = GLEW_SGIX_vertex_preclip;

11341

continue;

11342

}

11343

#endif

11344

#ifdef GL_SGIX_vertex_preclip_hint

11345

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))

11346

{

11347

ret = GLEW_SGIX_vertex_preclip_hint;

11348

continue;

11349

}

11350

#endif

11351

#ifdef GL_SGIX_ycrcb

11352

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))

11353

{

11354

ret = GLEW_SGIX_ycrcb;

11355

continue;

11356

}

11357

#endif

11358

}

11359

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

11360

{

11361

#ifdef GL_SGI_color_matrix

11362

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))

11363

{

11364

ret = GLEW_SGI_color_matrix;

11365

continue;

11366

}

11367

#endif

11368

#ifdef GL_SGI_color_table

11369

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))

11370

{

11371

ret = GLEW_SGI_color_table;

11372

continue;

11373

}

11374

#endif

11375

#ifdef GL_SGI_texture_color_table

11376

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))

11377

{

11378

ret = GLEW_SGI_texture_color_table;

11379

continue;

11380

}

11381

#endif

11382

}

11383

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))

11384

{

11385

#ifdef GL_SUNX_constant_data

11386

if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))

11387

{

11388

ret = GLEW_SUNX_constant_data;

11389

continue;

11390

}

11391

#endif

11392

}

11393

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

11394

{

11395

#ifdef GL_SUN_convolution_border_modes

11396

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

11397

{

11398

ret = GLEW_SUN_convolution_border_modes;

11399

continue;

11400

}

11401

#endif

11402

#ifdef GL_SUN_global_alpha

11403

if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))

11404

{

11405

ret = GLEW_SUN_global_alpha;

11406

continue;

11407

}

11408

#endif

11409

#ifdef GL_SUN_mesh_array

11410

if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))

11411

{

11412

ret = GLEW_SUN_mesh_array;

11413

continue;

11414

}

11415

#endif

11416

#ifdef GL_SUN_read_video_pixels

11417

if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))

11418

{

11419

ret = GLEW_SUN_read_video_pixels;

11420

continue;

11421

}

11422

#endif

11423

#ifdef GL_SUN_slice_accum

11424

if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))

11425

{

11426

ret = GLEW_SUN_slice_accum;

11427

continue;

11428

}

11429

#endif

11430

#ifdef GL_SUN_triangle_list

11431

if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))

11432

{

11433

ret = GLEW_SUN_triangle_list;

11434

continue;

11435

}

11436

#endif

11437

#ifdef GL_SUN_vertex

11438

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))

11439

{

11440

ret = GLEW_SUN_vertex;

11441

continue;

11442

}

11443

#endif

11444

}

11445

if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))

11446

{

11447

#ifdef GL_WIN_phong_shading

11448

if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))

11449

{

11450

ret = GLEW_WIN_phong_shading;

11451

continue;

11452

}

11453

#endif

11454

#ifdef GL_WIN_specular_fog

11455

if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))

11456

{

11457

ret = GLEW_WIN_specular_fog;

11458

continue;

11459

}

11460

#endif

11461

#ifdef GL_WIN_swap_hint

11462

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))

11463

{

11464

ret = GLEW_WIN_swap_hint;

11465

continue;

11466

}

11467

#endif

11468

}

11469

}

11470

ret = (len == 0);

11471

}

11472

return ret;

11473

}

11474

11475

#if defined(_WIN32)

11476

11477

#if defined(GLEW_MX)

11478

GLboolean wglewContextIsSupported (WGLEWContext* ctx, const char* name)

11479

#else

11480

GLboolean wglewIsSupported (const char* name)

11481

#endif

11482

{

11483

GLubyte* pos = (GLubyte*)name;

11484

GLuint len = _glewStrLen(pos);

11485

GLboolean ret = GL_TRUE;

11486

while (ret && len > 0)

11487

{

11488

if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))

11489

{

11490

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

11491

{

11492

#ifdef WGL_3DFX_multisample

11493

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

11494

{

11495

ret = WGLEW_3DFX_multisample;

11496

continue;

11497

}

11498

#endif

11499

}

11500

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4))

11501

{

11502

#ifdef WGL_3DL_stereo_control

11503

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14))

11504

{

11505

ret = WGLEW_3DL_stereo_control;

11506

continue;

11507

}

11508

#endif

11509

}

11510

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

11511

{

11512

#ifdef WGL_ARB_buffer_region

11513

if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

11514

{

11515

ret = WGLEW_ARB_buffer_region;

11516

continue;

11517

}

11518

#endif

11519

#ifdef WGL_ARB_create_context

11520

if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))

11521

{

11522

ret = WGLEW_ARB_create_context;

11523

continue;

11524

}

11525

#endif

11526

#ifdef WGL_ARB_extensions_string

11527

if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

11528

{

11529

ret = WGLEW_ARB_extensions_string;

11530

continue;

11531

}

11532

#endif

11533

#ifdef WGL_ARB_framebuffer_sRGB

11534

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

11535

{

11536

ret = WGLEW_ARB_framebuffer_sRGB;

11537

continue;

11538

}

11539

#endif

11540

#ifdef WGL_ARB_make_current_read

11541

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

11542

{

11543

ret = WGLEW_ARB_make_current_read;

11544

continue;

11545

}

11546

#endif

11547

#ifdef WGL_ARB_multisample

11548

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

11549

{

11550

ret = WGLEW_ARB_multisample;

11551

continue;

11552

}

11553

#endif

11554

#ifdef WGL_ARB_pbuffer

11555

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

11556

{

11557

ret = WGLEW_ARB_pbuffer;

11558

continue;

11559

}

11560

#endif

11561

#ifdef WGL_ARB_pixel_format

11562

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

11563

{

11564

ret = WGLEW_ARB_pixel_format;

11565

continue;

11566

}

11567

#endif

11568

#ifdef WGL_ARB_pixel_format_float

11569

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

11570

{

11571

ret = WGLEW_ARB_pixel_format_float;

11572

continue;

11573

}

11574

#endif

11575

#ifdef WGL_ARB_render_texture

11576

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

11577

{

11578

ret = WGLEW_ARB_render_texture;

11579

continue;

11580

}

11581

#endif

11582

}

11583

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

11584

{

11585

#ifdef WGL_ATI_pixel_format_float

11586

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

11587

{

11588

ret = WGLEW_ATI_pixel_format_float;

11589

continue;

11590

}

11591

#endif

11592

#ifdef WGL_ATI_render_texture_rectangle

11593

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

11594

{

11595

ret = WGLEW_ATI_render_texture_rectangle;

11596

continue;

11597

}

11598

#endif

11599

}

11600

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

11601

{

11602

#ifdef WGL_EXT_depth_float

11603

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))

11604

{

11605

ret = WGLEW_EXT_depth_float;

11606

continue;

11607

}

11608

#endif

11609

#ifdef WGL_EXT_display_color_table

11610

if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))

11611

{

11612

ret = WGLEW_EXT_display_color_table;

11613

continue;

11614

}

11615

#endif

11616

#ifdef WGL_EXT_extensions_string

11617

if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

11618

{

11619

ret = WGLEW_EXT_extensions_string;

11620

continue;

11621

}

11622

#endif

11623

#ifdef WGL_EXT_framebuffer_sRGB

11624

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

11625

{

11626

ret = WGLEW_EXT_framebuffer_sRGB;

11627

continue;

11628

}

11629

#endif

11630

#ifdef WGL_EXT_make_current_read

11631

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

11632

{

11633

ret = WGLEW_EXT_make_current_read;

11634

continue;

11635

}

11636

#endif

11637

#ifdef WGL_EXT_multisample

11638

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

11639

{

11640

ret = WGLEW_EXT_multisample;

11641

continue;

11642

}

11643

#endif

11644

#ifdef WGL_EXT_pbuffer

11645

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

11646

{

11647

ret = WGLEW_EXT_pbuffer;

11648

continue;

11649

}

11650

#endif

11651

#ifdef WGL_EXT_pixel_format

11652

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

11653

{

11654

ret = WGLEW_EXT_pixel_format;

11655

continue;

11656

}

11657

#endif

11658

#ifdef WGL_EXT_pixel_format_packed_float

11659

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25))

11660

{

11661

ret = WGLEW_EXT_pixel_format_packed_float;

11662

continue;

11663

}

11664

#endif

11665

#ifdef WGL_EXT_swap_control

11666

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

11667

{

11668

ret = WGLEW_EXT_swap_control;

11669

continue;

11670

}

11671

#endif

11672

}

11673

if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))

11674

{

11675

#ifdef WGL_I3D_digital_video_control

11676

if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))

11677

{

11678

ret = WGLEW_I3D_digital_video_control;

11679

continue;

11680

}

11681

#endif

11682

#ifdef WGL_I3D_gamma

11683

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))

11684

{

11685

ret = WGLEW_I3D_gamma;

11686

continue;

11687

}

11688

#endif

11689

#ifdef WGL_I3D_genlock

11690

if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))

11691

{

11692

ret = WGLEW_I3D_genlock;

11693

continue;

11694

}

11695

#endif

11696

#ifdef WGL_I3D_image_buffer

11697

if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))

11698

{

11699

ret = WGLEW_I3D_image_buffer;

11700

continue;

11701

}

11702

#endif

11703

#ifdef WGL_I3D_swap_frame_lock

11704

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))

11705

{

11706

ret = WGLEW_I3D_swap_frame_lock;

11707

continue;

11708

}

11709

#endif

11710

#ifdef WGL_I3D_swap_frame_usage

11711

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))

11712

{

11713

ret = WGLEW_I3D_swap_frame_usage;

11714

continue;

11715

}

11716

#endif

11717

}

11718

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

11719

{

11720

#ifdef WGL_NV_float_buffer

11721

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

11722

{

11723

ret = WGLEW_NV_float_buffer;

11724

continue;

11725

}

11726

#endif

11727

#ifdef WGL_NV_gpu_affinity

11728

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12))

11729

{

11730

ret = WGLEW_NV_gpu_affinity;

11731

continue;

11732

}

11733

#endif

11734

#ifdef WGL_NV_present_video

11735

if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))

11736

{

11737

ret = WGLEW_NV_present_video;

11738

continue;

11739

}

11740

#endif

11741

#ifdef WGL_NV_render_depth_texture

11742

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))

11743

{

11744

ret = WGLEW_NV_render_depth_texture;

11745

continue;

11746

}

11747

#endif

11748

#ifdef WGL_NV_render_texture_rectangle

11749

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

11750

{

11751

ret = WGLEW_NV_render_texture_rectangle;

11752

continue;

11753

}

11754

#endif

11755

#ifdef WGL_NV_swap_group

11756

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

11757

{

11758

ret = WGLEW_NV_swap_group;

11759

continue;

11760

}

11761

#endif

11762

#ifdef WGL_NV_vertex_array_range

11763

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

11764

{

11765

ret = WGLEW_NV_vertex_array_range;

11766

continue;

11767

}

11768

#endif

11769

#ifdef WGL_NV_video_output

11770

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))

11771

{

11772

ret = WGLEW_NV_video_output;

11773

continue;

11774

}

11775

#endif

11776

}

11777

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

11778

{

11779

#ifdef WGL_OML_sync_control

11780

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

11781

{

11782

ret = WGLEW_OML_sync_control;

11783

continue;

11784

}

11785

#endif

11786

}

11787

}

11788

ret = (len == 0);

11789

}

11790

return ret;

11791

}

11792

11793

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

11794

11795

#if defined(GLEW_MX)

11796

GLboolean glxewContextIsSupported (GLXEWContext* ctx, const char* name)

11797

#else

11798

GLboolean glxewIsSupported (const char* name)

11799

#endif

11800

{

11801

GLubyte* pos = (GLubyte*)name;

11802

GLuint len = _glewStrLen(pos);

11803

GLboolean ret = GL_TRUE;

11804

while (ret && len > 0)

11805

{

11806

if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))

11807

{

11808

if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

11809

{

11810

#ifdef GLX_VERSION_1_2

11811

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

11812

{

11813

ret = GLXEW_VERSION_1_2;

11814

continue;

11815

}

11816

#endif

11817

#ifdef GLX_VERSION_1_3

11818

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

11819

{

11820

ret = GLXEW_VERSION_1_3;

11821

continue;

11822

}

11823

#endif

11824

#ifdef GLX_VERSION_1_4

11825

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

11826

{

11827

ret = GLXEW_VERSION_1_4;

11828

continue;

11829

}

11830

#endif

11831

}

11832

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

11833

{

11834

#ifdef GLX_3DFX_multisample

11835

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

11836

{

11837

ret = GLXEW_3DFX_multisample;

11838

continue;

11839

}

11840

#endif

11841

}

11842

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

11843

{

11844

#ifdef GLX_ARB_create_context

11845

if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))

11846

{

11847

ret = GLXEW_ARB_create_context;

11848

continue;

11849

}

11850

#endif

11851

#ifdef GLX_ARB_fbconfig_float

11852

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))

11853

{

11854

ret = GLXEW_ARB_fbconfig_float;

11855

continue;

11856

}

11857

#endif

11858

#ifdef GLX_ARB_framebuffer_sRGB

11859

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

11860

{

11861

ret = GLXEW_ARB_framebuffer_sRGB;

11862

continue;

11863

}

11864

#endif

11865

#ifdef GLX_ARB_get_proc_address

11866

if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))

11867

{

11868

ret = GLXEW_ARB_get_proc_address;

11869

continue;

11870

}

11871

#endif

11872

#ifdef GLX_ARB_multisample

11873

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

11874

{

11875

ret = GLXEW_ARB_multisample;

11876

continue;

11877

}

11878

#endif

11879

}

11880

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

11881

{

11882

#ifdef GLX_ATI_pixel_format_float

11883

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

11884

{

11885

ret = GLXEW_ATI_pixel_format_float;

11886

continue;

11887

}

11888

#endif

11889

#ifdef GLX_ATI_render_texture

11890

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

11891

{

11892

ret = GLXEW_ATI_render_texture;

11893

continue;

11894

}

11895

#endif

11896

}

11897

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

11898

{

11899

#ifdef GLX_EXT_fbconfig_packed_float

11900

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21))

11901

{

11902

ret = GLXEW_EXT_fbconfig_packed_float;

11903

continue;

11904

}

11905

#endif

11906

#ifdef GLX_EXT_framebuffer_sRGB

11907

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))

11908

{

11909

ret = GLXEW_EXT_framebuffer_sRGB;

11910

continue;

11911

}

11912

#endif

11913

#ifdef GLX_EXT_import_context

11914

if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))

11915

{

11916

ret = GLXEW_EXT_import_context;

11917

continue;

11918

}

11919

#endif

11920

#ifdef GLX_EXT_scene_marker

11921

if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

11922

{

11923

ret = GLXEW_EXT_scene_marker;

11924

continue;

11925

}

11926

#endif

11927

#ifdef GLX_EXT_texture_from_pixmap

11928

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))

11929

{

11930

ret = GLXEW_EXT_texture_from_pixmap;

11931

continue;

11932

}

11933

#endif

11934

#ifdef GLX_EXT_visual_info

11935

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))

11936

{

11937

ret = GLXEW_EXT_visual_info;

11938

continue;

11939

}

11940

#endif

11941

#ifdef GLX_EXT_visual_rating

11942

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))

11943

{

11944

ret = GLXEW_EXT_visual_rating;

11945

continue;

11946

}

11947

#endif

11948

}

11949

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

11950

{

11951

#ifdef GLX_MESA_agp_offset

11952

if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))

11953

{

11954

ret = GLXEW_MESA_agp_offset;

11955

continue;

11956

}

11957

#endif

11958

#ifdef GLX_MESA_copy_sub_buffer

11959

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))

11960

{

11961

ret = GLXEW_MESA_copy_sub_buffer;

11962

continue;

11963

}

11964

#endif

11965

#ifdef GLX_MESA_pixmap_colormap

11966

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))

11967

{

11968

ret = GLXEW_MESA_pixmap_colormap;

11969

continue;

11970

}

11971

#endif

11972

#ifdef GLX_MESA_release_buffers

11973

if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))

11974

{

11975

ret = GLXEW_MESA_release_buffers;

11976

continue;

11977

}

11978

#endif

11979

#ifdef GLX_MESA_set_3dfx_mode

11980

if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))

11981

{

11982

ret = GLXEW_MESA_set_3dfx_mode;

11983

continue;

11984

}

11985

#endif

11986

}

11987

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

11988

{

11989

#ifdef GLX_NV_float_buffer

11990

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

11991

{

11992

ret = GLXEW_NV_float_buffer;

11993

continue;

11994

}

11995

#endif

11996

#ifdef GLX_NV_present_video

11997

if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))

11998

{

11999

ret = GLXEW_NV_present_video;

12000

continue;

12001

}

12002

#endif

12003

#ifdef GLX_NV_swap_group

12004

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

12005

{

12006

ret = GLXEW_NV_swap_group;

12007

continue;

12008

}

12009

#endif

12010

#ifdef GLX_NV_vertex_array_range

12011

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

12012

{

12013

ret = GLXEW_NV_vertex_array_range;

12014

continue;

12015

}

12016

#endif

12017

#ifdef GLX_NV_video_output

12018

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))

12019

{

12020

ret = GLXEW_NV_video_output;

12021

continue;

12022

}

12023

#endif

12024

}

12025

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

12026

{

12027

#ifdef GLX_OML_swap_method

12028

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))

12029

{

12030

ret = GLXEW_OML_swap_method;

12031

continue;

12032

}

12033

#endif

12034

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

12035

#include <inttypes.h>

12036

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

12037

{

12038

ret = GLXEW_OML_sync_control;

12039

continue;

12040

}

12041

#endif

12042

}

12043

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

12044

{

12045

#ifdef GLX_SGIS_blended_overlay

12046

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))

12047

{

12048

ret = GLXEW_SGIS_blended_overlay;

12049

continue;

12050

}

12051

#endif

12052

#ifdef GLX_SGIS_color_range

12053

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

12054

{

12055

ret = GLXEW_SGIS_color_range;

12056

continue;

12057

}

12058

#endif

12059

#ifdef GLX_SGIS_multisample

12060

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

12061

{

12062

ret = GLXEW_SGIS_multisample;

12063

continue;

12064

}

12065

#endif

12066

#ifdef GLX_SGIS_shared_multisample

12067

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))

12068

{

12069

ret = GLXEW_SGIS_shared_multisample;

12070

continue;

12071

}

12072

#endif

12073

}

12074

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

12075

{

12076

#ifdef GLX_SGIX_fbconfig

12077

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))

12078

{

12079

ret = GLXEW_SGIX_fbconfig;

12080

continue;

12081

}

12082

#endif

12083

#ifdef GLX_SGIX_hyperpipe

12084

if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9))

12085

{

12086

ret = GLXEW_SGIX_hyperpipe;

12087

continue;

12088

}

12089

#endif

12090

#ifdef GLX_SGIX_pbuffer

12091

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

12092

{

12093

ret = GLXEW_SGIX_pbuffer;

12094

continue;

12095

}

12096

#endif

12097

#ifdef GLX_SGIX_swap_barrier

12098

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))

12099

{

12100

ret = GLXEW_SGIX_swap_barrier;

12101

continue;

12102

}

12103

#endif

12104

#ifdef GLX_SGIX_swap_group

12105

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

12106

{

12107

ret = GLXEW_SGIX_swap_group;

12108

continue;

12109

}

12110

#endif

12111

#ifdef GLX_SGIX_video_resize

12112

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

12113

{

12114

ret = GLXEW_SGIX_video_resize;

12115

continue;

12116

}

12117

#endif

12118

#ifdef GLX_SGIX_visual_select_group

12119

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))

12120

{

12121

ret = GLXEW_SGIX_visual_select_group;

12122

continue;

12123

}

12124

#endif

12125

}

12126

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

12127

{

12128

#ifdef GLX_SGI_cushion

12129

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))

12130

{

12131

ret = GLXEW_SGI_cushion;

12132

continue;

12133

}

12134

#endif

12135

#ifdef GLX_SGI_make_current_read

12136

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

12137

{

12138

ret = GLXEW_SGI_make_current_read;

12139

continue;

12140

}

12141

#endif

12142

#ifdef GLX_SGI_swap_control

12143

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

12144

{

12145

ret = GLXEW_SGI_swap_control;

12146

continue;

12147

}

12148

#endif

12149

#ifdef GLX_SGI_video_sync

12150

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))

12151

{

12152

ret = GLXEW_SGI_video_sync;

12153

continue;

12154

}

12155

#endif

12156

}

12157

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

12158

{

12159

#ifdef GLX_SUN_get_transparent_index

12160

if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))

12161

{

12162

ret = GLXEW_SUN_get_transparent_index;

12163

continue;

12164

}

12165

#endif

12166

#ifdef GLX_SUN_video_resize

12167

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

12168

{

12169

ret = GLXEW_SUN_video_resize;

12170

continue;

12171

}

12172

#endif

12173

}

12174

}

12175

ret = (len == 0);

12176

}

12177

return ret;

12178

}

12179

12180

#endif /* _WIN32 */