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

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

NSSymbol symbol;

76

char* symbolName;

77

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

78

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

79

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

80

symbolName[0] = '_';

81

symbol = NULL;

82

if (NSIsSymbolNameDefined(symbolName))

83

symbol = NSLookupAndBindSymbol(symbolName);

84

free(symbolName);

85

return symbol ? NSAddressOfSymbol(symbol) : NULL;

86

}

87

#endif /* __APPLE__ */

88

89

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

90

#include <dlfcn.h>

91

#include <stdio.h>

92

#include <stdlib.h>

93

94

void* dlGetProcAddress (const GLubyte* name)

95

{

96

static void* h = NULL;

97

static void* gpa;

98

99

if (h == NULL)

100

{

101

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

102

gpa = dlsym(h, "glXGetProcAddress");

103

}

104

105

if (gpa != NULL)

106

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

107

else

108

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

109

}

110

#endif /* __sgi || __sun */

111

112

/*

113

* Define glewGetProcAddress.

114

*/

115

#if defined(_WIN32)

116

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

117

#else

118

# if defined(__APPLE__)

119

# define glewGetProcAddress(name) NSGLGetProcAddress(name)

120

# else

121

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

122

# define glewGetProcAddress(name) dlGetProcAddress(name)

123

# else /* __linux */

124

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

125

# endif

126

# endif

127

#endif

128

129

/*

130

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

131

* These functions implement the functionality required in this file.

132

*/

133

134

static GLuint _glewStrLen (const GLubyte* s)

135

{

136

GLuint i=0;

137

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

138

return i;

139

}

140

141

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

142

{

143

GLuint i=0;

144

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

145

return i;

146

}

147

148

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

149

{

150

GLuint i=0;

151

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

152

return i == n ? GL_TRUE : GL_FALSE;

153

}

154

155

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

156

{

157

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

158

{

159

(*a)++;

160

(*na)--;

161

}

162

if(*na >= nb)

163

{

164

GLuint i=0;

165

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

166

if(i == nb)

167

{

168

*a = *a + nb;

169

*na = *na - nb;

170

return GL_TRUE;

171

}

172

}

173

return GL_FALSE;

174

}

175

176

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

177

{

178

if(*na >= nb)

179

{

180

GLuint i=0;

181

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

182

if(i == nb)

183

{

184

*a = *a + nb;

185

*na = *na - nb;

186

return GL_TRUE;

187

}

188

}

189

return GL_FALSE;

190

}

191

192

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

193

{

194

if(*na >= nb)

195

{

196

GLuint i=0;

197

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

198

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

199

{

200

*a = *a + nb;

201

*na = *na - nb;

202

return GL_TRUE;

203

}

204

}

205

return GL_FALSE;

206

}

207

208

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

209

210

PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;

211

PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;

212

PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;

213

PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;

214

215

PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;

216

PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;

217

PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;

218

PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;

219

PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;

220

PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;

221

PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;

222

PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;

223

PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;

224

PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;

225

PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;

226

PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;

227

PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;

228

PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;

229

PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;

230

PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;

231

PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;

232

PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;

233

PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;

234

PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;

235

PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;

236

PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;

237

PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;

238

PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;

239

PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;

240

PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;

241

PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;

242

PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;

243

PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;

244

PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;

245

PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;

246

PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;

247

PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;

248

PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;

249

PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;

250

PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;

251

PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;

252

PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;

253

PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;

254

PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;

255

PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;

256

PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;

257

PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;

258

PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;

259

PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;

260

PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;

261

262

PFNGLBLENDCOLORPROC __glewBlendColor = NULL;

263

PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;

264

PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;

265

PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;

266

PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;

267

PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;

268

PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;

269

PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;

270

PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;

271

PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;

272

PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;

273

PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;

274

PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;

275

PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;

276

PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;

277

PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;

278

PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;

279

PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;

280

PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;

281

PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;

282

PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;

283

PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;

284

PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;

285

PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;

286

PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;

287

PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;

288

PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;

289

PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;

290

PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;

291

PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;

292

PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;

293

PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;

294

PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;

295

PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;

296

PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;

297

PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;

298

PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;

299

PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;

300

PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;

301

PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;

302

PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;

303

PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;

304

PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;

305

PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;

306

PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;

307

308

PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;

309

PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;

310

PFNGLBUFFERDATAPROC __glewBufferData = NULL;

311

PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;

312

PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;

313

PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;

314

PFNGLENDQUERYPROC __glewEndQuery = NULL;

315

PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;

316

PFNGLGENQUERIESPROC __glewGenQueries = NULL;

317

PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;

318

PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;

319

PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;

320

PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;

321

PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;

322

PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;

323

PFNGLISBUFFERPROC __glewIsBuffer = NULL;

324

PFNGLISQUERYPROC __glewIsQuery = NULL;

325

PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;

326

PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;

327

328

PFNGLATTACHSHADERPROC __glewAttachShader = NULL;

329

PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;

330

PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;

331

PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;

332

PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;

333

PFNGLCREATESHADERPROC __glewCreateShader = NULL;

334

PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;

335

PFNGLDELETESHADERPROC __glewDeleteShader = NULL;

336

PFNGLDETACHSHADERPROC __glewDetachShader = NULL;

337

PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;

338

PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;

339

PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;

340

PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;

341

PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;

342

PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;

343

PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;

344

PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;

345

PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;

346

PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;

347

PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;

348

PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;

349

PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;

350

PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;

351

PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;

352

PFNGLISPROGRAMPROC __glewIsProgram = NULL;

353

PFNGLISSHADERPROC __glewIsShader = NULL;

354

PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;

355

PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;

356

PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;

357

PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;

358

PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;

359

PFNGLUNIFORM1FPROC __glewUniform1f = NULL;

360

PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;

361

PFNGLUNIFORM1IPROC __glewUniform1i = NULL;

362

PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;

363

PFNGLUNIFORM2FPROC __glewUniform2f = NULL;

364

PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;

365

PFNGLUNIFORM2IPROC __glewUniform2i = NULL;

366

PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;

367

PFNGLUNIFORM3FPROC __glewUniform3f = NULL;

368

PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;

369

PFNGLUNIFORM3IPROC __glewUniform3i = NULL;

370

PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;

371

PFNGLUNIFORM4FPROC __glewUniform4f = NULL;

372

PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;

373

PFNGLUNIFORM4IPROC __glewUniform4i = NULL;

374

PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;

375

PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;

376

PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;

377

PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;

378

PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;

379

PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;

380

PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;

381

PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;

382

PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;

383

PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;

384

PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;

385

PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;

386

PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;

387

PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;

388

PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;

389

PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;

390

PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;

391

PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;

392

PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;

393

PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;

394

PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;

395

PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;

396

PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;

397

PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;

398

PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;

399

PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;

400

PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;

401

PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;

402

PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;

403

PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;

404

PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;

405

PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;

406

PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;

407

PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;

408

PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;

409

PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;

410

PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;

411

PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;

412

PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;

413

PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;

414

PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;

415

PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;

416

PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;

417

418

PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;

419

420

PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;

421

PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;

422

PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;

423

PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;

424

PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;

425

426

PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;

427

PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;

428

PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;

429

PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;

430

PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;

431

PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;

432

PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;

433

PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;

434

435

PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;

436

PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;

437

438

PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;

439

PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;

440

PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;

441

PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;

442

443

PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;

444

PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;

445

PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;

446

447

PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;

448

449

PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;

450

451

PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;

452

PFNGLCOLORTABLEPROC __glewColorTable = NULL;

453

PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;

454

PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;

455

PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;

456

PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;

457

PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;

458

PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;

459

PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;

460

PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;

461

PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;

462

PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;

463

PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;

464

PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;

465

PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;

466

PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;

467

PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;

468

PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;

469

PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;

470

PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;

471

PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;

472

PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;

473

PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;

474

PFNGLGETMINMAXPROC __glewGetMinmax = NULL;

475

PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;

476

PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;

477

PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;

478

PFNGLHISTOGRAMPROC __glewHistogram = NULL;

479

PFNGLMINMAXPROC __glewMinmax = NULL;

480

PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;

481

PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;

482

PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;

483

484

PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;

485

PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;

486

PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;

487

PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;

488

PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;

489

490

PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;

491

492

PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;

493

PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;

494

PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;

495

PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;

496

PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;

497

PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;

498

PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;

499

PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;

500

PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;

501

PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;

502

PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;

503

PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;

504

PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;

505

PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;

506

PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;

507

PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;

508

PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;

509

PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;

510

PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;

511

PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;

512

PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;

513

PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;

514

PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;

515

PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;

516

PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;

517

PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;

518

PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;

519

PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;

520

PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;

521

PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;

522

PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;

523

PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;

524

PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;

525

PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;

526

527

PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;

528

PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;

529

PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;

530

PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;

531

PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;

532

PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;

533

PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;

534

PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;

535

536

PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;

537

PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;

538

539

PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;

540

PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;

541

PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;

542

PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;

543

PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;

544

PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;

545

PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;

546

PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;

547

PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;

548

PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;

549

PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;

550

PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;

551

PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;

552

PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;

553

PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;

554

PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;

555

PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;

556

PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;

557

PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;

558

PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;

559

PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;

560

PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;

561

PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;

562

PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;

563

PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;

564

PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;

565

PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;

566

PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;

567

PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;

568

PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;

569

PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;

570

PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;

571

PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;

572

PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;

573

PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;

574

PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;

575

PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;

576

PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;

577

PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;

578

579

PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;

580

PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;

581

PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;

582

PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;

583

PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;

584

PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;

585

PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;

586

587

PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;

588

PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;

589

PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;

590

PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;

591

PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;

592

PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;

593

PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;

594

PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;

595

PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;

596

PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;

597

598

PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;

599

PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;

600

PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;

601

PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;

602

PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;

603

PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;

604

PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;

605

PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;

606

PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;

607

PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;

608

PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;

609

610

PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;

611

PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;

612

PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;

613

PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;

614

PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;

615

PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;

616

PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;

617

PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;

618

PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;

619

PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;

620

PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;

621

PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;

622

PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;

623

PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;

624

PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;

625

PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;

626

PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;

627

PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;

628

PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;

629

PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;

630

PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;

631

PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;

632

PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;

633

PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;

634

PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;

635

PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;

636

PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;

637

PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;

638

PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;

639

PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;

640

PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;

641

PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;

642

PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;

643

PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;

644

PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;

645

PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;

646

PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;

647

PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;

648

PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;

649

PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;

650

PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;

651

PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;

652

PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;

653

PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;

654

PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;

655

PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;

656

PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;

657

PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;

658

PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;

659

PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;

660

PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;

661

PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;

662

PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;

663

PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;

664

PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;

665

PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;

666

PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;

667

PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;

668

PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;

669

PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;

670

PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;

671

PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;

672

673

PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;

674

PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;

675

PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;

676

677

PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;

678

PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;

679

PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;

680

PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;

681

PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;

682

PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;

683

PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;

684

PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;

685

PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;

686

PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;

687

PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;

688

PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;

689

PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;

690

PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;

691

PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;

692

PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;

693

694

PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;

695

696

PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;

697

PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;

698

PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;

699

700

PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;

701

PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;

702

PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;

703

PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;

704

705

PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;

706

PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;

707

PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;

708

PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;

709

PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;

710

PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;

711

PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;

712

PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;

713

PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;

714

PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;

715

PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;

716

PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;

717

PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;

718

PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;

719

720

PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;

721

PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;

722

723

PFNGLPNTRIANGLESFATIPROC __glPNTrianglewesfATI = NULL;

724

PFNGLPNTRIANGLESIATIPROC __glPNTrianglewesiATI = NULL;

725

726

PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;

727

PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;

728

729

PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;

730

PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;

731

PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;

732

PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;

733

PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;

734

PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;

735

PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;

736

PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;

737

PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;

738

PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;

739

PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;

740

PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;

741

742

PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;

743

PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;

744

PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;

745

746

PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;

747

PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;

748

PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;

749

PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;

750

PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;

751

PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;

752

PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;

753

PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;

754

PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;

755

PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;

756

PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;

757

PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;

758

PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;

759

PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;

760

PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;

761

PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;

762

PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;

763

PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;

764

PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;

765

PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;

766

PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;

767

PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;

768

PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;

769

PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;

770

PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;

771

PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;

772

PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;

773

PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;

774

PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;

775

PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;

776

PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;

777

PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;

778

PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;

779

PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;

780

PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;

781

PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;

782

PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;

783

784

PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;

785

786

PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;

787

788

PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;

789

790

PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;

791

792

PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;

793

PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;

794

795

PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;

796

PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;

797

798

PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;

799

PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;

800

PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;

801

PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;

802

PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;

803

PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;

804

PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;

805

PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;

806

PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;

807

PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;

808

PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;

809

PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;

810

PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;

811

812

PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;

813

PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;

814

815

PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;

816

PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;

817

PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;

818

PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;

819

PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;

820

821

PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;

822

PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;

823

824

PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;

825

826

PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;

827

828

PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;

829

PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;

830

PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;

831

PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;

832

PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;

833

834

PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;

835

PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;

836

PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;

837

PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;

838

PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;

839

PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;

840

PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;

841

PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;

842

PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;

843

PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;

844

PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;

845

PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;

846

PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;

847

PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;

848

PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;

849

PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;

850

PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;

851

PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;

852

853

PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;

854

PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;

855

PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;

856

PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;

857

PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;

858

PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFrameBufferTexture1DEXT = NULL;

859

PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;

860

PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;

861

PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;

862

PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;

863

PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;

864

PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;

865

PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;

866

PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;

867

PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;

868

PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;

869

PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;

870

871

PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;

872

PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;

873

PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;

874

PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;

875

PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;

876

PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;

877

PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;

878

PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;

879

PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;

880

PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;

881

882

PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;

883

884

PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;

885

886

PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;

887

PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;

888

PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;

889

890

PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;

891

PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;

892

893

PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;

894

PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;

895

896

PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;

897

PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;

898

PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;

899

PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;

900

901

PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;

902

PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;

903

PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;

904

PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;

905

PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;

906

PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;

907

908

PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;

909

PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;

910

911

PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;

912

913

PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;

914

PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;

915

916

PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;

917

PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;

918

PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;

919

PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;

920

PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;

921

PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;

922

PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;

923

PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;

924

PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;

925

PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;

926

PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;

927

PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;

928

PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;

929

PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;

930

PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;

931

PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;

932

PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;

933

934

PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;

935

936

PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;

937

PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;

938

PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;

939

940

PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;

941

942

PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;

943

PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;

944

PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;

945

PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;

946

PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;

947

PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;

948

949

PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;

950

951

PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;

952

PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;

953

PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;

954

PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;

955

PFNGLGETPOINTERVEXTPROC __glewGetPointervEXT = NULL;

956

PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;

957

PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;

958

PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;

959

PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;

960

961

PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;

962

PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;

963

PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;

964

PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;

965

PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;

966

PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;

967

PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;

968

PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;

969

PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;

970

PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;

971

PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;

972

PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;

973

PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;

974

PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;

975

PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;

976

PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;

977

PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;

978

PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;

979

PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;

980

PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;

981

PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;

982

PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;

983

PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;

984

PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;

985

PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;

986

PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;

987

PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;

988

PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;

989

PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;

990

PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;

991

PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;

992

PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;

993

PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;

994

PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;

995

PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;

996

PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;

997

PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;

998

PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;

999

PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;

1000

PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;

1001

PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;

1002

PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;

1003

1004

PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;

1005

PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;

1006

PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;

1007

1008

PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;

1009

PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;

1010

PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;

1011

PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;

1012

PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;

1013

PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;

1014

1015

PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;

1016

PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;

1017

1018

PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;

1019

PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;

1020

PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;

1021

PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;

1022

PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;

1023

PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;

1024

PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;

1025

PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;

1026

1027

PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;

1028

PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;

1029

PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;

1030

PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;

1031

1032

PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;

1033

PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;

1034

1035

PFNGLBUFFERREGIONENABLEDEXTPROC __glewBufferRegionEnabledEXT = NULL;

1036

PFNGLDELETEBUFFERREGIONEXTPROC __glewDeleteBufferRegionEXT = NULL;

1037

PFNGLDRAWBUFFERREGIONEXTPROC __glewDrawBufferRegionEXT = NULL;

1038

PFNGLNEWBUFFERREGIONEXTPROC __glewNewBufferRegionEXT = NULL;

1039

PFNGLREADBUFFERREGIONEXTPROC __glewReadBufferRegionEXT = NULL;

1040

1041

PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;

1042

1043

PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;

1044

PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;

1045

PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;

1046

PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;

1047

PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;

1048

PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;

1049

PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;

1050

PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;

1051

PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;

1052

PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;

1053

PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;

1054

PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;

1055

PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;

1056

PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;

1057

PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;

1058

PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;

1059

PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;

1060

PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;

1061

PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;

1062

PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;

1063

PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;

1064

PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;

1065

PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;

1066

PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;

1067

1068

PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;

1069

PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;

1070

PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;

1071

PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;

1072

PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;

1073

PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;

1074

PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;

1075

PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;

1076

PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;

1077

1078

PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;

1079

PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;

1080

PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;

1081

PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;

1082

PFNGLISFENCENVPROC __glewIsFenceNV = NULL;

1083

PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;

1084

PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;

1085

1086

PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;

1087

PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;

1088

PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;

1089

PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;

1090

PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;

1091

PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;

1092

1093

PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;

1094

PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;

1095

PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;

1096

PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;

1097

PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;

1098

PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;

1099

PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;

1100

PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;

1101

PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;

1102

PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;

1103

PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;

1104

PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;

1105

PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;

1106

PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;

1107

PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;

1108

PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;

1109

PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;

1110

PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;

1111

PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;

1112

PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;

1113

PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;

1114

PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;

1115

PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;

1116

PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;

1117

PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;

1118

PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;

1119

PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;

1120

PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;

1121

PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;

1122

PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;

1123

PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;

1124

PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;

1125

PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;

1126

PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;

1127

PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;

1128

PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;

1129

PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;

1130

PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;

1131

PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;

1132

PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;

1133

PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;

1134

PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;

1135

PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;

1136

PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;

1137

PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;

1138

PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;

1139

1140

PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;

1141

PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;

1142

PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;

1143

PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;

1144

PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;

1145

PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;

1146

PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;

1147

1148

PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;

1149

PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;

1150

1151

PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;

1152

PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;

1153

1154

PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;

1155

PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;

1156

1157

PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;

1158

PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;

1159

PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;

1160

PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;

1161

PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;

1162

PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;

1163

PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;

1164

PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;

1165

PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;

1166

PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;

1167

PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;

1168

PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;

1169

PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;

1170

1171

PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;

1172

PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;

1173

1174

PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;

1175

PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;

1176

1177

PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;

1178

PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;

1179

PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;

1180

PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;

1181

PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;

1182

PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;

1183

PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;

1184

PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;

1185

PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;

1186

PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;

1187

PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;

1188

PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;

1189

PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;

1190

PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;

1191

PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;

1192

PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;

1193

PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;

1194

PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;

1195

PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;

1196

PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;

1197

PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;

1198

PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;

1199

PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;

1200

PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;

1201

PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;

1202

PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;

1203

PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;

1204

PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;

1205

PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;

1206

PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;

1207

PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;

1208

PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;

1209

PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;

1210

PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;

1211

PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;

1212

PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;

1213

PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;

1214

PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;

1215

PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;

1216

PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;

1217

PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;

1218

PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;

1219

PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;

1220

PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;

1221

PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;

1222

PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;

1223

PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;

1224

PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;

1225

PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;

1226

PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;

1227

PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;

1228

PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;

1229

PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;

1230

PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;

1231

PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;

1232

PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;

1233

PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;

1234

PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;

1235

PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;

1236

PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;

1237

PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;

1238

PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;

1239

PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;

1240

PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;

1241

1242

PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;

1243

PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;

1244

1245

PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;

1246

PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;

1247

1248

PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;

1249

PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;

1250

1251

PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;

1252

PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;

1253

1254

PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;

1255

PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;

1256

1257

PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;

1258

PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;

1259

1260

PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;

1261

PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;

1262

PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;

1263

PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;

1264

PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;

1265

PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;

1266

1267

PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;

1268

1269

PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;

1270

1271

PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;

1272

PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;

1273

PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;

1274

PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;

1275

PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;

1276

PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;

1277

PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;

1278

PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;

1279

PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;

1280

PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;

1281

PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;

1282

PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;

1283

PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;

1284

PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;

1285

PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;

1286

PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;

1287

PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;

1288

1289

PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;

1290

1291

PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;

1292

1293

PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;

1294

1295

PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;

1296

PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;

1297

PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;

1298

PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;

1299

1300

PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;

1301

1302

PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;

1303

PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;

1304

PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;

1305

PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;

1306

PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;

1307

PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;

1308

PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;

1309

1310

PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;

1311

1312

PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;

1313

PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;

1314

PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;

1315

PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;

1316

PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;

1317

PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;

1318

PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;

1319

PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;

1320

1321

PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;

1322

1323

PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;

1324

PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;

1325

PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;

1326

PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;

1327

PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;

1328

PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;

1329

PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;

1330

1331

PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;

1332

PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;

1333

PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;

1334

PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;

1335

PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;

1336

PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;

1337

PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;

1338

PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;

1339

PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;

1340

PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;

1341

PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;

1342

PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;

1343

PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;

1344

PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;

1345

PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;

1346

PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;

1347

PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;

1348

PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;

1349

PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

1350

PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

1351

PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;

1352

PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;

1353

PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;

1354

PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;

1355

PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;

1356

PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;

1357

PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;

1358

PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;

1359

PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;

1360

PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;

1361

PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;

1362

PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;

1363

PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;

1364

PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;

1365

PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;

1366

PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;

1367

PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;

1368

PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;

1369

PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;

1370

PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;

1371

1372

PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;

1373

1374

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

1375

1376

#if !defined(GLEW_MX)

1377

1378

GLboolean __GLEW_VERSION_1_1 = GL_FALSE;

1379

GLboolean __GLEW_VERSION_1_2 = GL_FALSE;

1380

GLboolean __GLEW_VERSION_1_3 = GL_FALSE;

1381

GLboolean __GLEW_VERSION_1_4 = GL_FALSE;

1382

GLboolean __GLEW_VERSION_1_5 = GL_FALSE;

1383

GLboolean __GLEW_VERSION_2_0 = GL_FALSE;

1384

GLboolean __GLEW_3DFX_multisample = GL_FALSE;

1385

GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;

1386

GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;

1387

GLboolean __GLEW_APPLE_client_storage = GL_FALSE;

1388

GLboolean __GLEW_APPLE_element_array = GL_FALSE;

1389

GLboolean __GLEW_APPLE_fence = GL_FALSE;

1390

GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;

1391

GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;

1392

GLboolean __GLEW_APPLE_texture_range = GL_FALSE;

1393

GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;

1394

GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;

1395

GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;

1396

GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;

1397

GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;

1398

GLboolean __GLEW_ARB_depth_texture = GL_FALSE;

1399

GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;

1400

GLboolean __GLEW_ARB_fragment_program = GL_FALSE;

1401

GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;

1402

GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;

1403

GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;

1404

GLboolean __GLEW_ARB_imaging = GL_FALSE;

1405

GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;

1406

GLboolean __GLEW_ARB_multisample = GL_FALSE;

1407

GLboolean __GLEW_ARB_multitexture = GL_FALSE;

1408

GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;

1409

GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;

1410

GLboolean __GLEW_ARB_point_parameters = GL_FALSE;

1411

GLboolean __GLEW_ARB_point_sprite = GL_FALSE;

1412

GLboolean __GLEW_ARB_shader_objects = GL_FALSE;

1413

GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;

1414

GLboolean __GLEW_ARB_shadow = GL_FALSE;

1415

GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;

1416

GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;

1417

GLboolean __GLEW_ARB_texture_compression = GL_FALSE;

1418

GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;

1419

GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;

1420

GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;

1421

GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;

1422

GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;

1423

GLboolean __GLEW_ARB_texture_float = GL_FALSE;

1424

GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;

1425

GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;

1426

GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;

1427

GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;

1428

GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;

1429

GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;

1430

GLboolean __GLEW_ARB_vertex_program = GL_FALSE;

1431

GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;

1432

GLboolean __GLEW_ARB_window_pos = GL_FALSE;

1433

GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;

1434

GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;

1435

GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;

1436

GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;

1437

GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;

1438

GLboolean __GLEW_ATI_element_array = GL_FALSE;

1439

GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;

1440

GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;

1441

GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;

1442

GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;

1443

GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;

1444

GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;

1445

GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;

1446

GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;

1447

GLboolean __GLEW_ATI_texture_float = GL_FALSE;

1448

GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;

1449

GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;

1450

GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;

1451

GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;

1452

GLboolean __GLEW_EXT_422_pixels = GL_FALSE;

1453

GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;

1454

GLboolean __GLEW_EXT_abgr = GL_FALSE;

1455

GLboolean __GLEW_EXT_bgra = GL_FALSE;

1456

GLboolean __GLEW_EXT_blend_color = GL_FALSE;

1457

GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;

1458

GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;

1459

GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;

1460

GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;

1461

GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;

1462

GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;

1463

GLboolean __GLEW_EXT_cmyka = GL_FALSE;

1464

GLboolean __GLEW_EXT_color_subtable = GL_FALSE;

1465

GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;

1466

GLboolean __GLEW_EXT_convolution = GL_FALSE;

1467

GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;

1468

GLboolean __GLEW_EXT_copy_texture = GL_FALSE;

1469

GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;

1470

GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;

1471

GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;

1472

GLboolean __GLEW_EXT_fog_coord = GL_FALSE;

1473

GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;

1474

GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;

1475

GLboolean __GLEW_EXT_histogram = GL_FALSE;

1476

GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;

1477

GLboolean __GLEW_EXT_index_func = GL_FALSE;

1478

GLboolean __GLEW_EXT_index_material = GL_FALSE;

1479

GLboolean __GLEW_EXT_index_texture = GL_FALSE;

1480

GLboolean __GLEW_EXT_light_texture = GL_FALSE;

1481

GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;

1482

GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;

1483

GLboolean __GLEW_EXT_multisample = GL_FALSE;

1484

GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;

1485

GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;

1486

GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;

1487

GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;

1488

GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;

1489

GLboolean __GLEW_EXT_point_parameters = GL_FALSE;

1490

GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;

1491

GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;

1492

GLboolean __GLEW_EXT_scene_marker = GL_FALSE;

1493

GLboolean __GLEW_EXT_secondary_color = GL_FALSE;

1494

GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;

1495

GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;

1496

GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;

1497

GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;

1498

GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;

1499

GLboolean __GLEW_EXT_subtexture = GL_FALSE;

1500

GLboolean __GLEW_EXT_texture = GL_FALSE;

1501

GLboolean __GLEW_EXT_texture3D = GL_FALSE;

1502

GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;

1503

GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;

1504

GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;

1505

GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;

1506

GLboolean __GLEW_EXT_texture_env = GL_FALSE;

1507

GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;

1508

GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;

1509

GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;

1510

GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;

1511

GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;

1512

GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;

1513

GLboolean __GLEW_EXT_texture_object = GL_FALSE;

1514

GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;

1515

GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;

1516

GLboolean __GLEW_EXT_vertex_array = GL_FALSE;

1517

GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;

1518

GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;

1519

GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;

1520

GLboolean __GLEW_HP_image_transform = GL_FALSE;

1521

GLboolean __GLEW_HP_occlusion_test = GL_FALSE;

1522

GLboolean __GLEW_HP_texture_lighting = GL_FALSE;

1523

GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;

1524

GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;

1525

GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;

1526

GLboolean __GLEW_IBM_static_data = GL_FALSE;

1527

GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;

1528

GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;

1529

GLboolean __GLEW_INGR_color_clamp = GL_FALSE;

1530

GLboolean __GLEW_INGR_interlace_read = GL_FALSE;

1531

GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;

1532

GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;

1533

GLboolean __GLEW_KTX_buffer_region = GL_FALSE;

1534

GLboolean __GLEW_MESA_pack_invert = GL_FALSE;

1535

GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;

1536

GLboolean __GLEW_MESA_window_pos = GL_FALSE;

1537

GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;

1538

GLboolean __GLEW_NV_blend_square = GL_FALSE;

1539

GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;

1540

GLboolean __GLEW_NV_depth_clamp = GL_FALSE;

1541

GLboolean __GLEW_NV_evaluators = GL_FALSE;

1542

GLboolean __GLEW_NV_fence = GL_FALSE;

1543

GLboolean __GLEW_NV_float_buffer = GL_FALSE;

1544

GLboolean __GLEW_NV_fog_distance = GL_FALSE;

1545

GLboolean __GLEW_NV_fragment_program = GL_FALSE;

1546

GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;

1547

GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;

1548

GLboolean __GLEW_NV_half_float = GL_FALSE;

1549

GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;

1550

GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;

1551

GLboolean __GLEW_NV_occlusion_query = GL_FALSE;

1552

GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;

1553

GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;

1554

GLboolean __GLEW_NV_point_sprite = GL_FALSE;

1555

GLboolean __GLEW_NV_primitive_restart = GL_FALSE;

1556

GLboolean __GLEW_NV_register_combiners = GL_FALSE;

1557

GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;

1558

GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;

1559

GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;

1560

GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;

1561

GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;

1562

GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;

1563

GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;

1564

GLboolean __GLEW_NV_texture_shader = GL_FALSE;

1565

GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;

1566

GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;

1567

GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;

1568

GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;

1569

GLboolean __GLEW_NV_vertex_program = GL_FALSE;

1570

GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;

1571

GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;

1572

GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;

1573

GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;

1574

GLboolean __GLEW_OML_interlace = GL_FALSE;

1575

GLboolean __GLEW_OML_resample = GL_FALSE;

1576

GLboolean __GLEW_OML_subsample = GL_FALSE;

1577

GLboolean __GLEW_PGI_misc_hints = GL_FALSE;

1578

GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;

1579

GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;

1580

GLboolean __GLEW_S3_s3tc = GL_FALSE;

1581

GLboolean __GLEW_SGIS_color_range = GL_FALSE;

1582

GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;

1583

GLboolean __GLEW_SGIS_fog_function = GL_FALSE;

1584

GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;

1585

GLboolean __GLEW_SGIS_multisample = GL_FALSE;

1586

GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;

1587

GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;

1588

GLboolean __GLEW_SGIS_texture4D = GL_FALSE;

1589

GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;

1590

GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;

1591

GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;

1592

GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;

1593

GLboolean __GLEW_SGIS_texture_select = GL_FALSE;

1594

GLboolean __GLEW_SGIX_async = GL_FALSE;

1595

GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;

1596

GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;

1597

GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;

1598

GLboolean __GLEW_SGIX_clipmap = GL_FALSE;

1599

GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;

1600

GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;

1601

GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;

1602

GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;

1603

GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;

1604

GLboolean __GLEW_SGIX_framezoom = GL_FALSE;

1605

GLboolean __GLEW_SGIX_interlace = GL_FALSE;

1606

GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;

1607

GLboolean __GLEW_SGIX_list_priority = GL_FALSE;

1608

GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;

1609

GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;

1610

GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;

1611

GLboolean __GLEW_SGIX_resample = GL_FALSE;

1612

GLboolean __GLEW_SGIX_shadow = GL_FALSE;

1613

GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;

1614

GLboolean __GLEW_SGIX_sprite = GL_FALSE;

1615

GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;

1616

GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;

1617

GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;

1618

GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;

1619

GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;

1620

GLboolean __GLEW_SGIX_texture_range = GL_FALSE;

1621

GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;

1622

GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;

1623

GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;

1624

GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;

1625

GLboolean __GLEW_SGI_color_matrix = GL_FALSE;

1626

GLboolean __GLEW_SGI_color_table = GL_FALSE;

1627

GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;

1628

GLboolean __GLEW_SUNX_constant_data = GL_FALSE;

1629

GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;

1630

GLboolean __GLEW_SUN_global_alpha = GL_FALSE;

1631

GLboolean __GLEW_SUN_mesh_array = GL_FALSE;

1632

GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;

1633

GLboolean __GLEW_SUN_slice_accum = GL_FALSE;

1634

GLboolean __GLEW_SUN_triangle_list = GL_FALSE;

1635

GLboolean __GLEW_SUN_vertex = GL_FALSE;

1636

GLboolean __GLEW_WIN_phong_shading = GL_FALSE;

1637

GLboolean __GLEW_WIN_specular_fog = GL_FALSE;

1638

GLboolean __GLEW_WIN_swap_hint = GL_FALSE;

1639

1640

#endif /* !GLEW_MX */

1641

1642

#ifdef GL_VERSION_1_2

1643

1644

static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)

1645

{

1646

GLboolean r = GL_FALSE;

1647

1648

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

1649

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

1650

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

1651

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

1652

1653

return r;

1654

}

1655

1656

#endif /* GL_VERSION_1_2 */

1657

1658

#ifdef GL_VERSION_1_3

1659

1660

static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)

1661

{

1662

GLboolean r = GL_FALSE;

1663

1664

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

1665

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

1666

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

1667

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

1668

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

1669

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

1670

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

1671

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

1672

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

1673

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

1674

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

1675

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

1676

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

1677

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

1678

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

1679

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

1680

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

1681

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

1682

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

1683

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

1684

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

1685

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

1686

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

1687

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

1688

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

1689

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

1690

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

1691

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

1692

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

1693

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

1694

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

1695

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

1696

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

1697

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

1698

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

1699

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

1700

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

1701

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

1702

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

1703

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

1704

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

1705

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

1706

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

1707

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

1708

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

1709

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

1710

1711

return r;

1712

}

1713

1714

#endif /* GL_VERSION_1_3 */

1715

1716

#ifdef GL_VERSION_1_4

1717

1718

static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)

1719

{

1720

GLboolean r = GL_FALSE;

1721

1722

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

1723

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

1724

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

1725

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

1726

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

1727

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

1728

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

1729

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

1730

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

1731

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

1732

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

1733

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

1734

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

1735

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

1736

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

1737

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

1738

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

1739

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

1740

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

1741

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

1742

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

1743

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

1744

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

1745

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

1746

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

1747

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

1748

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

1749

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

1750

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

1751

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

1752

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

1753

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

1754

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

1755

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

1756

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

1757

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

1758

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

1759

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

1760

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

1761

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

1762

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

1763

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

1764

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

1765

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

1766

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

1767

1768

return r;

1769

}

1770

1771

#endif /* GL_VERSION_1_4 */

1772

1773

#ifdef GL_VERSION_1_5

1774

1775

static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)

1776

{

1777

GLboolean r = GL_FALSE;

1778

1779

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

1780

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

1781

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

1782

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

1783

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

1784

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

1785

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

1786

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

1787

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

1788

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

1789

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

1790

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

1791

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

1792

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

1793

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

1794

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

1795

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

1796

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

1797

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

1798

1799

return r;

1800

}

1801

1802

#endif /* GL_VERSION_1_5 */

1803

1804

#ifdef GL_VERSION_2_0

1805

1806

static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)

1807

{

1808

GLboolean r = GL_FALSE;

1809

1810

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

1811

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

1812

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

1813

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

1814

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

1815

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

1816

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

1817

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

1818

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

1819

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

1820

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

1821

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

1822

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

1823

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

1824

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

1825

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

1826

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

1827

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

1828

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

1829

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

1830

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

1831

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

1832

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

1833

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

1834

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

1835

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

1836

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

1837

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

1838

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

1839

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

1840

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

1841

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

1842

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

1843

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

1844

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

1845

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

1846

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

1847

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

1848

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

1849

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

1850

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

1851

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

1852

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

1853

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

1854

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

1855

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

1856

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

1857

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

1858

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

1859

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

1860

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

1861

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

1862

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

1863

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

1864

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

1865

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

1866

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

1867

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

1868

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

1869

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

1870

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

1871

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

1872

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

1873

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

1874

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

1875

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

1876

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

1877

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

1878

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

1879

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

1880

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

1881

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

1882

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

1883

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

1884

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

1885

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

1886

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

1887

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

1888

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

1889

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

1890

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

1891

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

1892

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

1893

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

1894

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

1895

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

1896

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

1897

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

1898

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

1899

1900

return r;

1901

}

1902

1903

#endif /* GL_VERSION_2_0 */

1904

1905

#ifdef GL_3DFX_multisample

1906

1907

#endif /* GL_3DFX_multisample */

1908

1909

#ifdef GL_3DFX_tbuffer

1910

1911

static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)

1912

{

1913

GLboolean r = GL_FALSE;

1914

1915

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

1916

1917

return r;

1918

}

1919

1920

#endif /* GL_3DFX_tbuffer */

1921

1922

#ifdef GL_3DFX_texture_compression_FXT1

1923

1924

#endif /* GL_3DFX_texture_compression_FXT1 */

1925

1926

#ifdef GL_APPLE_client_storage

1927

1928

#endif /* GL_APPLE_client_storage */

1929

1930

#ifdef GL_APPLE_element_array

1931

1932

static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT)

1933

{

1934

GLboolean r = GL_FALSE;

1935

1936

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

1937

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

1938

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

1939

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

1940

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

1941

1942

return r;

1943

}

1944

1945

#endif /* GL_APPLE_element_array */

1946

1947

#ifdef GL_APPLE_fence

1948

1949

static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT)

1950

{

1951

GLboolean r = GL_FALSE;

1952

1953

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

1954

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

1955

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

1956

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

1957

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

1958

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

1959

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

1960

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

1961

1962

return r;

1963

}

1964

1965

#endif /* GL_APPLE_fence */

1966

1967

#ifdef GL_APPLE_float_pixels

1968

1969

#endif /* GL_APPLE_float_pixels */

1970

1971

#ifdef GL_APPLE_specular_vector

1972

1973

#endif /* GL_APPLE_specular_vector */

1974

1975

#ifdef GL_APPLE_texture_range

1976

1977

static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT)

1978

{

1979

GLboolean r = GL_FALSE;

1980

1981

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

1982

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

1983

1984

return r;

1985

}

1986

1987

#endif /* GL_APPLE_texture_range */

1988

1989

#ifdef GL_APPLE_transform_hint

1990

1991

#endif /* GL_APPLE_transform_hint */

1992

1993

#ifdef GL_APPLE_vertex_array_object

1994

1995

static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

1996

{

1997

GLboolean r = GL_FALSE;

1998

1999

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

2000

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

2001

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

2002

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

2003

2004

return r;

2005

}

2006

2007

#endif /* GL_APPLE_vertex_array_object */

2008

2009

#ifdef GL_APPLE_vertex_array_range

2010

2011

static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)

2012

{

2013

GLboolean r = GL_FALSE;

2014

2015

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

2016

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

2017

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

2018

2019

return r;

2020

}

2021

2022

#endif /* GL_APPLE_vertex_array_range */

2023

2024

#ifdef GL_APPLE_ycbcr_422

2025

2026

#endif /* GL_APPLE_ycbcr_422 */

2027

2028

#ifdef GL_ARB_color_buffer_float

2029

2030

static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)

2031

{

2032

GLboolean r = GL_FALSE;

2033

2034

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

2035

2036

return r;

2037

}

2038

2039

#endif /* GL_ARB_color_buffer_float */

2040

2041

#ifdef GL_ARB_depth_texture

2042

2043

#endif /* GL_ARB_depth_texture */

2044

2045

#ifdef GL_ARB_draw_buffers

2046

2047

static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

2048

{

2049

GLboolean r = GL_FALSE;

2050

2051

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

2052

2053

return r;

2054

}

2055

2056

#endif /* GL_ARB_draw_buffers */

2057

2058

#ifdef GL_ARB_fragment_program

2059

2060

#endif /* GL_ARB_fragment_program */

2061

2062

#ifdef GL_ARB_fragment_program_shadow

2063

2064

#endif /* GL_ARB_fragment_program_shadow */

2065

2066

#ifdef GL_ARB_fragment_shader

2067

2068

#endif /* GL_ARB_fragment_shader */

2069

2070

#ifdef GL_ARB_half_float_pixel

2071

2072

#endif /* GL_ARB_half_float_pixel */

2073

2074

#ifdef GL_ARB_imaging

2075

2076

static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT)

2077

{

2078

GLboolean r = GL_FALSE;

2079

2080

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

2081

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

2082

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

2083

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

2084

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

2085

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

2086

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

2087

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

2088

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

2089

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

2090

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

2091

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

2092

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

2093

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

2094

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

2095

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

2096

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

2097

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

2098

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

2099

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

2100

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

2101

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

2102

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

2103

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

2104

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

2105

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

2106

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

2107

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

2108

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

2109

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

2110

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

2111

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

2112

2113

return r;

2114

}

2115

2116

#endif /* GL_ARB_imaging */

2117

2118

#ifdef GL_ARB_matrix_palette

2119

2120

static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT)

2121

{

2122

GLboolean r = GL_FALSE;

2123

2124

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

2125

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

2126

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

2127

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

2128

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

2129

2130

return r;

2131

}

2132

2133

#endif /* GL_ARB_matrix_palette */

2134

2135

#ifdef GL_ARB_multisample

2136

2137

static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

2138

{

2139

GLboolean r = GL_FALSE;

2140

2141

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

2142

2143

return r;

2144

}

2145

2146

#endif /* GL_ARB_multisample */

2147

2148

#ifdef GL_ARB_multitexture

2149

2150

static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)

2151

{

2152

GLboolean r = GL_FALSE;

2153

2154

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

2155

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

2156

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

2157

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

2158

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

2159

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

2160

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

2161

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

2162

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

2163

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

2164

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

2165

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

2166

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

2167

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

2168

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

2169

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

2170

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

2171

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

2172

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

2173

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

2174

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

2175

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

2176

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

2177

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

2178

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

2179

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

2180

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

2181

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

2182

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

2183

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

2184

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

2185

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

2186

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

2187

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

2188

2189

return r;

2190

}

2191

2192

#endif /* GL_ARB_multitexture */

2193

2194

#ifdef GL_ARB_occlusion_query

2195

2196

static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)

2197

{

2198

GLboolean r = GL_FALSE;

2199

2200

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

2201

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

2202

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

2203

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

2204

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

2205

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

2206

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

2207

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

2208

2209

return r;

2210

}

2211

2212

#endif /* GL_ARB_occlusion_query */

2213

2214

#ifdef GL_ARB_pixel_buffer_object

2215

2216

#endif /* GL_ARB_pixel_buffer_object */

2217

2218

#ifdef GL_ARB_point_parameters

2219

2220

static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

2221

{

2222

GLboolean r = GL_FALSE;

2223

2224

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

2225

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

2226

2227

return r;

2228

}

2229

2230

#endif /* GL_ARB_point_parameters */

2231

2232

#ifdef GL_ARB_point_sprite

2233

2234

#endif /* GL_ARB_point_sprite */

2235

2236

#ifdef GL_ARB_shader_objects

2237

2238

static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)

2239

{

2240

GLboolean r = GL_FALSE;

2241

2242

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

2243

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

2244

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

2245

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

2246

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

2247

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

2248

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

2249

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

2250

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

2251

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

2252

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

2253

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

2254

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

2255

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

2256

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

2257

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

2258

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

2259

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

2260

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

2261

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

2262

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

2263

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

2264

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

2265

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

2266

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

2267

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

2268

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

2269

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

2270

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

2271

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

2272

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

2273

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

2274

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

2275

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

2276

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

2277

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

2278

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

2279

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

2280

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

2281

2282

return r;

2283

}

2284

2285

#endif /* GL_ARB_shader_objects */

2286

2287

#ifdef GL_ARB_shading_language_100

2288

2289

#endif /* GL_ARB_shading_language_100 */

2290

2291

#ifdef GL_ARB_shadow

2292

2293

#endif /* GL_ARB_shadow */

2294

2295

#ifdef GL_ARB_shadow_ambient

2296

2297

#endif /* GL_ARB_shadow_ambient */

2298

2299

#ifdef GL_ARB_texture_border_clamp

2300

2301

#endif /* GL_ARB_texture_border_clamp */

2302

2303

#ifdef GL_ARB_texture_compression

2304

2305

static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)

2306

{

2307

GLboolean r = GL_FALSE;

2308

2309

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

2310

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

2311

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

2312

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

2313

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

2314

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

2315

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

2316

2317

return r;

2318

}

2319

2320

#endif /* GL_ARB_texture_compression */

2321

2322

#ifdef GL_ARB_texture_cube_map

2323

2324

#endif /* GL_ARB_texture_cube_map */

2325

2326

#ifdef GL_ARB_texture_env_add

2327

2328

#endif /* GL_ARB_texture_env_add */

2329

2330

#ifdef GL_ARB_texture_env_combine

2331

2332

#endif /* GL_ARB_texture_env_combine */

2333

2334

#ifdef GL_ARB_texture_env_crossbar

2335

2336

#endif /* GL_ARB_texture_env_crossbar */

2337

2338

#ifdef GL_ARB_texture_env_dot3

2339

2340

#endif /* GL_ARB_texture_env_dot3 */

2341

2342

#ifdef GL_ARB_texture_float

2343

2344

#endif /* GL_ARB_texture_float */

2345

2346

#ifdef GL_ARB_texture_mirrored_repeat

2347

2348

#endif /* GL_ARB_texture_mirrored_repeat */

2349

2350

#ifdef GL_ARB_texture_non_power_of_two

2351

2352

#endif /* GL_ARB_texture_non_power_of_two */

2353

2354

#ifdef GL_ARB_texture_rectangle

2355

2356

#endif /* GL_ARB_texture_rectangle */

2357

2358

#ifdef GL_ARB_transpose_matrix

2359

2360

#endif /* GL_ARB_transpose_matrix */

2361

2362

#ifdef GL_ARB_vertex_blend

2363

2364

static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT)

2365

{

2366

GLboolean r = GL_FALSE;

2367

2368

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

2369

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

2370

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

2371

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

2372

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

2373

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

2374

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

2375

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

2376

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

2377

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

2378

2379

return r;

2380

}

2381

2382

#endif /* GL_ARB_vertex_blend */

2383

2384

#ifdef GL_ARB_vertex_buffer_object

2385

2386

static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

2387

{

2388

GLboolean r = GL_FALSE;

2389

2390

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

2391

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

2392

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

2393

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

2394

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

2395

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

2396

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

2397

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

2398

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

2399

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

2400

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

2401

2402

return r;

2403

}

2404

2405

#endif /* GL_ARB_vertex_buffer_object */

2406

2407

#ifdef GL_ARB_vertex_program

2408

2409

static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)

2410

{

2411

GLboolean r = GL_FALSE;

2412

2413

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

2414

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

2415

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

2416

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

2417

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

2418

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

2419

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

2420

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

2421

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

2422

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

2423

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

2424

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

2425

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

2426

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

2427

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

2428

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

2429

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

2430

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

2431

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

2432

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

2433

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

2434

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

2435

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

2436

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

2437

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

2438

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

2439

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

2440

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

2441

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

2442

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

2443

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

2444

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

2445

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

2446

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

2447

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

2448

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

2449

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

2450

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

2451

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

2452

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

2453

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

2454

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

2455

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

2456

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

2457

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

2458

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

2459

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

2460

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

2461

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

2462

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

2463

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

2464

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

2465

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

2466

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

2467

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

2468

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

2469

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

2470

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

2471

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

2472

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

2473

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

2474

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

2475

2476

return r;

2477

}

2478

2479

#endif /* GL_ARB_vertex_program */

2480

2481

#ifdef GL_ARB_vertex_shader

2482

2483

static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)

2484

{

2485

GLboolean r = GL_FALSE;

2486

2487

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

2488

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

2489

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

2490

2491

return r;

2492

}

2493

2494

#endif /* GL_ARB_vertex_shader */

2495

2496

#ifdef GL_ARB_window_pos

2497

2498

static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)

2499

{

2500

GLboolean r = GL_FALSE;

2501

2502

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

2503

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

2504

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

2505

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

2506

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

2507

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

2508

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

2509

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

2510

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

2511

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

2512

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

2513

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

2514

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

2515

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

2516

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

2517

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

2518

2519

return r;

2520

}

2521

2522

#endif /* GL_ARB_window_pos */

2523

2524

#ifdef GL_ATIX_point_sprites

2525

2526

#endif /* GL_ATIX_point_sprites */

2527

2528

#ifdef GL_ATIX_texture_env_combine3

2529

2530

#endif /* GL_ATIX_texture_env_combine3 */

2531

2532

#ifdef GL_ATIX_texture_env_route

2533

2534

#endif /* GL_ATIX_texture_env_route */

2535

2536

#ifdef GL_ATIX_vertex_shader_output_point_size

2537

2538

#endif /* GL_ATIX_vertex_shader_output_point_size */

2539

2540

#ifdef GL_ATI_draw_buffers

2541

2542

static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

2543

{

2544

GLboolean r = GL_FALSE;

2545

2546

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

2547

2548

return r;

2549

}

2550

2551

#endif /* GL_ATI_draw_buffers */

2552

2553

#ifdef GL_ATI_element_array

2554

2555

static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT)

2556

{

2557

GLboolean r = GL_FALSE;

2558

2559

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

2560

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

2561

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

2562

2563

return r;

2564

}

2565

2566

#endif /* GL_ATI_element_array */

2567

2568

#ifdef GL_ATI_envmap_bumpmap

2569

2570

static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT)

2571

{

2572

GLboolean r = GL_FALSE;

2573

2574

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

2575

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

2576

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

2577

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

2578

2579

return r;

2580

}

2581

2582

#endif /* GL_ATI_envmap_bumpmap */

2583

2584

#ifdef GL_ATI_fragment_shader

2585

2586

static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)

2587

{

2588

GLboolean r = GL_FALSE;

2589

2590

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

2591

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

2592

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

2593

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

2594

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

2595

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

2596

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

2597

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

2598

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

2599

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

2600

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

2601

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

2602

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

2603

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

2604

2605

return r;

2606

}

2607

2608

#endif /* GL_ATI_fragment_shader */

2609

2610

#ifdef GL_ATI_map_object_buffer

2611

2612

static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)

2613

{

2614

GLboolean r = GL_FALSE;

2615

2616

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

2617

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

2618

2619

return r;

2620

}

2621

2622

#endif /* GL_ATI_map_object_buffer */

2623

2624

#ifdef GL_ATI_pn_triangles

2625

2626

static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)

2627

{

2628

GLboolean r = GL_FALSE;

2629

2630

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

2631

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

2632

2633

return r;

2634

}

2635

2636

#endif /* GL_ATI_pn_triangles */

2637

2638

#ifdef GL_ATI_separate_stencil

2639

2640

static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT)

2641

{

2642

GLboolean r = GL_FALSE;

2643

2644

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

2645

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

2646

2647

return r;

2648

}

2649

2650

#endif /* GL_ATI_separate_stencil */

2651

2652

#ifdef GL_ATI_text_fragment_shader

2653

2654

#endif /* GL_ATI_text_fragment_shader */

2655

2656

#ifdef GL_ATI_texture_compression_3dc

2657

2658

#endif /* GL_ATI_texture_compression_3dc */

2659

2660

#ifdef GL_ATI_texture_env_combine3

2661

2662

#endif /* GL_ATI_texture_env_combine3 */

2663

2664

#ifdef GL_ATI_texture_float

2665

2666

#endif /* GL_ATI_texture_float */

2667

2668

#ifdef GL_ATI_texture_mirror_once

2669

2670

#endif /* GL_ATI_texture_mirror_once */

2671

2672

#ifdef GL_ATI_vertex_array_object

2673

2674

static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

2675

{

2676

GLboolean r = GL_FALSE;

2677

2678

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

2679

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

2680

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

2681

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

2682

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

2683

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

2684

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

2685

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

2686

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

2687

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

2688

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

2689

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

2690

2691

return r;

2692

}

2693

2694

#endif /* GL_ATI_vertex_array_object */

2695

2696

#ifdef GL_ATI_vertex_attrib_array_object

2697

2698

static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT)

2699

{

2700

GLboolean r = GL_FALSE;

2701

2702

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

2703

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

2704

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

2705

2706

return r;

2707

}

2708

2709

#endif /* GL_ATI_vertex_attrib_array_object */

2710

2711

#ifdef GL_ATI_vertex_streams

2712

2713

static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT)

2714

{

2715

GLboolean r = GL_FALSE;

2716

2717

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

2718

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

2719

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

2720

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

2721

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

2722

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

2723

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

2724

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

2725

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

2726

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

2727

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

2728

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

2729

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

2730

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

2731

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

2732

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

2733

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

2734

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

2735

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

2736

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

2737

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

2738

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

2739

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

2740

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

2741

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

2742

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

2743

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

2744

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

2745

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

2746

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

2747

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

2748

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

2749

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

2750

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

2751

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

2752

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

2753

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

2754

2755

return r;

2756

}

2757

2758

#endif /* GL_ATI_vertex_streams */

2759

2760

#ifdef GL_EXT_422_pixels

2761

2762

#endif /* GL_EXT_422_pixels */

2763

2764

#ifdef GL_EXT_Cg_shader

2765

2766

#endif /* GL_EXT_Cg_shader */

2767

2768

#ifdef GL_EXT_abgr

2769

2770

#endif /* GL_EXT_abgr */

2771

2772

#ifdef GL_EXT_bgra

2773

2774

#endif /* GL_EXT_bgra */

2775

2776

#ifdef GL_EXT_blend_color

2777

2778

static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT)

2779

{

2780

GLboolean r = GL_FALSE;

2781

2782

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

2783

2784

return r;

2785

}

2786

2787

#endif /* GL_EXT_blend_color */

2788

2789

#ifdef GL_EXT_blend_equation_separate

2790

2791

static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT)

2792

{

2793

GLboolean r = GL_FALSE;

2794

2795

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

2796

2797

return r;

2798

}

2799

2800

#endif /* GL_EXT_blend_equation_separate */

2801

2802

#ifdef GL_EXT_blend_func_separate

2803

2804

static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT)

2805

{

2806

GLboolean r = GL_FALSE;

2807

2808

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

2809

2810

return r;

2811

}

2812

2813

#endif /* GL_EXT_blend_func_separate */

2814

2815

#ifdef GL_EXT_blend_logic_op

2816

2817

#endif /* GL_EXT_blend_logic_op */

2818

2819

#ifdef GL_EXT_blend_minmax

2820

2821

static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT)

2822

{

2823

GLboolean r = GL_FALSE;

2824

2825

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

2826

2827

return r;

2828

}

2829

2830

#endif /* GL_EXT_blend_minmax */

2831

2832

#ifdef GL_EXT_blend_subtract

2833

2834

#endif /* GL_EXT_blend_subtract */

2835

2836

#ifdef GL_EXT_clip_volume_hint

2837

2838

#endif /* GL_EXT_clip_volume_hint */

2839

2840

#ifdef GL_EXT_cmyka

2841

2842

#endif /* GL_EXT_cmyka */

2843

2844

#ifdef GL_EXT_color_subtable

2845

2846

static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT)

2847

{

2848

GLboolean r = GL_FALSE;

2849

2850

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

2851

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

2852

2853

return r;

2854

}

2855

2856

#endif /* GL_EXT_color_subtable */

2857

2858

#ifdef GL_EXT_compiled_vertex_array

2859

2860

static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)

2861

{

2862

GLboolean r = GL_FALSE;

2863

2864

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

2865

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

2866

2867

return r;

2868

}

2869

2870

#endif /* GL_EXT_compiled_vertex_array */

2871

2872

#ifdef GL_EXT_convolution

2873

2874

static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT)

2875

{

2876

GLboolean r = GL_FALSE;

2877

2878

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

2879

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

2880

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

2881

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

2882

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

2883

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

2884

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

2885

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

2886

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

2887

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

2888

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

2889

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

2890

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

2891

2892

return r;

2893

}

2894

2895

#endif /* GL_EXT_convolution */

2896

2897

#ifdef GL_EXT_coordinate_frame

2898

2899

static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT)

2900

{

2901

GLboolean r = GL_FALSE;

2902

2903

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

2904

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

2905

2906

return r;

2907

}

2908

2909

#endif /* GL_EXT_coordinate_frame */

2910

2911

#ifdef GL_EXT_copy_texture

2912

2913

static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT)

2914

{

2915

GLboolean r = GL_FALSE;

2916

2917

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

2918

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

2919

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

2920

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

2921

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

2922

2923

return r;

2924

}

2925

2926

#endif /* GL_EXT_copy_texture */

2927

2928

#ifdef GL_EXT_cull_vertex

2929

2930

static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT)

2931

{

2932

GLboolean r = GL_FALSE;

2933

2934

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

2935

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

2936

2937

return r;

2938

}

2939

2940

#endif /* GL_EXT_cull_vertex */

2941

2942

#ifdef GL_EXT_depth_bounds_test

2943

2944

static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT)

2945

{

2946

GLboolean r = GL_FALSE;

2947

2948

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

2949

2950

return r;

2951

}

2952

2953

#endif /* GL_EXT_depth_bounds_test */

2954

2955

#ifdef GL_EXT_draw_range_elements

2956

2957

static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT)

2958

{

2959

GLboolean r = GL_FALSE;

2960

2961

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

2962

2963

return r;

2964

}

2965

2966

#endif /* GL_EXT_draw_range_elements */

2967

2968

#ifdef GL_EXT_fog_coord

2969

2970

static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT)

2971

{

2972

GLboolean r = GL_FALSE;

2973

2974

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

2975

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

2976

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

2977

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

2978

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

2979

2980

return r;

2981

}

2982

2983

#endif /* GL_EXT_fog_coord */

2984

2985

#ifdef GL_EXT_fragment_lighting

2986

2987

static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT)

2988

{

2989

GLboolean r = GL_FALSE;

2990

2991

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

2992

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

2993

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

2994

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

2995

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

2996

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

2997

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

2998

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

2999

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

3000

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

3001

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

3002

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

3003

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

3004

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

3005

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

3006

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

3007

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

3008

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

3009

3010

return r;

3011

}

3012

3013

#endif /* GL_EXT_fragment_lighting */

3014

3015

#ifdef GL_EXT_framebuffer_object

3016

3017

static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)

3018

{

3019

GLboolean r = GL_FALSE;

3020

3021

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

3022

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

3023

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

3024

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

3025

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

3026

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

3027

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

3028

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

3029

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

3030

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

3031

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

3032

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

3033

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

3034

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

3035

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

3036

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

3037

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

3038

3039

return r;

3040

}

3041

3042

#endif /* GL_EXT_framebuffer_object */

3043

3044

#ifdef GL_EXT_histogram

3045

3046

static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT)

3047

{

3048

GLboolean r = GL_FALSE;

3049

3050

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

3051

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

3052

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

3053

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

3054

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

3055

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

3056

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

3057

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

3058

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

3059

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

3060

3061

return r;

3062

}

3063

3064

#endif /* GL_EXT_histogram */

3065

3066

#ifdef GL_EXT_index_array_formats

3067

3068

#endif /* GL_EXT_index_array_formats */

3069

3070

#ifdef GL_EXT_index_func

3071

3072

static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT)

3073

{

3074

GLboolean r = GL_FALSE;

3075

3076

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

3077

3078

return r;

3079

}

3080

3081

#endif /* GL_EXT_index_func */

3082

3083

#ifdef GL_EXT_index_material

3084

3085

static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT)

3086

{

3087

GLboolean r = GL_FALSE;

3088

3089

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

3090

3091

return r;

3092

}

3093

3094

#endif /* GL_EXT_index_material */

3095

3096

#ifdef GL_EXT_index_texture

3097

3098

#endif /* GL_EXT_index_texture */

3099

3100

#ifdef GL_EXT_light_texture

3101

3102

static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT)

3103

{

3104

GLboolean r = GL_FALSE;

3105

3106

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

3107

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

3108

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

3109

3110

return r;

3111

}

3112

3113

#endif /* GL_EXT_light_texture */

3114

3115

#ifdef GL_EXT_misc_attribute

3116

3117

#endif /* GL_EXT_misc_attribute */

3118

3119

#ifdef GL_EXT_multi_draw_arrays

3120

3121

static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

3122

{

3123

GLboolean r = GL_FALSE;

3124

3125

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

3126

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

3127

3128

return r;

3129

}

3130

3131

#endif /* GL_EXT_multi_draw_arrays */

3132

3133

#ifdef GL_EXT_multisample

3134

3135

static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

3136

{

3137

GLboolean r = GL_FALSE;

3138

3139

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

3140

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

3141

3142

return r;

3143

}

3144

3145

#endif /* GL_EXT_multisample */

3146

3147

#ifdef GL_EXT_packed_pixels

3148

3149

#endif /* GL_EXT_packed_pixels */

3150

3151

#ifdef GL_EXT_paletted_texture

3152

3153

static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT)

3154

{

3155

GLboolean r = GL_FALSE;

3156

3157

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

3158

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

3159

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

3160

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

3161

3162

return r;

3163

}

3164

3165

#endif /* GL_EXT_paletted_texture */

3166

3167

#ifdef GL_EXT_pixel_buffer_object

3168

3169

#endif /* GL_EXT_pixel_buffer_object */

3170

3171

#ifdef GL_EXT_pixel_transform

3172

3173

static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT)

3174

{

3175

GLboolean r = GL_FALSE;

3176

3177

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

3178

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

3179

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

3180

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

3181

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

3182

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

3183

3184

return r;

3185

}

3186

3187

#endif /* GL_EXT_pixel_transform */

3188

3189

#ifdef GL_EXT_pixel_transform_color_table

3190

3191

#endif /* GL_EXT_pixel_transform_color_table */

3192

3193

#ifdef GL_EXT_point_parameters

3194

3195

static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)

3196

{

3197

GLboolean r = GL_FALSE;

3198

3199

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

3200

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

3201

3202

return r;

3203

}

3204

3205

#endif /* GL_EXT_point_parameters */

3206

3207

#ifdef GL_EXT_polygon_offset

3208

3209

static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)

3210

{

3211

GLboolean r = GL_FALSE;

3212

3213

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

3214

3215

return r;

3216

}

3217

3218

#endif /* GL_EXT_polygon_offset */

3219

3220

#ifdef GL_EXT_rescale_normal

3221

3222

#endif /* GL_EXT_rescale_normal */

3223

3224

#ifdef GL_EXT_scene_marker

3225

3226

static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT)

3227

{

3228

GLboolean r = GL_FALSE;

3229

3230

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

3231

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

3232

3233

return r;

3234

}

3235

3236

#endif /* GL_EXT_scene_marker */

3237

3238

#ifdef GL_EXT_secondary_color

3239

3240

static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)

3241

{

3242

GLboolean r = GL_FALSE;

3243

3244

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

3245

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

3246

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

3247

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

3248

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

3249

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

3250

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

3251

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

3252

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

3253

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

3254

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

3255

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

3256

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

3257

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

3258

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

3259

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

3260

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

3261

3262

return r;

3263

}

3264

3265

#endif /* GL_EXT_secondary_color */

3266

3267

#ifdef GL_EXT_separate_specular_color

3268

3269

#endif /* GL_EXT_separate_specular_color */

3270

3271

#ifdef GL_EXT_shadow_funcs

3272

3273

#endif /* GL_EXT_shadow_funcs */

3274

3275

#ifdef GL_EXT_shared_texture_palette

3276

3277

#endif /* GL_EXT_shared_texture_palette */

3278

3279

#ifdef GL_EXT_stencil_two_side

3280

3281

static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)

3282

{

3283

GLboolean r = GL_FALSE;

3284

3285

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

3286

3287

return r;

3288

}

3289

3290

#endif /* GL_EXT_stencil_two_side */

3291

3292

#ifdef GL_EXT_stencil_wrap

3293

3294

#endif /* GL_EXT_stencil_wrap */

3295

3296

#ifdef GL_EXT_subtexture

3297

3298

static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT)

3299

{

3300

GLboolean r = GL_FALSE;

3301

3302

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

3303

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

3304

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

3305

3306

return r;

3307

}

3308

3309

#endif /* GL_EXT_subtexture */

3310

3311

#ifdef GL_EXT_texture

3312

3313

#endif /* GL_EXT_texture */

3314

3315

#ifdef GL_EXT_texture3D

3316

3317

static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT)

3318

{

3319

GLboolean r = GL_FALSE;

3320

3321

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

3322

3323

return r;

3324

}

3325

3326

#endif /* GL_EXT_texture3D */

3327

3328

#ifdef GL_EXT_texture_compression_dxt1

3329

3330

#endif /* GL_EXT_texture_compression_dxt1 */

3331

3332

#ifdef GL_EXT_texture_compression_s3tc

3333

3334

#endif /* GL_EXT_texture_compression_s3tc */

3335

3336

#ifdef GL_EXT_texture_cube_map

3337

3338

#endif /* GL_EXT_texture_cube_map */

3339

3340

#ifdef GL_EXT_texture_edge_clamp

3341

3342

#endif /* GL_EXT_texture_edge_clamp */

3343

3344

#ifdef GL_EXT_texture_env

3345

3346

#endif /* GL_EXT_texture_env */

3347

3348

#ifdef GL_EXT_texture_env_add

3349

3350

#endif /* GL_EXT_texture_env_add */

3351

3352

#ifdef GL_EXT_texture_env_combine

3353

3354

#endif /* GL_EXT_texture_env_combine */

3355

3356

#ifdef GL_EXT_texture_env_dot3

3357

3358

#endif /* GL_EXT_texture_env_dot3 */

3359

3360

#ifdef GL_EXT_texture_filter_anisotropic

3361

3362

#endif /* GL_EXT_texture_filter_anisotropic */

3363

3364

#ifdef GL_EXT_texture_lod_bias

3365

3366

#endif /* GL_EXT_texture_lod_bias */

3367

3368

#ifdef GL_EXT_texture_mirror_clamp

3369

3370

#endif /* GL_EXT_texture_mirror_clamp */

3371

3372

#ifdef GL_EXT_texture_object

3373

3374

static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT)

3375

{

3376

GLboolean r = GL_FALSE;

3377

3378

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

3379

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

3380

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

3381

r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;

3382

r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;

3383

r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;

3384

3385

return r;

3386

}

3387

3388

#endif /* GL_EXT_texture_object */

3389

3390

#ifdef GL_EXT_texture_perturb_normal

3391

3392

static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT)

3393

{

3394

GLboolean r = GL_FALSE;

3395

3396

r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;

3397

3398

return r;

3399

}

3400

3401

#endif /* GL_EXT_texture_perturb_normal */

3402

3403

#ifdef GL_EXT_texture_rectangle

3404

3405

#endif /* GL_EXT_texture_rectangle */

3406

3407

#ifdef GL_EXT_vertex_array

3408

3409

static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)

3410

{

3411

GLboolean r = GL_FALSE;

3412

3413

r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;

3414

r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;

3415

r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;

3416

r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;

3417

r = ((glGetPointervEXT = (PFNGLGETPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointervEXT")) == NULL) || r;

3418

r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;

3419

r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;

3420

r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;

3421

r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;

3422

3423

return r;

3424

}

3425

3426

#endif /* GL_EXT_vertex_array */

3427

3428

#ifdef GL_EXT_vertex_shader

3429

3430

static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)

3431

{

3432

GLboolean r = GL_FALSE;

3433

3434

r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;

3435

r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;

3436

r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;

3437

r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;

3438

r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;

3439

r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;

3440

r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;

3441

r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;

3442

r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;

3443

r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;

3444

r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;

3445

r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;

3446

r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;

3447

r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;

3448

r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;

3449

r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;

3450

r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;

3451

r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;

3452

r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;

3453

r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;

3454

r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;

3455

r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;

3456

r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;

3457

r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;

3458

r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;

3459

r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;

3460

r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;

3461

r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;

3462

r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;

3463

r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;

3464

r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;

3465

r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;

3466

r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;

3467

r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;

3468

r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;

3469

r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;

3470

r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;

3471

r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;

3472

r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;

3473

r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;

3474

r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;

3475

r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;

3476

3477

return r;

3478

}

3479

3480

#endif /* GL_EXT_vertex_shader */

3481

3482

#ifdef GL_EXT_vertex_weighting

3483

3484

static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT)

3485

{

3486

GLboolean r = GL_FALSE;

3487

3488

r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;

3489

r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;

3490

r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;

3491

3492

return r;

3493

}

3494

3495

#endif /* GL_EXT_vertex_weighting */

3496

3497

#ifdef GL_HP_convolution_border_modes

3498

3499

#endif /* GL_HP_convolution_border_modes */

3500

3501

#ifdef GL_HP_image_transform

3502

3503

static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT)

3504

{

3505

GLboolean r = GL_FALSE;

3506

3507

r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;

3508

r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;

3509

r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;

3510

r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;

3511

r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;

3512

r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;

3513

3514

return r;

3515

}

3516

3517

#endif /* GL_HP_image_transform */

3518

3519

#ifdef GL_HP_occlusion_test

3520

3521

#endif /* GL_HP_occlusion_test */

3522

3523

#ifdef GL_HP_texture_lighting

3524

3525

#endif /* GL_HP_texture_lighting */

3526

3527

#ifdef GL_IBM_cull_vertex

3528

3529

#endif /* GL_IBM_cull_vertex */

3530

3531

#ifdef GL_IBM_multimode_draw_arrays

3532

3533

static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

3534

{

3535

GLboolean r = GL_FALSE;

3536

3537

r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;

3538

r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;

3539

3540

return r;

3541

}

3542

3543

#endif /* GL_IBM_multimode_draw_arrays */

3544

3545

#ifdef GL_IBM_rasterpos_clip

3546

3547

#endif /* GL_IBM_rasterpos_clip */

3548

3549

#ifdef GL_IBM_static_data

3550

3551

#endif /* GL_IBM_static_data */

3552

3553

#ifdef GL_IBM_texture_mirrored_repeat

3554

3555

#endif /* GL_IBM_texture_mirrored_repeat */

3556

3557

#ifdef GL_IBM_vertex_array_lists

3558

3559

static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT)

3560

{

3561

GLboolean r = GL_FALSE;

3562

3563

r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;

3564

r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;

3565

r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;

3566

r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;

3567

r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;

3568

r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;

3569

r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;

3570

r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;

3571

3572

return r;

3573

}

3574

3575

#endif /* GL_IBM_vertex_array_lists */

3576

3577

#ifdef GL_INGR_color_clamp

3578

3579

#endif /* GL_INGR_color_clamp */

3580

3581

#ifdef GL_INGR_interlace_read

3582

3583

#endif /* GL_INGR_interlace_read */

3584

3585

#ifdef GL_INTEL_parallel_arrays

3586

3587

static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT)

3588

{

3589

GLboolean r = GL_FALSE;

3590

3591

r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;

3592

r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;

3593

r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;

3594

r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;

3595

3596

return r;

3597

}

3598

3599

#endif /* GL_INTEL_parallel_arrays */

3600

3601

#ifdef GL_INTEL_texture_scissor

3602

3603

static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT)

3604

{

3605

GLboolean r = GL_FALSE;

3606

3607

r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;

3608

r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;

3609

3610

return r;

3611

}

3612

3613

#endif /* GL_INTEL_texture_scissor */

3614

3615

#ifdef GL_KTX_buffer_region

3616

3617

static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT)

3618

{

3619

GLboolean r = GL_FALSE;

3620

3621

r = ((glBufferRegionEnabledEXT = (PFNGLBUFFERREGIONENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabledEXT")) == NULL) || r;

3622

r = ((glDeleteBufferRegionEXT = (PFNGLDELETEBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegionEXT")) == NULL) || r;

3623

r = ((glDrawBufferRegionEXT = (PFNGLDRAWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegionEXT")) == NULL) || r;

3624

r = ((glNewBufferRegionEXT = (PFNGLNEWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegionEXT")) == NULL) || r;

3625

r = ((glReadBufferRegionEXT = (PFNGLREADBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegionEXT")) == NULL) || r;

3626

3627

return r;

3628

}

3629

3630

#endif /* GL_KTX_buffer_region */

3631

3632

#ifdef GL_MESA_pack_invert

3633

3634

#endif /* GL_MESA_pack_invert */

3635

3636

#ifdef GL_MESA_resize_buffers

3637

3638

static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT)

3639

{

3640

GLboolean r = GL_FALSE;

3641

3642

r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;

3643

3644

return r;

3645

}

3646

3647

#endif /* GL_MESA_resize_buffers */

3648

3649

#ifdef GL_MESA_window_pos

3650

3651

static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)

3652

{

3653

GLboolean r = GL_FALSE;

3654

3655

r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;

3656

r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;

3657

r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;

3658

r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;

3659

r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;

3660

r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;

3661

r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;

3662

r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;

3663

r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;

3664

r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;

3665

r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;

3666

r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;

3667

r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;

3668

r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;

3669

r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;

3670

r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;

3671

r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;

3672

r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;

3673

r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;

3674

r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;

3675

r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;

3676

r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;

3677

r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;

3678

r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;

3679

3680

return r;

3681

}

3682

3683

#endif /* GL_MESA_window_pos */

3684

3685

#ifdef GL_MESA_ycbcr_texture

3686

3687

#endif /* GL_MESA_ycbcr_texture */

3688

3689

#ifdef GL_NV_blend_square

3690

3691

#endif /* GL_NV_blend_square */

3692

3693

#ifdef GL_NV_copy_depth_to_color

3694

3695

#endif /* GL_NV_copy_depth_to_color */

3696

3697

#ifdef GL_NV_depth_clamp

3698

3699

#endif /* GL_NV_depth_clamp */

3700

3701

#ifdef GL_NV_evaluators

3702

3703

static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)

3704

{

3705

GLboolean r = GL_FALSE;

3706

3707

r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;

3708

r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;

3709

r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;

3710

r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;

3711

r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;

3712

r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;

3713

r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;

3714

r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;

3715

r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;

3716

3717

return r;

3718

}

3719

3720

#endif /* GL_NV_evaluators */

3721

3722

#ifdef GL_NV_fence

3723

3724

static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT)

3725

{

3726

GLboolean r = GL_FALSE;

3727

3728

r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;

3729

r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;

3730

r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;

3731

r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;

3732

r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;

3733

r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;

3734

r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;

3735

3736

return r;

3737

}

3738

3739

#endif /* GL_NV_fence */

3740

3741

#ifdef GL_NV_float_buffer

3742

3743

#endif /* GL_NV_float_buffer */

3744

3745

#ifdef GL_NV_fog_distance

3746

3747

#endif /* GL_NV_fog_distance */

3748

3749

#ifdef GL_NV_fragment_program

3750

3751

static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)

3752

{

3753

GLboolean r = GL_FALSE;

3754

3755

r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;

3756

r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;

3757

r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;

3758

r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;

3759

r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;

3760

r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;

3761

3762

return r;

3763

}

3764

3765

#endif /* GL_NV_fragment_program */

3766

3767

#ifdef GL_NV_fragment_program2

3768

3769

#endif /* GL_NV_fragment_program2 */

3770

3771

#ifdef GL_NV_fragment_program_option

3772

3773

#endif /* GL_NV_fragment_program_option */

3774

3775

#ifdef GL_NV_half_float

3776

3777

static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)

3778

{

3779

GLboolean r = GL_FALSE;

3780

3781

r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;

3782

r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;

3783

r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;

3784

r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;

3785

r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;

3786

r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;

3787

r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;

3788

r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;

3789

r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;

3790

r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;

3791

r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;

3792

r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;

3793

r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;

3794

r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;

3795

r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;

3796

r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;

3797

r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;

3798

r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;

3799

r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;

3800

r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;

3801

r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;

3802

r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;

3803

r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;

3804

r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;

3805

r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;

3806

r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;

3807

r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;

3808

r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;

3809

r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;

3810

r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;

3811

r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;

3812

r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;

3813

r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;

3814

r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;

3815

r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;

3816

r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;

3817

r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;

3818

r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;

3819

r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;

3820

r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;

3821

r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;

3822

r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;

3823

r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;

3824

r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;

3825

r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;

3826

r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;

3827

3828

return r;

3829

}

3830

3831

#endif /* GL_NV_half_float */

3832

3833

#ifdef GL_NV_light_max_exponent

3834

3835

#endif /* GL_NV_light_max_exponent */

3836

3837

#ifdef GL_NV_multisample_filter_hint

3838

3839

#endif /* GL_NV_multisample_filter_hint */

3840

3841

#ifdef GL_NV_occlusion_query

3842

3843

static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)

3844

{

3845

GLboolean r = GL_FALSE;

3846

3847

r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;

3848

r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;

3849

r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;

3850

r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;

3851

r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;

3852

r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;

3853

r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;

3854

3855

return r;

3856

}

3857

3858

#endif /* GL_NV_occlusion_query */

3859

3860

#ifdef GL_NV_packed_depth_stencil

3861

3862

#endif /* GL_NV_packed_depth_stencil */

3863

3864

#ifdef GL_NV_pixel_data_range

3865

3866

static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)

3867

{

3868

GLboolean r = GL_FALSE;

3869

3870

r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;

3871

r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;

3872

3873

return r;

3874

}

3875

3876

#endif /* GL_NV_pixel_data_range */

3877

3878

#ifdef GL_NV_point_sprite

3879

3880

static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT)

3881

{

3882

GLboolean r = GL_FALSE;

3883

3884

r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;

3885

r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;

3886

3887

return r;

3888

}

3889

3890

#endif /* GL_NV_point_sprite */

3891

3892

#ifdef GL_NV_primitive_restart

3893

3894

static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT)

3895

{

3896

GLboolean r = GL_FALSE;

3897

3898

r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;

3899

r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;

3900

3901

return r;

3902

}

3903

3904

#endif /* GL_NV_primitive_restart */

3905

3906

#ifdef GL_NV_register_combiners

3907

3908

static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)

3909

{

3910

GLboolean r = GL_FALSE;

3911

3912

r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;

3913

r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;

3914

r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;

3915

r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;

3916

r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;

3917

r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;

3918

r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;

3919

r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;

3920

r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;

3921

r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;

3922

r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;

3923

r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;

3924

r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;

3925

3926

return r;

3927

}

3928

3929

#endif /* GL_NV_register_combiners */

3930

3931

#ifdef GL_NV_register_combiners2

3932

3933

static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)

3934

{

3935

GLboolean r = GL_FALSE;

3936

3937

r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;

3938

r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;

3939

3940

return r;

3941

}

3942

3943

#endif /* GL_NV_register_combiners2 */

3944

3945

#ifdef GL_NV_texgen_emboss

3946

3947

#endif /* GL_NV_texgen_emboss */

3948

3949

#ifdef GL_NV_texgen_reflection

3950

3951

#endif /* GL_NV_texgen_reflection */

3952

3953

#ifdef GL_NV_texture_compression_vtc

3954

3955

#endif /* GL_NV_texture_compression_vtc */

3956

3957

#ifdef GL_NV_texture_env_combine4

3958

3959

#endif /* GL_NV_texture_env_combine4 */

3960

3961

#ifdef GL_NV_texture_expand_normal

3962

3963

#endif /* GL_NV_texture_expand_normal */

3964

3965

#ifdef GL_NV_texture_rectangle

3966

3967

#endif /* GL_NV_texture_rectangle */

3968

3969

#ifdef GL_NV_texture_shader

3970

3971

#endif /* GL_NV_texture_shader */

3972

3973

#ifdef GL_NV_texture_shader2

3974

3975

#endif /* GL_NV_texture_shader2 */

3976

3977

#ifdef GL_NV_texture_shader3

3978

3979

#endif /* GL_NV_texture_shader3 */

3980

3981

#ifdef GL_NV_vertex_array_range

3982

3983

static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)

3984

{

3985

GLboolean r = GL_FALSE;

3986

3987

r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;

3988

r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;

3989

3990

return r;

3991

}

3992

3993

#endif /* GL_NV_vertex_array_range */

3994

3995

#ifdef GL_NV_vertex_array_range2

3996

3997

#endif /* GL_NV_vertex_array_range2 */

3998

3999

#ifdef GL_NV_vertex_program

4000

4001

static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)

4002

{

4003

GLboolean r = GL_FALSE;

4004

4005

r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;

4006

r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;

4007

r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;

4008

r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;

4009

r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;

4010

r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;

4011

r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;

4012

r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;

4013

r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;

4014

r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;

4015

r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;

4016

r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;

4017

r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;

4018

r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;

4019

r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;

4020

r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;

4021

r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;

4022

r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;

4023

r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;

4024

r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;

4025

r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;

4026

r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;

4027

r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;

4028

r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;

4029

r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;

4030

r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;

4031

r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;

4032

r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;

4033

r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;

4034

r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;

4035

r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;

4036

r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;

4037

r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;

4038

r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;

4039

r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;

4040

r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;

4041

r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;

4042

r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;

4043

r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;

4044

r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;

4045

r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;

4046

r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;

4047

r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;

4048

r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;

4049

r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;

4050

r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;

4051

r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;

4052

r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;

4053

r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;

4054

r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;

4055

r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;

4056

r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;

4057

r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;

4058

r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;

4059

r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;

4060

r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;

4061

r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;

4062

r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;

4063

r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;

4064

r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;

4065

r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;

4066

r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;

4067

r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;

4068

r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;

4069

4070

return r;

4071

}

4072

4073

#endif /* GL_NV_vertex_program */

4074

4075

#ifdef GL_NV_vertex_program1_1

4076

4077

#endif /* GL_NV_vertex_program1_1 */

4078

4079

#ifdef GL_NV_vertex_program2

4080

4081

#endif /* GL_NV_vertex_program2 */

4082

4083

#ifdef GL_NV_vertex_program2_option

4084

4085

#endif /* GL_NV_vertex_program2_option */

4086

4087

#ifdef GL_NV_vertex_program3

4088

4089

#endif /* GL_NV_vertex_program3 */

4090

4091

#ifdef GL_OML_interlace

4092

4093

#endif /* GL_OML_interlace */

4094

4095

#ifdef GL_OML_resample

4096

4097

#endif /* GL_OML_resample */

4098

4099

#ifdef GL_OML_subsample

4100

4101

#endif /* GL_OML_subsample */

4102

4103

#ifdef GL_PGI_misc_hints

4104

4105

#endif /* GL_PGI_misc_hints */

4106

4107

#ifdef GL_PGI_vertex_hints

4108

4109

#endif /* GL_PGI_vertex_hints */

4110

4111

#ifdef GL_REND_screen_coordinates

4112

4113

#endif /* GL_REND_screen_coordinates */

4114

4115

#ifdef GL_S3_s3tc

4116

4117

#endif /* GL_S3_s3tc */

4118

4119

#ifdef GL_SGIS_color_range

4120

4121

#endif /* GL_SGIS_color_range */

4122

4123

#ifdef GL_SGIS_detail_texture

4124

4125

static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4126

{

4127

GLboolean r = GL_FALSE;

4128

4129

r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;

4130

r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;

4131

4132

return r;

4133

}

4134

4135

#endif /* GL_SGIS_detail_texture */

4136

4137

#ifdef GL_SGIS_fog_function

4138

4139

static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT)

4140

{

4141

GLboolean r = GL_FALSE;

4142

4143

r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;

4144

r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;

4145

4146

return r;

4147

}

4148

4149

#endif /* GL_SGIS_fog_function */

4150

4151

#ifdef GL_SGIS_generate_mipmap

4152

4153

#endif /* GL_SGIS_generate_mipmap */

4154

4155

#ifdef GL_SGIS_multisample

4156

4157

static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT)

4158

{

4159

GLboolean r = GL_FALSE;

4160

4161

r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;

4162

r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;

4163

4164

return r;

4165

}

4166

4167

#endif /* GL_SGIS_multisample */

4168

4169

#ifdef GL_SGIS_pixel_texture

4170

4171

#endif /* GL_SGIS_pixel_texture */

4172

4173

#ifdef GL_SGIS_sharpen_texture

4174

4175

static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4176

{

4177

GLboolean r = GL_FALSE;

4178

4179

r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;

4180

r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;

4181

4182

return r;

4183

}

4184

4185

#endif /* GL_SGIS_sharpen_texture */

4186

4187

#ifdef GL_SGIS_texture4D

4188

4189

static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT)

4190

{

4191

GLboolean r = GL_FALSE;

4192

4193

r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;

4194

r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;

4195

4196

return r;

4197

}

4198

4199

#endif /* GL_SGIS_texture4D */

4200

4201

#ifdef GL_SGIS_texture_border_clamp

4202

4203

#endif /* GL_SGIS_texture_border_clamp */

4204

4205

#ifdef GL_SGIS_texture_edge_clamp

4206

4207

#endif /* GL_SGIS_texture_edge_clamp */

4208

4209

#ifdef GL_SGIS_texture_filter4

4210

4211

static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT)

4212

{

4213

GLboolean r = GL_FALSE;

4214

4215

r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;

4216

r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;

4217

4218

return r;

4219

}

4220

4221

#endif /* GL_SGIS_texture_filter4 */

4222

4223

#ifdef GL_SGIS_texture_lod

4224

4225

#endif /* GL_SGIS_texture_lod */

4226

4227

#ifdef GL_SGIS_texture_select

4228

4229

#endif /* GL_SGIS_texture_select */

4230

4231

#ifdef GL_SGIX_async

4232

4233

static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT)

4234

{

4235

GLboolean r = GL_FALSE;

4236

4237

r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;

4238

r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;

4239

r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;

4240

r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;

4241

r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;

4242

r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;

4243

4244

return r;

4245

}

4246

4247

#endif /* GL_SGIX_async */

4248

4249

#ifdef GL_SGIX_async_histogram

4250

4251

#endif /* GL_SGIX_async_histogram */

4252

4253

#ifdef GL_SGIX_async_pixel

4254

4255

#endif /* GL_SGIX_async_pixel */

4256

4257

#ifdef GL_SGIX_blend_alpha_minmax

4258

4259

#endif /* GL_SGIX_blend_alpha_minmax */

4260

4261

#ifdef GL_SGIX_clipmap

4262

4263

#endif /* GL_SGIX_clipmap */

4264

4265

#ifdef GL_SGIX_depth_texture

4266

4267

#endif /* GL_SGIX_depth_texture */

4268

4269

#ifdef GL_SGIX_flush_raster

4270

4271

static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT)

4272

{

4273

GLboolean r = GL_FALSE;

4274

4275

r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;

4276

4277

return r;

4278

}

4279

4280

#endif /* GL_SGIX_flush_raster */

4281

4282

#ifdef GL_SGIX_fog_offset

4283

4284

#endif /* GL_SGIX_fog_offset */

4285

4286

#ifdef GL_SGIX_fog_texture

4287

4288

static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4289

{

4290

GLboolean r = GL_FALSE;

4291

4292

r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;

4293

4294

return r;

4295

}

4296

4297

#endif /* GL_SGIX_fog_texture */

4298

4299

#ifdef GL_SGIX_fragment_specular_lighting

4300

4301

static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT)

4302

{

4303

GLboolean r = GL_FALSE;

4304

4305

r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;

4306

r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;

4307

r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;

4308

r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;

4309

r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;

4310

r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;

4311

r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;

4312

r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;

4313

r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;

4314

r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;

4315

r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;

4316

r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;

4317

r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;

4318

r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;

4319

r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;

4320

r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;

4321

r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;

4322

4323

return r;

4324

}

4325

4326

#endif /* GL_SGIX_fragment_specular_lighting */

4327

4328

#ifdef GL_SGIX_framezoom

4329

4330

static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT)

4331

{

4332

GLboolean r = GL_FALSE;

4333

4334

r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;

4335

4336

return r;

4337

}

4338

4339

#endif /* GL_SGIX_framezoom */

4340

4341

#ifdef GL_SGIX_interlace

4342

4343

#endif /* GL_SGIX_interlace */

4344

4345

#ifdef GL_SGIX_ir_instrument1

4346

4347

#endif /* GL_SGIX_ir_instrument1 */

4348

4349

#ifdef GL_SGIX_list_priority

4350

4351

#endif /* GL_SGIX_list_priority */

4352

4353

#ifdef GL_SGIX_pixel_texture

4354

4355

static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT)

4356

{

4357

GLboolean r = GL_FALSE;

4358

4359

r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;

4360

4361

return r;

4362

}

4363

4364

#endif /* GL_SGIX_pixel_texture */

4365

4366

#ifdef GL_SGIX_pixel_texture_bits

4367

4368

#endif /* GL_SGIX_pixel_texture_bits */

4369

4370

#ifdef GL_SGIX_reference_plane

4371

4372

static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT)

4373

{

4374

GLboolean r = GL_FALSE;

4375

4376

r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;

4377

4378

return r;

4379

}

4380

4381

#endif /* GL_SGIX_reference_plane */

4382

4383

#ifdef GL_SGIX_resample

4384

4385

#endif /* GL_SGIX_resample */

4386

4387

#ifdef GL_SGIX_shadow

4388

4389

#endif /* GL_SGIX_shadow */

4390

4391

#ifdef GL_SGIX_shadow_ambient

4392

4393

#endif /* GL_SGIX_shadow_ambient */

4394

4395

#ifdef GL_SGIX_sprite

4396

4397

static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT)

4398

{

4399

GLboolean r = GL_FALSE;

4400

4401

r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;

4402

r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;

4403

r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;

4404

r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;

4405

4406

return r;

4407

}

4408

4409

#endif /* GL_SGIX_sprite */

4410

4411

#ifdef GL_SGIX_tag_sample_buffer

4412

4413

static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT)

4414

{

4415

GLboolean r = GL_FALSE;

4416

4417

r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;

4418

4419

return r;

4420

}

4421

4422

#endif /* GL_SGIX_tag_sample_buffer */

4423

4424

#ifdef GL_SGIX_texture_add_env

4425

4426

#endif /* GL_SGIX_texture_add_env */

4427

4428

#ifdef GL_SGIX_texture_coordinate_clamp

4429

4430

#endif /* GL_SGIX_texture_coordinate_clamp */

4431

4432

#ifdef GL_SGIX_texture_lod_bias

4433

4434

#endif /* GL_SGIX_texture_lod_bias */

4435

4436

#ifdef GL_SGIX_texture_multi_buffer

4437

4438

#endif /* GL_SGIX_texture_multi_buffer */

4439

4440

#ifdef GL_SGIX_texture_range

4441

4442

#endif /* GL_SGIX_texture_range */

4443

4444

#ifdef GL_SGIX_texture_scale_bias

4445

4446

#endif /* GL_SGIX_texture_scale_bias */

4447

4448

#ifdef GL_SGIX_vertex_preclip

4449

4450

#endif /* GL_SGIX_vertex_preclip */

4451

4452

#ifdef GL_SGIX_vertex_preclip_hint

4453

4454

#endif /* GL_SGIX_vertex_preclip_hint */

4455

4456

#ifdef GL_SGIX_ycrcb

4457

4458

#endif /* GL_SGIX_ycrcb */

4459

4460

#ifdef GL_SGI_color_matrix

4461

4462

#endif /* GL_SGI_color_matrix */

4463

4464

#ifdef GL_SGI_color_table

4465

4466

static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT)

4467

{

4468

GLboolean r = GL_FALSE;

4469

4470

r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;

4471

r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;

4472

r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;

4473

r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;

4474

r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;

4475

r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;

4476

r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;

4477

4478

return r;

4479

}

4480

4481

#endif /* GL_SGI_color_table */

4482

4483

#ifdef GL_SGI_texture_color_table

4484

4485

#endif /* GL_SGI_texture_color_table */

4486

4487

#ifdef GL_SUNX_constant_data

4488

4489

static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT)

4490

{

4491

GLboolean r = GL_FALSE;

4492

4493

r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;

4494

4495

return r;

4496

}

4497

4498

#endif /* GL_SUNX_constant_data */

4499

4500

#ifdef GL_SUN_convolution_border_modes

4501

4502

#endif /* GL_SUN_convolution_border_modes */

4503

4504

#ifdef GL_SUN_global_alpha

4505

4506

static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT)

4507

{

4508

GLboolean r = GL_FALSE;

4509

4510

r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;

4511

r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;

4512

r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;

4513

r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;

4514

r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;

4515

r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;

4516

r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;

4517

r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;

4518

4519

return r;

4520

}

4521

4522

#endif /* GL_SUN_global_alpha */

4523

4524

#ifdef GL_SUN_mesh_array

4525

4526

#endif /* GL_SUN_mesh_array */

4527

4528

#ifdef GL_SUN_read_video_pixels

4529

4530

static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT)

4531

{

4532

GLboolean r = GL_FALSE;

4533

4534

r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;

4535

4536

return r;

4537

}

4538

4539

#endif /* GL_SUN_read_video_pixels */

4540

4541

#ifdef GL_SUN_slice_accum

4542

4543

#endif /* GL_SUN_slice_accum */

4544

4545

#ifdef GL_SUN_triangle_list

4546

4547

static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT)

4548

{

4549

GLboolean r = GL_FALSE;

4550

4551

r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;

4552

r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;

4553

r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;

4554

r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;

4555

r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;

4556

r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;

4557

r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;

4558

4559

return r;

4560

}

4561

4562

#endif /* GL_SUN_triangle_list */

4563

4564

#ifdef GL_SUN_vertex

4565

4566

static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT)

4567

{

4568

GLboolean r = GL_FALSE;

4569

4570

r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;

4571

r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;

4572

r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;

4573

r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;

4574

r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;

4575

r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;

4576

r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;

4577

r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;

4578

r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;

4579

r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;

4580

r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;

4581

r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;

4582

r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;

4583

r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;

4584

r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;

4585

r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;

4586

r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;

4587

r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;

4588

r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

4589

r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

4590

r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

4591

r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

4592

r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;

4593

r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;

4594

r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;

4595

r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;

4596

r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;

4597

r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;

4598

r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;

4599

r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;

4600

r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;

4601

r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;

4602

r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;

4603

r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;

4604

r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;

4605

r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;

4606

r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;

4607

r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;

4608

r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;

4609

r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;

4610

4611

return r;

4612

}

4613

4614

#endif /* GL_SUN_vertex */

4615

4616

#ifdef GL_WIN_phong_shading

4617

4618

#endif /* GL_WIN_phong_shading */

4619

4620

#ifdef GL_WIN_specular_fog

4621

4622

#endif /* GL_WIN_specular_fog */

4623

4624

#ifdef GL_WIN_swap_hint

4625

4626

static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT)

4627

{

4628

GLboolean r = GL_FALSE;

4629

4630

r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;

4631

4632

return r;

4633

}

4634

4635

#endif /* GL_WIN_swap_hint */

4636

4637

/* ------------------------------------------------------------------------- */

4638

4639

/*

4640

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

4641

* is not sufficient because extension names can be prefixes of

4642

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

4643

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

4644

*/

4645

GLboolean glewGetExtension (const char* name)

4646

{

4647

GLubyte* p;

4648

GLubyte* end;

4649

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

4650

p = (GLubyte*)glGetString(GL_EXTENSIONS);

4651

if (0 == p) return GL_FALSE;

4652

end = p + _glewStrLen(p);

4653

while (p < end)

4654

{

4655

GLuint n = _glewStrCLen(p, ' ');

4656

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

4657

p += n+1;

4658

}

4659

return GL_FALSE;

4660

}

4661

4662

/* ------------------------------------------------------------------------- */

4663

4664

#ifndef GLEW_MX

4665

static

4666

#endif

4667

GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)

4668

{

4669

const GLubyte* s;

4670

GLuint major, minor;

4671

/* query opengl version */

4672

s = glGetString(GL_VERSION);

4673

if (!s) return GLEW_ERROR_NO_GL_VERSION;

4674

major = _glewStrCLen(s, '.')-1;

4675

minor = _glewStrCLen(s, '.')+1;

4676

4677

if (s+major == NULL

4678

|| s+minor-1 == NULL || s+minor == NULL

4679

|| (s[major] == 1 && s[minor] < '1'))

4680

{

4681

return GLEW_ERROR_GL_VERSION_10_ONLY;

4682

}

4683

else

4684

{

4685

if (s[major] >= '2')

4686

{

4687

GLEW_VERSION_1_1 = GL_TRUE;

4688

GLEW_VERSION_1_2 = GL_TRUE;

4689

GLEW_VERSION_1_3 = GL_TRUE;

4690

GLEW_VERSION_1_4 = GL_TRUE;

4691

GLEW_VERSION_1_5 = GL_TRUE;

4692

GLEW_VERSION_2_0 = GL_TRUE;

4693

}

4694

else

4695

{

4696

if (s[minor] >= '5')

4697

{

4698

GLEW_VERSION_1_1 = GL_TRUE;

4699

GLEW_VERSION_1_2 = GL_TRUE;

4700

GLEW_VERSION_1_3 = GL_TRUE;

4701

GLEW_VERSION_1_4 = GL_TRUE;

4702

GLEW_VERSION_1_5 = GL_TRUE;

4703

GLEW_VERSION_2_0 = GL_FALSE;

4704

}

4705

if (s[minor] == '4')

4706

{

4707

GLEW_VERSION_1_1 = GL_TRUE;

4708

GLEW_VERSION_1_2 = GL_TRUE;

4709

GLEW_VERSION_1_3 = GL_TRUE;

4710

GLEW_VERSION_1_4 = GL_TRUE;

4711

GLEW_VERSION_1_5 = GL_FALSE;

4712

GLEW_VERSION_2_0 = GL_FALSE;

4713

}

4714

if (s[minor] == '3')

4715

{

4716

GLEW_VERSION_1_1 = GL_TRUE;

4717

GLEW_VERSION_1_2 = GL_TRUE;

4718

GLEW_VERSION_1_3 = GL_TRUE;

4719

GLEW_VERSION_1_4 = GL_FALSE;

4720

GLEW_VERSION_1_5 = GL_FALSE;

4721

GLEW_VERSION_2_0 = GL_FALSE;

4722

}

4723

if (s[minor] == '2')

4724

{

4725

GLEW_VERSION_1_1 = GL_TRUE;

4726

GLEW_VERSION_1_2 = GL_TRUE;

4727

GLEW_VERSION_1_3 = GL_FALSE;

4728

GLEW_VERSION_1_4 = GL_FALSE;

4729

GLEW_VERSION_1_5 = GL_FALSE;

4730

GLEW_VERSION_2_0 = GL_FALSE;

4731

}

4732

if (s[minor] < '2')

4733

{

4734

GLEW_VERSION_1_1 = GL_TRUE;

4735

GLEW_VERSION_1_2 = GL_FALSE;

4736

GLEW_VERSION_1_3 = GL_FALSE;

4737

GLEW_VERSION_1_4 = GL_FALSE;

4738

GLEW_VERSION_1_5 = GL_FALSE;

4739

GLEW_VERSION_2_0 = GL_FALSE;

4740

}

4741

}

4742

}

4743

/* initialize extensions */

4744

#ifdef GL_VERSION_1_2

4745

if (glewExperimental || GLEW_VERSION_1_2) GLEW_VERSION_1_2 = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);

4746

#endif /* GL_VERSION_1_2 */

4747

#ifdef GL_VERSION_1_3

4748

if (glewExperimental || GLEW_VERSION_1_3) GLEW_VERSION_1_3 = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);

4749

#endif /* GL_VERSION_1_3 */

4750

#ifdef GL_VERSION_1_4

4751

if (glewExperimental || GLEW_VERSION_1_4) GLEW_VERSION_1_4 = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);

4752

#endif /* GL_VERSION_1_4 */

4753

#ifdef GL_VERSION_1_5

4754

if (glewExperimental || GLEW_VERSION_1_5) GLEW_VERSION_1_5 = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);

4755

#endif /* GL_VERSION_1_5 */

4756

#ifdef GL_VERSION_2_0

4757

if (glewExperimental || GLEW_VERSION_2_0) GLEW_VERSION_2_0 = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);

4758

#endif /* GL_VERSION_2_0 */

4759

#ifdef GL_3DFX_multisample

4760

GLEW_3DFX_multisample = glewGetExtension("GL_3DFX_multisample");

4761

#endif /* GL_3DFX_multisample */

4762

#ifdef GL_3DFX_tbuffer

4763

GLEW_3DFX_tbuffer = glewGetExtension("GL_3DFX_tbuffer");

4764

if (glewExperimental || GLEW_3DFX_tbuffer) GLEW_3DFX_tbuffer = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

4765

#endif /* GL_3DFX_tbuffer */

4766

#ifdef GL_3DFX_texture_compression_FXT1

4767

GLEW_3DFX_texture_compression_FXT1 = glewGetExtension("GL_3DFX_texture_compression_FXT1");

4768

#endif /* GL_3DFX_texture_compression_FXT1 */

4769

#ifdef GL_APPLE_client_storage

4770

GLEW_APPLE_client_storage = glewGetExtension("GL_APPLE_client_storage");

4771

#endif /* GL_APPLE_client_storage */

4772

#ifdef GL_APPLE_element_array

4773

GLEW_APPLE_element_array = glewGetExtension("GL_APPLE_element_array");

4774

if (glewExperimental || GLEW_APPLE_element_array) GLEW_APPLE_element_array = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT);

4775

#endif /* GL_APPLE_element_array */

4776

#ifdef GL_APPLE_fence

4777

GLEW_APPLE_fence = glewGetExtension("GL_APPLE_fence");

4778

if (glewExperimental || GLEW_APPLE_fence) GLEW_APPLE_fence = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT);

4779

#endif /* GL_APPLE_fence */

4780

#ifdef GL_APPLE_float_pixels

4781

GLEW_APPLE_float_pixels = glewGetExtension("GL_APPLE_float_pixels");

4782

#endif /* GL_APPLE_float_pixels */

4783

#ifdef GL_APPLE_specular_vector

4784

GLEW_APPLE_specular_vector = glewGetExtension("GL_APPLE_specular_vector");

4785

#endif /* GL_APPLE_specular_vector */

4786

#ifdef GL_APPLE_texture_range

4787

GLEW_APPLE_texture_range = glewGetExtension("GL_APPLE_texture_range");

4788

if (glewExperimental || GLEW_APPLE_texture_range) GLEW_APPLE_texture_range = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT);

4789

#endif /* GL_APPLE_texture_range */

4790

#ifdef GL_APPLE_transform_hint

4791

GLEW_APPLE_transform_hint = glewGetExtension("GL_APPLE_transform_hint");

4792

#endif /* GL_APPLE_transform_hint */

4793

#ifdef GL_APPLE_vertex_array_object

4794

GLEW_APPLE_vertex_array_object = glewGetExtension("GL_APPLE_vertex_array_object");

4795

if (glewExperimental || GLEW_APPLE_vertex_array_object) GLEW_APPLE_vertex_array_object = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

4796

#endif /* GL_APPLE_vertex_array_object */

4797

#ifdef GL_APPLE_vertex_array_range

4798

GLEW_APPLE_vertex_array_range = glewGetExtension("GL_APPLE_vertex_array_range");

4799

if (glewExperimental || GLEW_APPLE_vertex_array_range) GLEW_APPLE_vertex_array_range = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

4800

#endif /* GL_APPLE_vertex_array_range */

4801

#ifdef GL_APPLE_ycbcr_422

4802

GLEW_APPLE_ycbcr_422 = glewGetExtension("GL_APPLE_ycbcr_422");

4803

#endif /* GL_APPLE_ycbcr_422 */

4804

#ifdef GL_ARB_color_buffer_float

4805

GLEW_ARB_color_buffer_float = glewGetExtension("GL_ARB_color_buffer_float");

4806

if (glewExperimental || GLEW_ARB_color_buffer_float) GLEW_ARB_color_buffer_float = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);

4807

#endif /* GL_ARB_color_buffer_float */

4808

#ifdef GL_ARB_depth_texture

4809

GLEW_ARB_depth_texture = glewGetExtension("GL_ARB_depth_texture");

4810

#endif /* GL_ARB_depth_texture */

4811

#ifdef GL_ARB_draw_buffers

4812

GLEW_ARB_draw_buffers = glewGetExtension("GL_ARB_draw_buffers");

4813

if (glewExperimental || GLEW_ARB_draw_buffers) GLEW_ARB_draw_buffers = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

4814

#endif /* GL_ARB_draw_buffers */

4815

#ifdef GL_ARB_fragment_program

4816

GLEW_ARB_fragment_program = glewGetExtension("GL_ARB_fragment_program");

4817

#endif /* GL_ARB_fragment_program */

4818

#ifdef GL_ARB_fragment_program_shadow

4819

GLEW_ARB_fragment_program_shadow = glewGetExtension("GL_ARB_fragment_program_shadow");

4820

#endif /* GL_ARB_fragment_program_shadow */

4821

#ifdef GL_ARB_fragment_shader

4822

GLEW_ARB_fragment_shader = glewGetExtension("GL_ARB_fragment_shader");

4823

#endif /* GL_ARB_fragment_shader */

4824

#ifdef GL_ARB_half_float_pixel

4825

GLEW_ARB_half_float_pixel = glewGetExtension("GL_ARB_half_float_pixel");

4826

#endif /* GL_ARB_half_float_pixel */

4827

#ifdef GL_ARB_imaging

4828

GLEW_ARB_imaging = glewGetExtension("GL_ARB_imaging");

4829

if (glewExperimental || GLEW_ARB_imaging) GLEW_ARB_imaging = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT);

4830

#endif /* GL_ARB_imaging */

4831

#ifdef GL_ARB_matrix_palette

4832

GLEW_ARB_matrix_palette = glewGetExtension("GL_ARB_matrix_palette");

4833

if (glewExperimental || GLEW_ARB_matrix_palette) GLEW_ARB_matrix_palette = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT);

4834

#endif /* GL_ARB_matrix_palette */

4835

#ifdef GL_ARB_multisample

4836

GLEW_ARB_multisample = glewGetExtension("GL_ARB_multisample");

4837

if (glewExperimental || GLEW_ARB_multisample) GLEW_ARB_multisample = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

4838

#endif /* GL_ARB_multisample */

4839

#ifdef GL_ARB_multitexture

4840

GLEW_ARB_multitexture = glewGetExtension("GL_ARB_multitexture");

4841

if (glewExperimental || GLEW_ARB_multitexture) GLEW_ARB_multitexture = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);

4842

#endif /* GL_ARB_multitexture */

4843

#ifdef GL_ARB_occlusion_query

4844

GLEW_ARB_occlusion_query = glewGetExtension("GL_ARB_occlusion_query");

4845

if (glewExperimental || GLEW_ARB_occlusion_query) GLEW_ARB_occlusion_query = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);

4846

#endif /* GL_ARB_occlusion_query */

4847

#ifdef GL_ARB_pixel_buffer_object

4848

GLEW_ARB_pixel_buffer_object = glewGetExtension("GL_ARB_pixel_buffer_object");

4849

#endif /* GL_ARB_pixel_buffer_object */

4850

#ifdef GL_ARB_point_parameters

4851

GLEW_ARB_point_parameters = glewGetExtension("GL_ARB_point_parameters");

4852

if (glewExperimental || GLEW_ARB_point_parameters) GLEW_ARB_point_parameters = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

4853

#endif /* GL_ARB_point_parameters */

4854

#ifdef GL_ARB_point_sprite

4855

GLEW_ARB_point_sprite = glewGetExtension("GL_ARB_point_sprite");

4856

#endif /* GL_ARB_point_sprite */

4857

#ifdef GL_ARB_shader_objects

4858

GLEW_ARB_shader_objects = glewGetExtension("GL_ARB_shader_objects");

4859

if (glewExperimental || GLEW_ARB_shader_objects) GLEW_ARB_shader_objects = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);

4860

#endif /* GL_ARB_shader_objects */

4861

#ifdef GL_ARB_shading_language_100

4862

GLEW_ARB_shading_language_100 = glewGetExtension("GL_ARB_shading_language_100");

4863

#endif /* GL_ARB_shading_language_100 */

4864

#ifdef GL_ARB_shadow

4865

GLEW_ARB_shadow = glewGetExtension("GL_ARB_shadow");

4866

#endif /* GL_ARB_shadow */

4867

#ifdef GL_ARB_shadow_ambient

4868

GLEW_ARB_shadow_ambient = glewGetExtension("GL_ARB_shadow_ambient");

4869

#endif /* GL_ARB_shadow_ambient */

4870

#ifdef GL_ARB_texture_border_clamp

4871

GLEW_ARB_texture_border_clamp = glewGetExtension("GL_ARB_texture_border_clamp");

4872

#endif /* GL_ARB_texture_border_clamp */

4873

#ifdef GL_ARB_texture_compression

4874

GLEW_ARB_texture_compression = glewGetExtension("GL_ARB_texture_compression");

4875

if (glewExperimental || GLEW_ARB_texture_compression) GLEW_ARB_texture_compression = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);

4876

#endif /* GL_ARB_texture_compression */

4877

#ifdef GL_ARB_texture_cube_map

4878

GLEW_ARB_texture_cube_map = glewGetExtension("GL_ARB_texture_cube_map");

4879

#endif /* GL_ARB_texture_cube_map */

4880

#ifdef GL_ARB_texture_env_add

4881

GLEW_ARB_texture_env_add = glewGetExtension("GL_ARB_texture_env_add");

4882

#endif /* GL_ARB_texture_env_add */

4883

#ifdef GL_ARB_texture_env_combine

4884

GLEW_ARB_texture_env_combine = glewGetExtension("GL_ARB_texture_env_combine");

4885

#endif /* GL_ARB_texture_env_combine */

4886

#ifdef GL_ARB_texture_env_crossbar

4887

GLEW_ARB_texture_env_crossbar = glewGetExtension("GL_ARB_texture_env_crossbar");

4888

#endif /* GL_ARB_texture_env_crossbar */

4889

#ifdef GL_ARB_texture_env_dot3

4890

GLEW_ARB_texture_env_dot3 = glewGetExtension("GL_ARB_texture_env_dot3");

4891

#endif /* GL_ARB_texture_env_dot3 */

4892

#ifdef GL_ARB_texture_float

4893

GLEW_ARB_texture_float = glewGetExtension("GL_ARB_texture_float");

4894

#endif /* GL_ARB_texture_float */

4895

#ifdef GL_ARB_texture_mirrored_repeat

4896

GLEW_ARB_texture_mirrored_repeat = glewGetExtension("GL_ARB_texture_mirrored_repeat");

4897

#endif /* GL_ARB_texture_mirrored_repeat */

4898

#ifdef GL_ARB_texture_non_power_of_two

4899

GLEW_ARB_texture_non_power_of_two = glewGetExtension("GL_ARB_texture_non_power_of_two");

4900

#endif /* GL_ARB_texture_non_power_of_two */

4901

#ifdef GL_ARB_texture_rectangle

4902

GLEW_ARB_texture_rectangle = glewGetExtension("GL_ARB_texture_rectangle");

4903

#endif /* GL_ARB_texture_rectangle */

4904

#ifdef GL_ARB_transpose_matrix

4905

GLEW_ARB_transpose_matrix = glewGetExtension("GL_ARB_transpose_matrix");

4906

#endif /* GL_ARB_transpose_matrix */

4907

#ifdef GL_ARB_vertex_blend

4908

GLEW_ARB_vertex_blend = glewGetExtension("GL_ARB_vertex_blend");

4909

if (glewExperimental || GLEW_ARB_vertex_blend) GLEW_ARB_vertex_blend = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT);

4910

#endif /* GL_ARB_vertex_blend */

4911

#ifdef GL_ARB_vertex_buffer_object

4912

GLEW_ARB_vertex_buffer_object = glewGetExtension("GL_ARB_vertex_buffer_object");

4913

if (glewExperimental || GLEW_ARB_vertex_buffer_object) GLEW_ARB_vertex_buffer_object = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

4914

#endif /* GL_ARB_vertex_buffer_object */

4915

#ifdef GL_ARB_vertex_program

4916

GLEW_ARB_vertex_program = glewGetExtension("GL_ARB_vertex_program");

4917

if (glewExperimental || GLEW_ARB_vertex_program) GLEW_ARB_vertex_program = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);

4918

#endif /* GL_ARB_vertex_program */

4919

#ifdef GL_ARB_vertex_shader

4920

GLEW_ARB_vertex_shader = glewGetExtension("GL_ARB_vertex_shader");

4921

if (glewExperimental || GLEW_ARB_vertex_shader) { GLEW_ARB_vertex_shader = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); _glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); }

4922

#endif /* GL_ARB_vertex_shader */

4923

#ifdef GL_ARB_window_pos

4924

GLEW_ARB_window_pos = glewGetExtension("GL_ARB_window_pos");

4925

if (glewExperimental || GLEW_ARB_window_pos) GLEW_ARB_window_pos = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);

4926

#endif /* GL_ARB_window_pos */

4927

#ifdef GL_ATIX_point_sprites

4928

GLEW_ATIX_point_sprites = glewGetExtension("GL_ATIX_point_sprites");

4929

#endif /* GL_ATIX_point_sprites */

4930

#ifdef GL_ATIX_texture_env_combine3

4931

GLEW_ATIX_texture_env_combine3 = glewGetExtension("GL_ATIX_texture_env_combine3");

4932

#endif /* GL_ATIX_texture_env_combine3 */

4933

#ifdef GL_ATIX_texture_env_route

4934

GLEW_ATIX_texture_env_route = glewGetExtension("GL_ATIX_texture_env_route");

4935

#endif /* GL_ATIX_texture_env_route */

4936

#ifdef GL_ATIX_vertex_shader_output_point_size

4937

GLEW_ATIX_vertex_shader_output_point_size = glewGetExtension("GL_ATIX_vertex_shader_output_point_size");

4938

#endif /* GL_ATIX_vertex_shader_output_point_size */

4939

#ifdef GL_ATI_draw_buffers

4940

GLEW_ATI_draw_buffers = glewGetExtension("GL_ATI_draw_buffers");

4941

if (glewExperimental || GLEW_ATI_draw_buffers) GLEW_ATI_draw_buffers = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

4942

#endif /* GL_ATI_draw_buffers */

4943

#ifdef GL_ATI_element_array

4944

GLEW_ATI_element_array = glewGetExtension("GL_ATI_element_array");

4945

if (glewExperimental || GLEW_ATI_element_array) GLEW_ATI_element_array = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT);

4946

#endif /* GL_ATI_element_array */

4947

#ifdef GL_ATI_envmap_bumpmap

4948

GLEW_ATI_envmap_bumpmap = glewGetExtension("GL_ATI_envmap_bumpmap");

4949

if (glewExperimental || GLEW_ATI_envmap_bumpmap) GLEW_ATI_envmap_bumpmap = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT);

4950

#endif /* GL_ATI_envmap_bumpmap */

4951

#ifdef GL_ATI_fragment_shader

4952

GLEW_ATI_fragment_shader = glewGetExtension("GL_ATI_fragment_shader");

4953

if (glewExperimental || GLEW_ATI_fragment_shader) GLEW_ATI_fragment_shader = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);

4954

#endif /* GL_ATI_fragment_shader */

4955

#ifdef GL_ATI_map_object_buffer

4956

GLEW_ATI_map_object_buffer = glewGetExtension("GL_ATI_map_object_buffer");

4957

if (glewExperimental || GLEW_ATI_map_object_buffer) GLEW_ATI_map_object_buffer = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

4958

#endif /* GL_ATI_map_object_buffer */

4959

#ifdef GL_ATI_pn_triangles

4960

GLEW_ATI_pn_triangles = glewGetExtension("GL_ATI_pn_triangles");

4961

if (glewExperimental || GLEW_ATI_pn_triangles) GLEW_ATI_pn_triangles = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);

4962

#endif /* GL_ATI_pn_triangles */

4963

#ifdef GL_ATI_separate_stencil

4964

GLEW_ATI_separate_stencil = glewGetExtension("GL_ATI_separate_stencil");

4965

if (glewExperimental || GLEW_ATI_separate_stencil) GLEW_ATI_separate_stencil = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT);

4966

#endif /* GL_ATI_separate_stencil */

4967

#ifdef GL_ATI_text_fragment_shader

4968

GLEW_ATI_text_fragment_shader = glewGetExtension("GL_ATI_text_fragment_shader");

4969

#endif /* GL_ATI_text_fragment_shader */

4970

#ifdef GL_ATI_texture_compression_3dc

4971

GLEW_ATI_texture_compression_3dc = glewGetExtension("GL_ATI_texture_compression_3dc");

4972

#endif /* GL_ATI_texture_compression_3dc */

4973

#ifdef GL_ATI_texture_env_combine3

4974

GLEW_ATI_texture_env_combine3 = glewGetExtension("GL_ATI_texture_env_combine3");

4975

#endif /* GL_ATI_texture_env_combine3 */

4976

#ifdef GL_ATI_texture_float

4977

GLEW_ATI_texture_float = glewGetExtension("GL_ATI_texture_float");

4978

#endif /* GL_ATI_texture_float */

4979

#ifdef GL_ATI_texture_mirror_once

4980

GLEW_ATI_texture_mirror_once = glewGetExtension("GL_ATI_texture_mirror_once");

4981

#endif /* GL_ATI_texture_mirror_once */

4982

#ifdef GL_ATI_vertex_array_object

4983

GLEW_ATI_vertex_array_object = glewGetExtension("GL_ATI_vertex_array_object");

4984

if (glewExperimental || GLEW_ATI_vertex_array_object) GLEW_ATI_vertex_array_object = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

4985

#endif /* GL_ATI_vertex_array_object */

4986

#ifdef GL_ATI_vertex_attrib_array_object

4987

GLEW_ATI_vertex_attrib_array_object = glewGetExtension("GL_ATI_vertex_attrib_array_object");

4988

if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) GLEW_ATI_vertex_attrib_array_object = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT);

4989

#endif /* GL_ATI_vertex_attrib_array_object */

4990

#ifdef GL_ATI_vertex_streams

4991

GLEW_ATI_vertex_streams = glewGetExtension("GL_ATI_vertex_streams");

4992

if (glewExperimental || GLEW_ATI_vertex_streams) GLEW_ATI_vertex_streams = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT);

4993

#endif /* GL_ATI_vertex_streams */

4994

#ifdef GL_EXT_422_pixels

4995

GLEW_EXT_422_pixels = glewGetExtension("GL_EXT_422_pixels");

4996

#endif /* GL_EXT_422_pixels */

4997

#ifdef GL_EXT_Cg_shader

4998

GLEW_EXT_Cg_shader = glewGetExtension("GL_EXT_Cg_shader");

4999

#endif /* GL_EXT_Cg_shader */

5000

#ifdef GL_EXT_abgr

5001

GLEW_EXT_abgr = glewGetExtension("GL_EXT_abgr");

5002

#endif /* GL_EXT_abgr */

5003

#ifdef GL_EXT_bgra

5004

GLEW_EXT_bgra = glewGetExtension("GL_EXT_bgra");

5005

#endif /* GL_EXT_bgra */

5006

#ifdef GL_EXT_blend_color

5007

GLEW_EXT_blend_color = glewGetExtension("GL_EXT_blend_color");

5008

if (glewExperimental || GLEW_EXT_blend_color) GLEW_EXT_blend_color = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT);

5009

#endif /* GL_EXT_blend_color */

5010

#ifdef GL_EXT_blend_equation_separate

5011

GLEW_EXT_blend_equation_separate = glewGetExtension("GL_EXT_blend_equation_separate");

5012

if (glewExperimental || GLEW_EXT_blend_equation_separate) GLEW_EXT_blend_equation_separate = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT);

5013

#endif /* GL_EXT_blend_equation_separate */

5014

#ifdef GL_EXT_blend_func_separate

5015

GLEW_EXT_blend_func_separate = glewGetExtension("GL_EXT_blend_func_separate");

5016

if (glewExperimental || GLEW_EXT_blend_func_separate) GLEW_EXT_blend_func_separate = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT);

5017

#endif /* GL_EXT_blend_func_separate */

5018

#ifdef GL_EXT_blend_logic_op

5019

GLEW_EXT_blend_logic_op = glewGetExtension("GL_EXT_blend_logic_op");

5020

#endif /* GL_EXT_blend_logic_op */

5021

#ifdef GL_EXT_blend_minmax

5022

GLEW_EXT_blend_minmax = glewGetExtension("GL_EXT_blend_minmax");

5023

if (glewExperimental || GLEW_EXT_blend_minmax) GLEW_EXT_blend_minmax = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT);

5024

#endif /* GL_EXT_blend_minmax */

5025

#ifdef GL_EXT_blend_subtract

5026

GLEW_EXT_blend_subtract = glewGetExtension("GL_EXT_blend_subtract");

5027

#endif /* GL_EXT_blend_subtract */

5028

#ifdef GL_EXT_clip_volume_hint

5029

GLEW_EXT_clip_volume_hint = glewGetExtension("GL_EXT_clip_volume_hint");

5030

#endif /* GL_EXT_clip_volume_hint */

5031

#ifdef GL_EXT_cmyka

5032

GLEW_EXT_cmyka = glewGetExtension("GL_EXT_cmyka");

5033

#endif /* GL_EXT_cmyka */

5034

#ifdef GL_EXT_color_subtable

5035

GLEW_EXT_color_subtable = glewGetExtension("GL_EXT_color_subtable");

5036

if (glewExperimental || GLEW_EXT_color_subtable) GLEW_EXT_color_subtable = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT);

5037

#endif /* GL_EXT_color_subtable */

5038

#ifdef GL_EXT_compiled_vertex_array

5039

GLEW_EXT_compiled_vertex_array = glewGetExtension("GL_EXT_compiled_vertex_array");

5040

if (glewExperimental || GLEW_EXT_compiled_vertex_array) GLEW_EXT_compiled_vertex_array = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);

5041

#endif /* GL_EXT_compiled_vertex_array */

5042

#ifdef GL_EXT_convolution

5043

GLEW_EXT_convolution = glewGetExtension("GL_EXT_convolution");

5044

if (glewExperimental || GLEW_EXT_convolution) GLEW_EXT_convolution = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT);

5045

#endif /* GL_EXT_convolution */

5046

#ifdef GL_EXT_coordinate_frame

5047

GLEW_EXT_coordinate_frame = glewGetExtension("GL_EXT_coordinate_frame");

5048

if (glewExperimental || GLEW_EXT_coordinate_frame) GLEW_EXT_coordinate_frame = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT);

5049

#endif /* GL_EXT_coordinate_frame */

5050

#ifdef GL_EXT_copy_texture

5051

GLEW_EXT_copy_texture = glewGetExtension("GL_EXT_copy_texture");

5052

if (glewExperimental || GLEW_EXT_copy_texture) GLEW_EXT_copy_texture = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5053

#endif /* GL_EXT_copy_texture */

5054

#ifdef GL_EXT_cull_vertex

5055

GLEW_EXT_cull_vertex = glewGetExtension("GL_EXT_cull_vertex");

5056

if (glewExperimental || GLEW_EXT_cull_vertex) GLEW_EXT_cull_vertex = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT);

5057

#endif /* GL_EXT_cull_vertex */

5058

#ifdef GL_EXT_depth_bounds_test

5059

GLEW_EXT_depth_bounds_test = glewGetExtension("GL_EXT_depth_bounds_test");

5060

if (glewExperimental || GLEW_EXT_depth_bounds_test) GLEW_EXT_depth_bounds_test = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT);

5061

#endif /* GL_EXT_depth_bounds_test */

5062

#ifdef GL_EXT_draw_range_elements

5063

GLEW_EXT_draw_range_elements = glewGetExtension("GL_EXT_draw_range_elements");

5064

if (glewExperimental || GLEW_EXT_draw_range_elements) GLEW_EXT_draw_range_elements = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT);

5065

#endif /* GL_EXT_draw_range_elements */

5066

#ifdef GL_EXT_fog_coord

5067

GLEW_EXT_fog_coord = glewGetExtension("GL_EXT_fog_coord");

5068

if (glewExperimental || GLEW_EXT_fog_coord) GLEW_EXT_fog_coord = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT);

5069

#endif /* GL_EXT_fog_coord */

5070

#ifdef GL_EXT_fragment_lighting

5071

GLEW_EXT_fragment_lighting = glewGetExtension("GL_EXT_fragment_lighting");

5072

if (glewExperimental || GLEW_EXT_fragment_lighting) GLEW_EXT_fragment_lighting = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT);

5073

#endif /* GL_EXT_fragment_lighting */

5074

#ifdef GL_EXT_framebuffer_object

5075

GLEW_EXT_framebuffer_object = glewGetExtension("GL_EXT_framebuffer_object");

5076

if (glewExperimental || GLEW_EXT_framebuffer_object) GLEW_EXT_framebuffer_object = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);

5077

#endif /* GL_EXT_framebuffer_object */

5078

#ifdef GL_EXT_histogram

5079

GLEW_EXT_histogram = glewGetExtension("GL_EXT_histogram");

5080

if (glewExperimental || GLEW_EXT_histogram) GLEW_EXT_histogram = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT);

5081

#endif /* GL_EXT_histogram */

5082

#ifdef GL_EXT_index_array_formats

5083

GLEW_EXT_index_array_formats = glewGetExtension("GL_EXT_index_array_formats");

5084

#endif /* GL_EXT_index_array_formats */

5085

#ifdef GL_EXT_index_func

5086

GLEW_EXT_index_func = glewGetExtension("GL_EXT_index_func");

5087

if (glewExperimental || GLEW_EXT_index_func) GLEW_EXT_index_func = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT);

5088

#endif /* GL_EXT_index_func */

5089

#ifdef GL_EXT_index_material

5090

GLEW_EXT_index_material = glewGetExtension("GL_EXT_index_material");

5091

if (glewExperimental || GLEW_EXT_index_material) GLEW_EXT_index_material = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT);

5092

#endif /* GL_EXT_index_material */

5093

#ifdef GL_EXT_index_texture

5094

GLEW_EXT_index_texture = glewGetExtension("GL_EXT_index_texture");

5095

#endif /* GL_EXT_index_texture */

5096

#ifdef GL_EXT_light_texture

5097

GLEW_EXT_light_texture = glewGetExtension("GL_EXT_light_texture");

5098

if (glewExperimental || GLEW_EXT_light_texture) GLEW_EXT_light_texture = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5099

#endif /* GL_EXT_light_texture */

5100

#ifdef GL_EXT_misc_attribute

5101

GLEW_EXT_misc_attribute = glewGetExtension("GL_EXT_misc_attribute");

5102

#endif /* GL_EXT_misc_attribute */

5103

#ifdef GL_EXT_multi_draw_arrays

5104

GLEW_EXT_multi_draw_arrays = glewGetExtension("GL_EXT_multi_draw_arrays");

5105

if (glewExperimental || GLEW_EXT_multi_draw_arrays) GLEW_EXT_multi_draw_arrays = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

5106

#endif /* GL_EXT_multi_draw_arrays */

5107

#ifdef GL_EXT_multisample

5108

GLEW_EXT_multisample = glewGetExtension("GL_EXT_multisample");

5109

if (glewExperimental || GLEW_EXT_multisample) GLEW_EXT_multisample = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

5110

#endif /* GL_EXT_multisample */

5111

#ifdef GL_EXT_packed_pixels

5112

GLEW_EXT_packed_pixels = glewGetExtension("GL_EXT_packed_pixels");

5113

#endif /* GL_EXT_packed_pixels */

5114

#ifdef GL_EXT_paletted_texture

5115

GLEW_EXT_paletted_texture = glewGetExtension("GL_EXT_paletted_texture");

5116

if (glewExperimental || GLEW_EXT_paletted_texture) GLEW_EXT_paletted_texture = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5117

#endif /* GL_EXT_paletted_texture */

5118

#ifdef GL_EXT_pixel_buffer_object

5119

GLEW_EXT_pixel_buffer_object = glewGetExtension("GL_EXT_pixel_buffer_object");

5120

#endif /* GL_EXT_pixel_buffer_object */

5121

#ifdef GL_EXT_pixel_transform

5122

GLEW_EXT_pixel_transform = glewGetExtension("GL_EXT_pixel_transform");

5123

if (glewExperimental || GLEW_EXT_pixel_transform) GLEW_EXT_pixel_transform = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT);

5124

#endif /* GL_EXT_pixel_transform */

5125

#ifdef GL_EXT_pixel_transform_color_table

5126

GLEW_EXT_pixel_transform_color_table = glewGetExtension("GL_EXT_pixel_transform_color_table");

5127

#endif /* GL_EXT_pixel_transform_color_table */

5128

#ifdef GL_EXT_point_parameters

5129

GLEW_EXT_point_parameters = glewGetExtension("GL_EXT_point_parameters");

5130

if (glewExperimental || GLEW_EXT_point_parameters) GLEW_EXT_point_parameters = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);

5131

#endif /* GL_EXT_point_parameters */

5132

#ifdef GL_EXT_polygon_offset

5133

GLEW_EXT_polygon_offset = glewGetExtension("GL_EXT_polygon_offset");

5134

if (glewExperimental || GLEW_EXT_polygon_offset) GLEW_EXT_polygon_offset = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);

5135

#endif /* GL_EXT_polygon_offset */

5136

#ifdef GL_EXT_rescale_normal

5137

GLEW_EXT_rescale_normal = glewGetExtension("GL_EXT_rescale_normal");

5138

#endif /* GL_EXT_rescale_normal */

5139

#ifdef GL_EXT_scene_marker

5140

GLEW_EXT_scene_marker = glewGetExtension("GL_EXT_scene_marker");

5141

if (glewExperimental || GLEW_EXT_scene_marker) GLEW_EXT_scene_marker = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT);

5142

#endif /* GL_EXT_scene_marker */

5143

#ifdef GL_EXT_secondary_color

5144

GLEW_EXT_secondary_color = glewGetExtension("GL_EXT_secondary_color");

5145

if (glewExperimental || GLEW_EXT_secondary_color) GLEW_EXT_secondary_color = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);

5146

#endif /* GL_EXT_secondary_color */

5147

#ifdef GL_EXT_separate_specular_color

5148

GLEW_EXT_separate_specular_color = glewGetExtension("GL_EXT_separate_specular_color");

5149

#endif /* GL_EXT_separate_specular_color */

5150

#ifdef GL_EXT_shadow_funcs

5151

GLEW_EXT_shadow_funcs = glewGetExtension("GL_EXT_shadow_funcs");

5152

#endif /* GL_EXT_shadow_funcs */

5153

#ifdef GL_EXT_shared_texture_palette

5154

GLEW_EXT_shared_texture_palette = glewGetExtension("GL_EXT_shared_texture_palette");

5155

#endif /* GL_EXT_shared_texture_palette */

5156

#ifdef GL_EXT_stencil_two_side

5157

GLEW_EXT_stencil_two_side = glewGetExtension("GL_EXT_stencil_two_side");

5158

if (glewExperimental || GLEW_EXT_stencil_two_side) GLEW_EXT_stencil_two_side = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT);

5159

#endif /* GL_EXT_stencil_two_side */

5160

#ifdef GL_EXT_stencil_wrap

5161

GLEW_EXT_stencil_wrap = glewGetExtension("GL_EXT_stencil_wrap");

5162

#endif /* GL_EXT_stencil_wrap */

5163

#ifdef GL_EXT_subtexture

5164

GLEW_EXT_subtexture = glewGetExtension("GL_EXT_subtexture");

5165

if (glewExperimental || GLEW_EXT_subtexture) GLEW_EXT_subtexture = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT);

5166

#endif /* GL_EXT_subtexture */

5167

#ifdef GL_EXT_texture

5168

GLEW_EXT_texture = glewGetExtension("GL_EXT_texture");

5169

#endif /* GL_EXT_texture */

5170

#ifdef GL_EXT_texture3D

5171

GLEW_EXT_texture3D = glewGetExtension("GL_EXT_texture3D");

5172

if (glewExperimental || GLEW_EXT_texture3D) GLEW_EXT_texture3D = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT);

5173

#endif /* GL_EXT_texture3D */

5174

#ifdef GL_EXT_texture_compression_dxt1

5175

GLEW_EXT_texture_compression_dxt1 = glewGetExtension("GL_EXT_texture_compression_dxt1");

5176

#endif /* GL_EXT_texture_compression_dxt1 */

5177

#ifdef GL_EXT_texture_compression_s3tc

5178

GLEW_EXT_texture_compression_s3tc = glewGetExtension("GL_EXT_texture_compression_s3tc");

5179

#endif /* GL_EXT_texture_compression_s3tc */

5180

#ifdef GL_EXT_texture_cube_map

5181

GLEW_EXT_texture_cube_map = glewGetExtension("GL_EXT_texture_cube_map");

5182

#endif /* GL_EXT_texture_cube_map */

5183

#ifdef GL_EXT_texture_edge_clamp

5184

GLEW_EXT_texture_edge_clamp = glewGetExtension("GL_EXT_texture_edge_clamp");

5185

#endif /* GL_EXT_texture_edge_clamp */

5186

#ifdef GL_EXT_texture_env

5187

GLEW_EXT_texture_env = glewGetExtension("GL_EXT_texture_env");

5188

#endif /* GL_EXT_texture_env */

5189

#ifdef GL_EXT_texture_env_add

5190

GLEW_EXT_texture_env_add = glewGetExtension("GL_EXT_texture_env_add");

5191

#endif /* GL_EXT_texture_env_add */

5192

#ifdef GL_EXT_texture_env_combine

5193

GLEW_EXT_texture_env_combine = glewGetExtension("GL_EXT_texture_env_combine");

5194

#endif /* GL_EXT_texture_env_combine */

5195

#ifdef GL_EXT_texture_env_dot3

5196

GLEW_EXT_texture_env_dot3 = glewGetExtension("GL_EXT_texture_env_dot3");

5197

#endif /* GL_EXT_texture_env_dot3 */

5198

#ifdef GL_EXT_texture_filter_anisotropic

5199

GLEW_EXT_texture_filter_anisotropic = glewGetExtension("GL_EXT_texture_filter_anisotropic");

5200

#endif /* GL_EXT_texture_filter_anisotropic */

5201

#ifdef GL_EXT_texture_lod_bias

5202

GLEW_EXT_texture_lod_bias = glewGetExtension("GL_EXT_texture_lod_bias");

5203

#endif /* GL_EXT_texture_lod_bias */

5204

#ifdef GL_EXT_texture_mirror_clamp

5205

GLEW_EXT_texture_mirror_clamp = glewGetExtension("GL_EXT_texture_mirror_clamp");

5206

#endif /* GL_EXT_texture_mirror_clamp */

5207

#ifdef GL_EXT_texture_object

5208

GLEW_EXT_texture_object = glewGetExtension("GL_EXT_texture_object");

5209

if (glewExperimental || GLEW_EXT_texture_object) GLEW_EXT_texture_object = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT);

5210

#endif /* GL_EXT_texture_object */

5211

#ifdef GL_EXT_texture_perturb_normal

5212

GLEW_EXT_texture_perturb_normal = glewGetExtension("GL_EXT_texture_perturb_normal");

5213

if (glewExperimental || GLEW_EXT_texture_perturb_normal) GLEW_EXT_texture_perturb_normal = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT);

5214

#endif /* GL_EXT_texture_perturb_normal */

5215

#ifdef GL_EXT_texture_rectangle

5216

GLEW_EXT_texture_rectangle = glewGetExtension("GL_EXT_texture_rectangle");

5217

#endif /* GL_EXT_texture_rectangle */

5218

#ifdef GL_EXT_vertex_array

5219

GLEW_EXT_vertex_array = glewGetExtension("GL_EXT_vertex_array");

5220

if (glewExperimental || GLEW_EXT_vertex_array) GLEW_EXT_vertex_array = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);

5221

#endif /* GL_EXT_vertex_array */

5222

#ifdef GL_EXT_vertex_shader

5223

GLEW_EXT_vertex_shader = glewGetExtension("GL_EXT_vertex_shader");

5224

if (glewExperimental || GLEW_EXT_vertex_shader) GLEW_EXT_vertex_shader = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);

5225

#endif /* GL_EXT_vertex_shader */

5226

#ifdef GL_EXT_vertex_weighting

5227

GLEW_EXT_vertex_weighting = glewGetExtension("GL_EXT_vertex_weighting");

5228

if (glewExperimental || GLEW_EXT_vertex_weighting) GLEW_EXT_vertex_weighting = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT);

5229

#endif /* GL_EXT_vertex_weighting */

5230

#ifdef GL_HP_convolution_border_modes

5231

GLEW_HP_convolution_border_modes = glewGetExtension("GL_HP_convolution_border_modes");

5232

#endif /* GL_HP_convolution_border_modes */

5233

#ifdef GL_HP_image_transform

5234

GLEW_HP_image_transform = glewGetExtension("GL_HP_image_transform");

5235

if (glewExperimental || GLEW_HP_image_transform) GLEW_HP_image_transform = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT);

5236

#endif /* GL_HP_image_transform */

5237

#ifdef GL_HP_occlusion_test

5238

GLEW_HP_occlusion_test = glewGetExtension("GL_HP_occlusion_test");

5239

#endif /* GL_HP_occlusion_test */

5240

#ifdef GL_HP_texture_lighting

5241

GLEW_HP_texture_lighting = glewGetExtension("GL_HP_texture_lighting");

5242

#endif /* GL_HP_texture_lighting */

5243

#ifdef GL_IBM_cull_vertex

5244

GLEW_IBM_cull_vertex = glewGetExtension("GL_IBM_cull_vertex");

5245

#endif /* GL_IBM_cull_vertex */

5246

#ifdef GL_IBM_multimode_draw_arrays

5247

GLEW_IBM_multimode_draw_arrays = glewGetExtension("GL_IBM_multimode_draw_arrays");

5248

if (glewExperimental || GLEW_IBM_multimode_draw_arrays) GLEW_IBM_multimode_draw_arrays = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

5249

#endif /* GL_IBM_multimode_draw_arrays */

5250

#ifdef GL_IBM_rasterpos_clip

5251

GLEW_IBM_rasterpos_clip = glewGetExtension("GL_IBM_rasterpos_clip");

5252

#endif /* GL_IBM_rasterpos_clip */

5253

#ifdef GL_IBM_static_data

5254

GLEW_IBM_static_data = glewGetExtension("GL_IBM_static_data");

5255

#endif /* GL_IBM_static_data */

5256

#ifdef GL_IBM_texture_mirrored_repeat

5257

GLEW_IBM_texture_mirrored_repeat = glewGetExtension("GL_IBM_texture_mirrored_repeat");

5258

#endif /* GL_IBM_texture_mirrored_repeat */

5259

#ifdef GL_IBM_vertex_array_lists

5260

GLEW_IBM_vertex_array_lists = glewGetExtension("GL_IBM_vertex_array_lists");

5261

if (glewExperimental || GLEW_IBM_vertex_array_lists) GLEW_IBM_vertex_array_lists = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT);

5262

#endif /* GL_IBM_vertex_array_lists */

5263

#ifdef GL_INGR_color_clamp

5264

GLEW_INGR_color_clamp = glewGetExtension("GL_INGR_color_clamp");

5265

#endif /* GL_INGR_color_clamp */

5266

#ifdef GL_INGR_interlace_read

5267

GLEW_INGR_interlace_read = glewGetExtension("GL_INGR_interlace_read");

5268

#endif /* GL_INGR_interlace_read */

5269

#ifdef GL_INTEL_parallel_arrays

5270

GLEW_INTEL_parallel_arrays = glewGetExtension("GL_INTEL_parallel_arrays");

5271

if (glewExperimental || GLEW_INTEL_parallel_arrays) GLEW_INTEL_parallel_arrays = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT);

5272

#endif /* GL_INTEL_parallel_arrays */

5273

#ifdef GL_INTEL_texture_scissor

5274

GLEW_INTEL_texture_scissor = glewGetExtension("GL_INTEL_texture_scissor");

5275

if (glewExperimental || GLEW_INTEL_texture_scissor) GLEW_INTEL_texture_scissor = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT);

5276

#endif /* GL_INTEL_texture_scissor */

5277

#ifdef GL_KTX_buffer_region

5278

GLEW_KTX_buffer_region = glewGetExtension("GL_KTX_buffer_region");

5279

if (glewExperimental || GLEW_KTX_buffer_region) GLEW_KTX_buffer_region = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);

5280

#endif /* GL_KTX_buffer_region */

5281

#ifdef GL_MESA_pack_invert

5282

GLEW_MESA_pack_invert = glewGetExtension("GL_MESA_pack_invert");

5283

#endif /* GL_MESA_pack_invert */

5284

#ifdef GL_MESA_resize_buffers

5285

GLEW_MESA_resize_buffers = glewGetExtension("GL_MESA_resize_buffers");

5286

if (glewExperimental || GLEW_MESA_resize_buffers) GLEW_MESA_resize_buffers = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

5287

#endif /* GL_MESA_resize_buffers */

5288

#ifdef GL_MESA_window_pos

5289

GLEW_MESA_window_pos = glewGetExtension("GL_MESA_window_pos");

5290

if (glewExperimental || GLEW_MESA_window_pos) GLEW_MESA_window_pos = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);

5291

#endif /* GL_MESA_window_pos */

5292

#ifdef GL_MESA_ycbcr_texture

5293

GLEW_MESA_ycbcr_texture = glewGetExtension("GL_MESA_ycbcr_texture");

5294

#endif /* GL_MESA_ycbcr_texture */

5295

#ifdef GL_NV_blend_square

5296

GLEW_NV_blend_square = glewGetExtension("GL_NV_blend_square");

5297

#endif /* GL_NV_blend_square */

5298

#ifdef GL_NV_copy_depth_to_color

5299

GLEW_NV_copy_depth_to_color = glewGetExtension("GL_NV_copy_depth_to_color");

5300

#endif /* GL_NV_copy_depth_to_color */

5301

#ifdef GL_NV_depth_clamp

5302

GLEW_NV_depth_clamp = glewGetExtension("GL_NV_depth_clamp");

5303

#endif /* GL_NV_depth_clamp */

5304

#ifdef GL_NV_evaluators

5305

GLEW_NV_evaluators = glewGetExtension("GL_NV_evaluators");

5306

if (glewExperimental || GLEW_NV_evaluators) GLEW_NV_evaluators = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);

5307

#endif /* GL_NV_evaluators */

5308

#ifdef GL_NV_fence

5309

GLEW_NV_fence = glewGetExtension("GL_NV_fence");

5310

if (glewExperimental || GLEW_NV_fence) GLEW_NV_fence = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT);

5311

#endif /* GL_NV_fence */

5312

#ifdef GL_NV_float_buffer

5313

GLEW_NV_float_buffer = glewGetExtension("GL_NV_float_buffer");

5314

#endif /* GL_NV_float_buffer */

5315

#ifdef GL_NV_fog_distance

5316

GLEW_NV_fog_distance = glewGetExtension("GL_NV_fog_distance");

5317

#endif /* GL_NV_fog_distance */

5318

#ifdef GL_NV_fragment_program

5319

GLEW_NV_fragment_program = glewGetExtension("GL_NV_fragment_program");

5320

if (glewExperimental || GLEW_NV_fragment_program) GLEW_NV_fragment_program = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);

5321

#endif /* GL_NV_fragment_program */

5322

#ifdef GL_NV_fragment_program2

5323

GLEW_NV_fragment_program2 = glewGetExtension("GL_NV_fragment_program2");

5324

#endif /* GL_NV_fragment_program2 */

5325

#ifdef GL_NV_fragment_program_option

5326

GLEW_NV_fragment_program_option = glewGetExtension("GL_NV_fragment_program_option");

5327

#endif /* GL_NV_fragment_program_option */

5328

#ifdef GL_NV_half_float

5329

GLEW_NV_half_float = glewGetExtension("GL_NV_half_float");

5330

if (glewExperimental || GLEW_NV_half_float) GLEW_NV_half_float = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);

5331

#endif /* GL_NV_half_float */

5332

#ifdef GL_NV_light_max_exponent

5333

GLEW_NV_light_max_exponent = glewGetExtension("GL_NV_light_max_exponent");

5334

#endif /* GL_NV_light_max_exponent */

5335

#ifdef GL_NV_multisample_filter_hint

5336

GLEW_NV_multisample_filter_hint = glewGetExtension("GL_NV_multisample_filter_hint");

5337

#endif /* GL_NV_multisample_filter_hint */

5338

#ifdef GL_NV_occlusion_query

5339

GLEW_NV_occlusion_query = glewGetExtension("GL_NV_occlusion_query");

5340

if (glewExperimental || GLEW_NV_occlusion_query) GLEW_NV_occlusion_query = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);

5341

#endif /* GL_NV_occlusion_query */

5342

#ifdef GL_NV_packed_depth_stencil

5343

GLEW_NV_packed_depth_stencil = glewGetExtension("GL_NV_packed_depth_stencil");

5344

#endif /* GL_NV_packed_depth_stencil */

5345

#ifdef GL_NV_pixel_data_range

5346

GLEW_NV_pixel_data_range = glewGetExtension("GL_NV_pixel_data_range");

5347

if (glewExperimental || GLEW_NV_pixel_data_range) GLEW_NV_pixel_data_range = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT);

5348

#endif /* GL_NV_pixel_data_range */

5349

#ifdef GL_NV_point_sprite

5350

GLEW_NV_point_sprite = glewGetExtension("GL_NV_point_sprite");

5351

if (glewExperimental || GLEW_NV_point_sprite) GLEW_NV_point_sprite = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT);

5352

#endif /* GL_NV_point_sprite */

5353

#ifdef GL_NV_primitive_restart

5354

GLEW_NV_primitive_restart = glewGetExtension("GL_NV_primitive_restart");

5355

if (glewExperimental || GLEW_NV_primitive_restart) GLEW_NV_primitive_restart = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT);

5356

#endif /* GL_NV_primitive_restart */

5357

#ifdef GL_NV_register_combiners

5358

GLEW_NV_register_combiners = glewGetExtension("GL_NV_register_combiners");

5359

if (glewExperimental || GLEW_NV_register_combiners) GLEW_NV_register_combiners = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);

5360

#endif /* GL_NV_register_combiners */

5361

#ifdef GL_NV_register_combiners2

5362

GLEW_NV_register_combiners2 = glewGetExtension("GL_NV_register_combiners2");

5363

if (glewExperimental || GLEW_NV_register_combiners2) GLEW_NV_register_combiners2 = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);

5364

#endif /* GL_NV_register_combiners2 */

5365

#ifdef GL_NV_texgen_emboss

5366

GLEW_NV_texgen_emboss = glewGetExtension("GL_NV_texgen_emboss");

5367

#endif /* GL_NV_texgen_emboss */

5368

#ifdef GL_NV_texgen_reflection

5369

GLEW_NV_texgen_reflection = glewGetExtension("GL_NV_texgen_reflection");

5370

#endif /* GL_NV_texgen_reflection */

5371

#ifdef GL_NV_texture_compression_vtc

5372

GLEW_NV_texture_compression_vtc = glewGetExtension("GL_NV_texture_compression_vtc");

5373

#endif /* GL_NV_texture_compression_vtc */

5374

#ifdef GL_NV_texture_env_combine4

5375

GLEW_NV_texture_env_combine4 = glewGetExtension("GL_NV_texture_env_combine4");

5376

#endif /* GL_NV_texture_env_combine4 */

5377

#ifdef GL_NV_texture_expand_normal

5378

GLEW_NV_texture_expand_normal = glewGetExtension("GL_NV_texture_expand_normal");

5379

#endif /* GL_NV_texture_expand_normal */

5380

#ifdef GL_NV_texture_rectangle

5381

GLEW_NV_texture_rectangle = glewGetExtension("GL_NV_texture_rectangle");

5382

#endif /* GL_NV_texture_rectangle */

5383

#ifdef GL_NV_texture_shader

5384

GLEW_NV_texture_shader = glewGetExtension("GL_NV_texture_shader");

5385

#endif /* GL_NV_texture_shader */

5386

#ifdef GL_NV_texture_shader2

5387

GLEW_NV_texture_shader2 = glewGetExtension("GL_NV_texture_shader2");

5388

#endif /* GL_NV_texture_shader2 */

5389

#ifdef GL_NV_texture_shader3

5390

GLEW_NV_texture_shader3 = glewGetExtension("GL_NV_texture_shader3");

5391

#endif /* GL_NV_texture_shader3 */

5392

#ifdef GL_NV_vertex_array_range

5393

GLEW_NV_vertex_array_range = glewGetExtension("GL_NV_vertex_array_range");

5394

if (glewExperimental || GLEW_NV_vertex_array_range) GLEW_NV_vertex_array_range = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

5395

#endif /* GL_NV_vertex_array_range */

5396

#ifdef GL_NV_vertex_array_range2

5397

GLEW_NV_vertex_array_range2 = glewGetExtension("GL_NV_vertex_array_range2");

5398

#endif /* GL_NV_vertex_array_range2 */

5399

#ifdef GL_NV_vertex_program

5400

GLEW_NV_vertex_program = glewGetExtension("GL_NV_vertex_program");

5401

if (glewExperimental || GLEW_NV_vertex_program) GLEW_NV_vertex_program = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);

5402

#endif /* GL_NV_vertex_program */

5403

#ifdef GL_NV_vertex_program1_1

5404

GLEW_NV_vertex_program1_1 = glewGetExtension("GL_NV_vertex_program1_1");

5405

#endif /* GL_NV_vertex_program1_1 */

5406

#ifdef GL_NV_vertex_program2

5407

GLEW_NV_vertex_program2 = glewGetExtension("GL_NV_vertex_program2");

5408

#endif /* GL_NV_vertex_program2 */

5409

#ifdef GL_NV_vertex_program2_option

5410

GLEW_NV_vertex_program2_option = glewGetExtension("GL_NV_vertex_program2_option");

5411

#endif /* GL_NV_vertex_program2_option */

5412

#ifdef GL_NV_vertex_program3

5413

GLEW_NV_vertex_program3 = glewGetExtension("GL_NV_vertex_program3");

5414

#endif /* GL_NV_vertex_program3 */

5415

#ifdef GL_OML_interlace

5416

GLEW_OML_interlace = glewGetExtension("GL_OML_interlace");

5417

#endif /* GL_OML_interlace */

5418

#ifdef GL_OML_resample

5419

GLEW_OML_resample = glewGetExtension("GL_OML_resample");

5420

#endif /* GL_OML_resample */

5421

#ifdef GL_OML_subsample

5422

GLEW_OML_subsample = glewGetExtension("GL_OML_subsample");

5423

#endif /* GL_OML_subsample */

5424

#ifdef GL_PGI_misc_hints

5425

GLEW_PGI_misc_hints = glewGetExtension("GL_PGI_misc_hints");

5426

#endif /* GL_PGI_misc_hints */

5427

#ifdef GL_PGI_vertex_hints

5428

GLEW_PGI_vertex_hints = glewGetExtension("GL_PGI_vertex_hints");

5429

#endif /* GL_PGI_vertex_hints */

5430

#ifdef GL_REND_screen_coordinates

5431

GLEW_REND_screen_coordinates = glewGetExtension("GL_REND_screen_coordinates");

5432

#endif /* GL_REND_screen_coordinates */

5433

#ifdef GL_S3_s3tc

5434

GLEW_S3_s3tc = glewGetExtension("GL_S3_s3tc");

5435

#endif /* GL_S3_s3tc */

5436

#ifdef GL_SGIS_color_range

5437

GLEW_SGIS_color_range = glewGetExtension("GL_SGIS_color_range");

5438

#endif /* GL_SGIS_color_range */

5439

#ifdef GL_SGIS_detail_texture

5440

GLEW_SGIS_detail_texture = glewGetExtension("GL_SGIS_detail_texture");

5441

if (glewExperimental || GLEW_SGIS_detail_texture) GLEW_SGIS_detail_texture = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5442

#endif /* GL_SGIS_detail_texture */

5443

#ifdef GL_SGIS_fog_function

5444

GLEW_SGIS_fog_function = glewGetExtension("GL_SGIS_fog_function");

5445

if (glewExperimental || GLEW_SGIS_fog_function) GLEW_SGIS_fog_function = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT);

5446

#endif /* GL_SGIS_fog_function */

5447

#ifdef GL_SGIS_generate_mipmap

5448

GLEW_SGIS_generate_mipmap = glewGetExtension("GL_SGIS_generate_mipmap");

5449

#endif /* GL_SGIS_generate_mipmap */

5450

#ifdef GL_SGIS_multisample

5451

GLEW_SGIS_multisample = glewGetExtension("GL_SGIS_multisample");

5452

if (glewExperimental || GLEW_SGIS_multisample) GLEW_SGIS_multisample = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT);

5453

#endif /* GL_SGIS_multisample */

5454

#ifdef GL_SGIS_pixel_texture

5455

GLEW_SGIS_pixel_texture = glewGetExtension("GL_SGIS_pixel_texture");

5456

#endif /* GL_SGIS_pixel_texture */

5457

#ifdef GL_SGIS_sharpen_texture

5458

GLEW_SGIS_sharpen_texture = glewGetExtension("GL_SGIS_sharpen_texture");

5459

if (glewExperimental || GLEW_SGIS_sharpen_texture) GLEW_SGIS_sharpen_texture = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5460

#endif /* GL_SGIS_sharpen_texture */

5461

#ifdef GL_SGIS_texture4D

5462

GLEW_SGIS_texture4D = glewGetExtension("GL_SGIS_texture4D");

5463

if (glewExperimental || GLEW_SGIS_texture4D) GLEW_SGIS_texture4D = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT);

5464

#endif /* GL_SGIS_texture4D */

5465

#ifdef GL_SGIS_texture_border_clamp

5466

GLEW_SGIS_texture_border_clamp = glewGetExtension("GL_SGIS_texture_border_clamp");

5467

#endif /* GL_SGIS_texture_border_clamp */

5468

#ifdef GL_SGIS_texture_edge_clamp

5469

GLEW_SGIS_texture_edge_clamp = glewGetExtension("GL_SGIS_texture_edge_clamp");

5470

#endif /* GL_SGIS_texture_edge_clamp */

5471

#ifdef GL_SGIS_texture_filter4

5472

GLEW_SGIS_texture_filter4 = glewGetExtension("GL_SGIS_texture_filter4");

5473

if (glewExperimental || GLEW_SGIS_texture_filter4) GLEW_SGIS_texture_filter4 = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT);

5474

#endif /* GL_SGIS_texture_filter4 */

5475

#ifdef GL_SGIS_texture_lod

5476

GLEW_SGIS_texture_lod = glewGetExtension("GL_SGIS_texture_lod");

5477

#endif /* GL_SGIS_texture_lod */

5478

#ifdef GL_SGIS_texture_select

5479

GLEW_SGIS_texture_select = glewGetExtension("GL_SGIS_texture_select");

5480

#endif /* GL_SGIS_texture_select */

5481

#ifdef GL_SGIX_async

5482

GLEW_SGIX_async = glewGetExtension("GL_SGIX_async");

5483

if (glewExperimental || GLEW_SGIX_async) GLEW_SGIX_async = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT);

5484

#endif /* GL_SGIX_async */

5485

#ifdef GL_SGIX_async_histogram

5486

GLEW_SGIX_async_histogram = glewGetExtension("GL_SGIX_async_histogram");

5487

#endif /* GL_SGIX_async_histogram */

5488

#ifdef GL_SGIX_async_pixel

5489

GLEW_SGIX_async_pixel = glewGetExtension("GL_SGIX_async_pixel");

5490

#endif /* GL_SGIX_async_pixel */

5491

#ifdef GL_SGIX_blend_alpha_minmax

5492

GLEW_SGIX_blend_alpha_minmax = glewGetExtension("GL_SGIX_blend_alpha_minmax");

5493

#endif /* GL_SGIX_blend_alpha_minmax */

5494

#ifdef GL_SGIX_clipmap

5495

GLEW_SGIX_clipmap = glewGetExtension("GL_SGIX_clipmap");

5496

#endif /* GL_SGIX_clipmap */

5497

#ifdef GL_SGIX_depth_texture

5498

GLEW_SGIX_depth_texture = glewGetExtension("GL_SGIX_depth_texture");

5499

#endif /* GL_SGIX_depth_texture */

5500

#ifdef GL_SGIX_flush_raster

5501

GLEW_SGIX_flush_raster = glewGetExtension("GL_SGIX_flush_raster");

5502

if (glewExperimental || GLEW_SGIX_flush_raster) GLEW_SGIX_flush_raster = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT);

5503

#endif /* GL_SGIX_flush_raster */

5504

#ifdef GL_SGIX_fog_offset

5505

GLEW_SGIX_fog_offset = glewGetExtension("GL_SGIX_fog_offset");

5506

#endif /* GL_SGIX_fog_offset */

5507

#ifdef GL_SGIX_fog_texture

5508

GLEW_SGIX_fog_texture = glewGetExtension("GL_SGIX_fog_texture");

5509

if (glewExperimental || GLEW_SGIX_fog_texture) GLEW_SGIX_fog_texture = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5510

#endif /* GL_SGIX_fog_texture */

5511

#ifdef GL_SGIX_fragment_specular_lighting

5512

GLEW_SGIX_fragment_specular_lighting = glewGetExtension("GL_SGIX_fragment_specular_lighting");

5513

if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) GLEW_SGIX_fragment_specular_lighting = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT);

5514

#endif /* GL_SGIX_fragment_specular_lighting */

5515

#ifdef GL_SGIX_framezoom

5516

GLEW_SGIX_framezoom = glewGetExtension("GL_SGIX_framezoom");

5517

if (glewExperimental || GLEW_SGIX_framezoom) GLEW_SGIX_framezoom = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT);

5518

#endif /* GL_SGIX_framezoom */

5519

#ifdef GL_SGIX_interlace

5520

GLEW_SGIX_interlace = glewGetExtension("GL_SGIX_interlace");

5521

#endif /* GL_SGIX_interlace */

5522

#ifdef GL_SGIX_ir_instrument1

5523

GLEW_SGIX_ir_instrument1 = glewGetExtension("GL_SGIX_ir_instrument1");

5524

#endif /* GL_SGIX_ir_instrument1 */

5525

#ifdef GL_SGIX_list_priority

5526

GLEW_SGIX_list_priority = glewGetExtension("GL_SGIX_list_priority");

5527

#endif /* GL_SGIX_list_priority */

5528

#ifdef GL_SGIX_pixel_texture

5529

GLEW_SGIX_pixel_texture = glewGetExtension("GL_SGIX_pixel_texture");

5530

if (glewExperimental || GLEW_SGIX_pixel_texture) GLEW_SGIX_pixel_texture = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT);

5531

#endif /* GL_SGIX_pixel_texture */

5532

#ifdef GL_SGIX_pixel_texture_bits

5533

GLEW_SGIX_pixel_texture_bits = glewGetExtension("GL_SGIX_pixel_texture_bits");

5534

#endif /* GL_SGIX_pixel_texture_bits */

5535

#ifdef GL_SGIX_reference_plane

5536

GLEW_SGIX_reference_plane = glewGetExtension("GL_SGIX_reference_plane");

5537

if (glewExperimental || GLEW_SGIX_reference_plane) GLEW_SGIX_reference_plane = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT);

5538

#endif /* GL_SGIX_reference_plane */

5539

#ifdef GL_SGIX_resample

5540

GLEW_SGIX_resample = glewGetExtension("GL_SGIX_resample");

5541

#endif /* GL_SGIX_resample */

5542

#ifdef GL_SGIX_shadow

5543

GLEW_SGIX_shadow = glewGetExtension("GL_SGIX_shadow");

5544

#endif /* GL_SGIX_shadow */

5545

#ifdef GL_SGIX_shadow_ambient

5546

GLEW_SGIX_shadow_ambient = glewGetExtension("GL_SGIX_shadow_ambient");

5547

#endif /* GL_SGIX_shadow_ambient */

5548

#ifdef GL_SGIX_sprite

5549

GLEW_SGIX_sprite = glewGetExtension("GL_SGIX_sprite");

5550

if (glewExperimental || GLEW_SGIX_sprite) GLEW_SGIX_sprite = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT);

5551

#endif /* GL_SGIX_sprite */

5552

#ifdef GL_SGIX_tag_sample_buffer

5553

GLEW_SGIX_tag_sample_buffer = glewGetExtension("GL_SGIX_tag_sample_buffer");

5554

if (glewExperimental || GLEW_SGIX_tag_sample_buffer) GLEW_SGIX_tag_sample_buffer = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

5555

#endif /* GL_SGIX_tag_sample_buffer */

5556

#ifdef GL_SGIX_texture_add_env

5557

GLEW_SGIX_texture_add_env = glewGetExtension("GL_SGIX_texture_add_env");

5558

#endif /* GL_SGIX_texture_add_env */

5559

#ifdef GL_SGIX_texture_coordinate_clamp

5560

GLEW_SGIX_texture_coordinate_clamp = glewGetExtension("GL_SGIX_texture_coordinate_clamp");

5561

#endif /* GL_SGIX_texture_coordinate_clamp */

5562

#ifdef GL_SGIX_texture_lod_bias

5563

GLEW_SGIX_texture_lod_bias = glewGetExtension("GL_SGIX_texture_lod_bias");

5564

#endif /* GL_SGIX_texture_lod_bias */

5565

#ifdef GL_SGIX_texture_multi_buffer

5566

GLEW_SGIX_texture_multi_buffer = glewGetExtension("GL_SGIX_texture_multi_buffer");

5567

#endif /* GL_SGIX_texture_multi_buffer */

5568

#ifdef GL_SGIX_texture_range

5569

GLEW_SGIX_texture_range = glewGetExtension("GL_SGIX_texture_range");

5570

#endif /* GL_SGIX_texture_range */

5571

#ifdef GL_SGIX_texture_scale_bias

5572

GLEW_SGIX_texture_scale_bias = glewGetExtension("GL_SGIX_texture_scale_bias");

5573

#endif /* GL_SGIX_texture_scale_bias */

5574

#ifdef GL_SGIX_vertex_preclip

5575

GLEW_SGIX_vertex_preclip = glewGetExtension("GL_SGIX_vertex_preclip");

5576

#endif /* GL_SGIX_vertex_preclip */

5577

#ifdef GL_SGIX_vertex_preclip_hint

5578

GLEW_SGIX_vertex_preclip_hint = glewGetExtension("GL_SGIX_vertex_preclip_hint");

5579

#endif /* GL_SGIX_vertex_preclip_hint */

5580

#ifdef GL_SGIX_ycrcb

5581

GLEW_SGIX_ycrcb = glewGetExtension("GL_SGIX_ycrcb");

5582

#endif /* GL_SGIX_ycrcb */

5583

#ifdef GL_SGI_color_matrix

5584

GLEW_SGI_color_matrix = glewGetExtension("GL_SGI_color_matrix");

5585

#endif /* GL_SGI_color_matrix */

5586

#ifdef GL_SGI_color_table

5587

GLEW_SGI_color_table = glewGetExtension("GL_SGI_color_table");

5588

if (glewExperimental || GLEW_SGI_color_table) GLEW_SGI_color_table = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT);

5589

#endif /* GL_SGI_color_table */

5590

#ifdef GL_SGI_texture_color_table

5591

GLEW_SGI_texture_color_table = glewGetExtension("GL_SGI_texture_color_table");

5592

#endif /* GL_SGI_texture_color_table */

5593

#ifdef GL_SUNX_constant_data

5594

GLEW_SUNX_constant_data = glewGetExtension("GL_SUNX_constant_data");

5595

if (glewExperimental || GLEW_SUNX_constant_data) GLEW_SUNX_constant_data = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT);

5596

#endif /* GL_SUNX_constant_data */

5597

#ifdef GL_SUN_convolution_border_modes

5598

GLEW_SUN_convolution_border_modes = glewGetExtension("GL_SUN_convolution_border_modes");

5599

#endif /* GL_SUN_convolution_border_modes */

5600

#ifdef GL_SUN_global_alpha

5601

GLEW_SUN_global_alpha = glewGetExtension("GL_SUN_global_alpha");

5602

if (glewExperimental || GLEW_SUN_global_alpha) GLEW_SUN_global_alpha = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT);

5603

#endif /* GL_SUN_global_alpha */

5604

#ifdef GL_SUN_mesh_array

5605

GLEW_SUN_mesh_array = glewGetExtension("GL_SUN_mesh_array");

5606

#endif /* GL_SUN_mesh_array */

5607

#ifdef GL_SUN_read_video_pixels

5608

GLEW_SUN_read_video_pixels = glewGetExtension("GL_SUN_read_video_pixels");

5609

if (glewExperimental || GLEW_SUN_read_video_pixels) GLEW_SUN_read_video_pixels = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT);

5610

#endif /* GL_SUN_read_video_pixels */

5611

#ifdef GL_SUN_slice_accum

5612

GLEW_SUN_slice_accum = glewGetExtension("GL_SUN_slice_accum");

5613

#endif /* GL_SUN_slice_accum */

5614

#ifdef GL_SUN_triangle_list

5615

GLEW_SUN_triangle_list = glewGetExtension("GL_SUN_triangle_list");

5616

if (glewExperimental || GLEW_SUN_triangle_list) GLEW_SUN_triangle_list = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT);

5617

#endif /* GL_SUN_triangle_list */

5618

#ifdef GL_SUN_vertex

5619

GLEW_SUN_vertex = glewGetExtension("GL_SUN_vertex");

5620

if (glewExperimental || GLEW_SUN_vertex) GLEW_SUN_vertex = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT);

5621

#endif /* GL_SUN_vertex */

5622

#ifdef GL_WIN_phong_shading

5623

GLEW_WIN_phong_shading = glewGetExtension("GL_WIN_phong_shading");

5624

#endif /* GL_WIN_phong_shading */

5625

#ifdef GL_WIN_specular_fog

5626

GLEW_WIN_specular_fog = glewGetExtension("GL_WIN_specular_fog");

5627

#endif /* GL_WIN_specular_fog */

5628

#ifdef GL_WIN_swap_hint

5629

GLEW_WIN_swap_hint = glewGetExtension("GL_WIN_swap_hint");

5630

if (glewExperimental || GLEW_WIN_swap_hint) GLEW_WIN_swap_hint = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT);

5631

#endif /* GL_WIN_swap_hint */

5632

5633

return GLEW_OK;

5634

}

5635

5636

5637

#if defined(_WIN32)

5638

5639

#if !defined(GLEW_MX)

5640

5641

PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;

5642

PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;

5643

PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;

5644

PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;

5645

5646

PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;

5647

5648

PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;

5649

PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;

5650

5651

PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;

5652

PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;

5653

PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;

5654

PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;

5655

PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;

5656

5657

PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;

5658

PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;

5659

PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;

5660

5661

PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;

5662

PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;

5663

PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;

5664

5665

PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;

5666

PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;

5667

PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;

5668

PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;

5669

5670

PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;

5671

5672

PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;

5673

PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;

5674

5675

PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;

5676

PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;

5677

PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;

5678

PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;

5679

PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;

5680

5681

PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;

5682

PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;

5683

PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;

5684

5685

PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;

5686

PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;

5687

5688

PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;

5689

PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;

5690

5691

PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;

5692

PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;

5693

PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;

5694

PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;

5695

5696

PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;

5697

PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;

5698

PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;

5699

PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;

5700

PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;

5701

PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;

5702

PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;

5703

PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;

5704

PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;

5705

PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;

5706

PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;

5707

PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;

5708

5709

PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;

5710

PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;

5711

PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;

5712

PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;

5713

5714

PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;

5715

PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;

5716

PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;

5717

PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;

5718

5719

PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;

5720

PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;

5721

PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;

5722

PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;

5723

5724

PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;

5725

PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;

5726

5727

PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;

5728

PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;

5729

PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;

5730

PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;

5731

PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;

5732

PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;

5733

GLboolean __WGLEW_3DFX_multisample = GL_FALSE;

5734

GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;

5735

GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;

5736

GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;

5737

GLboolean __WGLEW_ARB_multisample = GL_FALSE;

5738

GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;

5739

GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;

5740

GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;

5741

GLboolean __WGLEW_ARB_render_texture = GL_FALSE;

5742

GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;

5743

GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;

5744

GLboolean __WGLEW_EXT_depth_float = GL_FALSE;

5745

GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;

5746

GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;

5747

GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;

5748

GLboolean __WGLEW_EXT_multisample = GL_FALSE;

5749

GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;

5750

GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;

5751

GLboolean __WGLEW_EXT_swap_control = GL_FALSE;

5752

GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;

5753

GLboolean __WGLEW_I3D_gamma = GL_FALSE;

5754

GLboolean __WGLEW_I3D_genlock = GL_FALSE;

5755

GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;

5756

GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;

5757

GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;

5758

GLboolean __WGLEW_NV_float_buffer = GL_FALSE;

5759

GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;

5760

GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;

5761

GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;

5762

GLboolean __WGLEW_OML_sync_control = GL_FALSE;

5763

5764

#endif /* !GLEW_MX */

5765

5766

#ifdef WGL_3DFX_multisample

5767

5768

#endif /* WGL_3DFX_multisample */

5769

5770

#ifdef WGL_ARB_buffer_region

5771

5772

static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)

5773

{

5774

GLboolean r = GL_FALSE;

5775

5776

r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;

5777

r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;

5778

r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;

5779

r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;

5780

5781

return r;

5782

}

5783

5784

#endif /* WGL_ARB_buffer_region */

5785

5786

#ifdef WGL_ARB_extensions_string

5787

5788

static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)

5789

{

5790

GLboolean r = GL_FALSE;

5791

5792

r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;

5793

5794

return r;

5795

}

5796

5797

#endif /* WGL_ARB_extensions_string */

5798

5799

#ifdef WGL_ARB_make_current_read

5800

5801

static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)

5802

{

5803

GLboolean r = GL_FALSE;

5804

5805

r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;

5806

r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;

5807

5808

return r;

5809

}

5810

5811

#endif /* WGL_ARB_make_current_read */

5812

5813

#ifdef WGL_ARB_multisample

5814

5815

#endif /* WGL_ARB_multisample */

5816

5817

#ifdef WGL_ARB_pbuffer

5818

5819

static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)

5820

{

5821

GLboolean r = GL_FALSE;

5822

5823

r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;

5824

r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;

5825

r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;

5826

r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;

5827

r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;

5828

5829

return r;

5830

}

5831

5832

#endif /* WGL_ARB_pbuffer */

5833

5834

#ifdef WGL_ARB_pixel_format

5835

5836

static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)

5837

{

5838

GLboolean r = GL_FALSE;

5839

5840

r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;

5841

r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;

5842

r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;

5843

5844

return r;

5845

}

5846

5847

#endif /* WGL_ARB_pixel_format */

5848

5849

#ifdef WGL_ARB_pixel_format_float

5850

5851

#endif /* WGL_ARB_pixel_format_float */

5852

5853

#ifdef WGL_ARB_render_texture

5854

5855

static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)

5856

{

5857

GLboolean r = GL_FALSE;

5858

5859

r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;

5860

r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;

5861

r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;

5862

5863

return r;

5864

}

5865

5866

#endif /* WGL_ARB_render_texture */

5867

5868

#ifdef WGL_ATI_pixel_format_float

5869

5870

#endif /* WGL_ATI_pixel_format_float */

5871

5872

#ifdef WGL_ATI_render_texture_rectangle

5873

5874

#endif /* WGL_ATI_render_texture_rectangle */

5875

5876

#ifdef WGL_EXT_depth_float

5877

5878

#endif /* WGL_EXT_depth_float */

5879

5880

#ifdef WGL_EXT_display_color_table

5881

5882

static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT)

5883

{

5884

GLboolean r = GL_FALSE;

5885

5886

r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;

5887

r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;

5888

r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;

5889

r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;

5890

5891

return r;

5892

}

5893

5894

#endif /* WGL_EXT_display_color_table */

5895

5896

#ifdef WGL_EXT_extensions_string

5897

5898

static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)

5899

{

5900

GLboolean r = GL_FALSE;

5901

5902

r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;

5903

5904

return r;

5905

}

5906

5907

#endif /* WGL_EXT_extensions_string */

5908

5909

#ifdef WGL_EXT_make_current_read

5910

5911

static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)

5912

{

5913

GLboolean r = GL_FALSE;

5914

5915

r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;

5916

r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;

5917

5918

return r;

5919

}

5920

5921

#endif /* WGL_EXT_make_current_read */

5922

5923

#ifdef WGL_EXT_multisample

5924

5925

#endif /* WGL_EXT_multisample */

5926

5927

#ifdef WGL_EXT_pbuffer

5928

5929

static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)

5930

{

5931

GLboolean r = GL_FALSE;

5932

5933

r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;

5934

r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;

5935

r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;

5936

r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;

5937

r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;

5938

5939

return r;

5940

}

5941

5942

#endif /* WGL_EXT_pbuffer */

5943

5944

#ifdef WGL_EXT_pixel_format

5945

5946

static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)

5947

{

5948

GLboolean r = GL_FALSE;

5949

5950

r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;

5951

r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;

5952

r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;

5953

5954

return r;

5955

}

5956

5957

#endif /* WGL_EXT_pixel_format */

5958

5959

#ifdef WGL_EXT_swap_control

5960

5961

static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)

5962

{

5963

GLboolean r = GL_FALSE;

5964

5965

r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;

5966

r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;

5967

5968

return r;

5969

}

5970

5971

#endif /* WGL_EXT_swap_control */

5972

5973

#ifdef WGL_I3D_digital_video_control

5974

5975

static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT)

5976

{

5977

GLboolean r = GL_FALSE;

5978

5979

r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;

5980

r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;

5981

5982

return r;

5983

}

5984

5985

#endif /* WGL_I3D_digital_video_control */

5986

5987

#ifdef WGL_I3D_gamma

5988

5989

static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT)

5990

{

5991

GLboolean r = GL_FALSE;

5992

5993

r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;

5994

r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;

5995

r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;

5996

r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;

5997

5998

return r;

5999

}

6000

6001

#endif /* WGL_I3D_gamma */

6002

6003

#ifdef WGL_I3D_genlock

6004

6005

static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT)

6006

{

6007

GLboolean r = GL_FALSE;

6008

6009

r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;

6010

r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;

6011

r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;

6012

r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;

6013

r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;

6014

r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;

6015

r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;

6016

r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;

6017

r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;

6018

r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;

6019

r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;

6020

r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;

6021

6022

return r;

6023

}

6024

6025

#endif /* WGL_I3D_genlock */

6026

6027

#ifdef WGL_I3D_image_buffer

6028

6029

static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT)

6030

{

6031

GLboolean r = GL_FALSE;

6032

6033

r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;

6034

r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;

6035

r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;

6036

r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;

6037

6038

return r;

6039

}

6040

6041

#endif /* WGL_I3D_image_buffer */

6042

6043

#ifdef WGL_I3D_swap_frame_lock

6044

6045

static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT)

6046

{

6047

GLboolean r = GL_FALSE;

6048

6049

r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;

6050

r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;

6051

r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;

6052

r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;

6053

6054

return r;

6055

}

6056

6057

#endif /* WGL_I3D_swap_frame_lock */

6058

6059

#ifdef WGL_I3D_swap_frame_usage

6060

6061

static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)

6062

{

6063

GLboolean r = GL_FALSE;

6064

6065

r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;

6066

r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;

6067

r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;

6068

r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;

6069

6070

return r;

6071

}

6072

6073

#endif /* WGL_I3D_swap_frame_usage */

6074

6075

#ifdef WGL_NV_float_buffer

6076

6077

#endif /* WGL_NV_float_buffer */

6078

6079

#ifdef WGL_NV_render_depth_texture

6080

6081

#endif /* WGL_NV_render_depth_texture */

6082

6083

#ifdef WGL_NV_render_texture_rectangle

6084

6085

#endif /* WGL_NV_render_texture_rectangle */

6086

6087

#ifdef WGL_NV_vertex_array_range

6088

6089

static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT)

6090

{

6091

GLboolean r = GL_FALSE;

6092

6093

r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;

6094

r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;

6095

6096

return r;

6097

}

6098

6099

#endif /* WGL_NV_vertex_array_range */

6100

6101

#ifdef WGL_OML_sync_control

6102

6103

static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT)

6104

{

6105

GLboolean r = GL_FALSE;

6106

6107

r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;

6108

r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;

6109

r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;

6110

r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;

6111

r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;

6112

r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;

6113

6114

return r;

6115

}

6116

6117

#endif /* WGL_OML_sync_control */

6118

6119

/* ------------------------------------------------------------------------- */

6120

6121

static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;

6122

static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;

6123

6124

GLboolean wglewGetExtension (const char* name)

6125

{

6126

GLubyte* p;

6127

GLubyte* end;

6128

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

6129

if (_wglewGetExtensionsStringARB == NULL)

6130

if (_wglewGetExtensionsStringEXT == NULL)

6131

return GL_FALSE;

6132

else

6133

p = (GLubyte*)_wglewGetExtensionsStringEXT();

6134

else

6135

p = (GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());

6136

if (0 == p) return GL_FALSE;

6137

end = p + _glewStrLen(p);

6138

while (p < end)

6139

{

6140

GLuint n = _glewStrCLen(p, ' ');

6141

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

6142

p += n+1;

6143

}

6144

return GL_FALSE;

6145

}

6146

6147

GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)

6148

{

6149

GLboolean crippled;

6150

/* find wgl extension string query functions */

6151

if (_wglewGetExtensionsStringARB == NULL)

6152

_wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");

6153

if (_wglewGetExtensionsStringEXT == NULL)

6154

_wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");

6155

/* initialize extensions */

6156

crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;

6157

#ifdef WGL_3DFX_multisample

6158

WGLEW_3DFX_multisample = wglewGetExtension("WGL_3DFX_multisample");

6159

#endif /* WGL_3DFX_multisample */

6160

#ifdef WGL_ARB_buffer_region

6161

WGLEW_ARB_buffer_region = wglewGetExtension("WGL_ARB_buffer_region");

6162

if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) WGLEW_ARB_buffer_region= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);

6163

#endif /* WGL_ARB_buffer_region */

6164

#ifdef WGL_ARB_extensions_string

6165

WGLEW_ARB_extensions_string = wglewGetExtension("WGL_ARB_extensions_string");

6166

if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) WGLEW_ARB_extensions_string= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);

6167

#endif /* WGL_ARB_extensions_string */

6168

#ifdef WGL_ARB_make_current_read

6169

WGLEW_ARB_make_current_read = wglewGetExtension("WGL_ARB_make_current_read");

6170

if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) WGLEW_ARB_make_current_read= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

6171

#endif /* WGL_ARB_make_current_read */

6172

#ifdef WGL_ARB_multisample

6173

WGLEW_ARB_multisample = wglewGetExtension("WGL_ARB_multisample");

6174

#endif /* WGL_ARB_multisample */

6175

#ifdef WGL_ARB_pbuffer

6176

WGLEW_ARB_pbuffer = wglewGetExtension("WGL_ARB_pbuffer");

6177

if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) WGLEW_ARB_pbuffer= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

6178

#endif /* WGL_ARB_pbuffer */

6179

#ifdef WGL_ARB_pixel_format

6180

WGLEW_ARB_pixel_format = wglewGetExtension("WGL_ARB_pixel_format");

6181

if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) WGLEW_ARB_pixel_format= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);

6182

#endif /* WGL_ARB_pixel_format */

6183

#ifdef WGL_ARB_pixel_format_float

6184

WGLEW_ARB_pixel_format_float = wglewGetExtension("WGL_ARB_pixel_format_float");

6185

#endif /* WGL_ARB_pixel_format_float */

6186

#ifdef WGL_ARB_render_texture

6187

WGLEW_ARB_render_texture = wglewGetExtension("WGL_ARB_render_texture");

6188

if (glewExperimental || WGLEW_ARB_render_texture|| crippled) WGLEW_ARB_render_texture= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6189

#endif /* WGL_ARB_render_texture */

6190

#ifdef WGL_ATI_pixel_format_float

6191

WGLEW_ATI_pixel_format_float = wglewGetExtension("WGL_ATI_pixel_format_float");

6192

#endif /* WGL_ATI_pixel_format_float */

6193

#ifdef WGL_ATI_render_texture_rectangle

6194

WGLEW_ATI_render_texture_rectangle = wglewGetExtension("WGL_ATI_render_texture_rectangle");

6195

#endif /* WGL_ATI_render_texture_rectangle */

6196

#ifdef WGL_EXT_depth_float

6197

WGLEW_EXT_depth_float = wglewGetExtension("WGL_EXT_depth_float");

6198

#endif /* WGL_EXT_depth_float */

6199

#ifdef WGL_EXT_display_color_table

6200

WGLEW_EXT_display_color_table = wglewGetExtension("WGL_EXT_display_color_table");

6201

if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) WGLEW_EXT_display_color_table= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT);

6202

#endif /* WGL_EXT_display_color_table */

6203

#ifdef WGL_EXT_extensions_string

6204

WGLEW_EXT_extensions_string = wglewGetExtension("WGL_EXT_extensions_string");

6205

if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) WGLEW_EXT_extensions_string= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);

6206

#endif /* WGL_EXT_extensions_string */

6207

#ifdef WGL_EXT_make_current_read

6208

WGLEW_EXT_make_current_read = wglewGetExtension("WGL_EXT_make_current_read");

6209

if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) WGLEW_EXT_make_current_read= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

6210

#endif /* WGL_EXT_make_current_read */

6211

#ifdef WGL_EXT_multisample

6212

WGLEW_EXT_multisample = wglewGetExtension("WGL_EXT_multisample");

6213

#endif /* WGL_EXT_multisample */

6214

#ifdef WGL_EXT_pbuffer

6215

WGLEW_EXT_pbuffer = wglewGetExtension("WGL_EXT_pbuffer");

6216

if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) WGLEW_EXT_pbuffer= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

6217

#endif /* WGL_EXT_pbuffer */

6218

#ifdef WGL_EXT_pixel_format

6219

WGLEW_EXT_pixel_format = wglewGetExtension("WGL_EXT_pixel_format");

6220

if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) WGLEW_EXT_pixel_format= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);

6221

#endif /* WGL_EXT_pixel_format */

6222

#ifdef WGL_EXT_swap_control

6223

WGLEW_EXT_swap_control = wglewGetExtension("WGL_EXT_swap_control");

6224

if (glewExperimental || WGLEW_EXT_swap_control|| crippled) WGLEW_EXT_swap_control= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);

6225

#endif /* WGL_EXT_swap_control */

6226

#ifdef WGL_I3D_digital_video_control

6227

WGLEW_I3D_digital_video_control = wglewGetExtension("WGL_I3D_digital_video_control");

6228

if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) WGLEW_I3D_digital_video_control= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT);

6229

#endif /* WGL_I3D_digital_video_control */

6230

#ifdef WGL_I3D_gamma

6231

WGLEW_I3D_gamma = wglewGetExtension("WGL_I3D_gamma");

6232

if (glewExperimental || WGLEW_I3D_gamma|| crippled) WGLEW_I3D_gamma= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT);

6233

#endif /* WGL_I3D_gamma */

6234

#ifdef WGL_I3D_genlock

6235

WGLEW_I3D_genlock = wglewGetExtension("WGL_I3D_genlock");

6236

if (glewExperimental || WGLEW_I3D_genlock|| crippled) WGLEW_I3D_genlock= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT);

6237

#endif /* WGL_I3D_genlock */

6238

#ifdef WGL_I3D_image_buffer

6239

WGLEW_I3D_image_buffer = wglewGetExtension("WGL_I3D_image_buffer");

6240

if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) WGLEW_I3D_image_buffer= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

6241

#endif /* WGL_I3D_image_buffer */

6242

#ifdef WGL_I3D_swap_frame_lock

6243

WGLEW_I3D_swap_frame_lock = wglewGetExtension("WGL_I3D_swap_frame_lock");

6244

if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) WGLEW_I3D_swap_frame_lock= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT);

6245

#endif /* WGL_I3D_swap_frame_lock */

6246

#ifdef WGL_I3D_swap_frame_usage

6247

WGLEW_I3D_swap_frame_usage = wglewGetExtension("WGL_I3D_swap_frame_usage");

6248

if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) WGLEW_I3D_swap_frame_usage= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT);

6249

#endif /* WGL_I3D_swap_frame_usage */

6250

#ifdef WGL_NV_float_buffer

6251

WGLEW_NV_float_buffer = wglewGetExtension("WGL_NV_float_buffer");

6252

#endif /* WGL_NV_float_buffer */

6253

#ifdef WGL_NV_render_depth_texture

6254

WGLEW_NV_render_depth_texture = wglewGetExtension("WGL_NV_render_depth_texture");

6255

#endif /* WGL_NV_render_depth_texture */

6256

#ifdef WGL_NV_render_texture_rectangle

6257

WGLEW_NV_render_texture_rectangle = wglewGetExtension("WGL_NV_render_texture_rectangle");

6258

#endif /* WGL_NV_render_texture_rectangle */

6259

#ifdef WGL_NV_vertex_array_range

6260

WGLEW_NV_vertex_array_range = wglewGetExtension("WGL_NV_vertex_array_range");

6261

if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) WGLEW_NV_vertex_array_range= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

6262

#endif /* WGL_NV_vertex_array_range */

6263

#ifdef WGL_OML_sync_control

6264

WGLEW_OML_sync_control = wglewGetExtension("WGL_OML_sync_control");

6265

if (glewExperimental || WGLEW_OML_sync_control|| crippled) WGLEW_OML_sync_control= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);

6266

#endif /* WGL_OML_sync_control */

6267

6268

return GLEW_OK;

6269

}

6270

6271

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

6272

6273

PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;

6274

6275

PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;

6276

PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;

6277

PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;

6278

PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;

6279

PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;

6280

PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;

6281

PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;

6282

PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;

6283

PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;

6284

PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;

6285

PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;

6286

PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;

6287

PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;

6288

PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;

6289

PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;

6290

PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;

6291

PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;

6292

6293

PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;

6294

PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;

6295

PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;

6296

6297

PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;

6298

PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;

6299

PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;

6300

PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;

6301

6302

PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;

6303

6304

PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;

6305

6306

PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;

6307

6308

PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;

6309

6310

PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;

6311

6312

PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;

6313

PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;

6314

6315

#ifdef GLX_OML_sync_control

6316

PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;

6317

PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;

6318

PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;

6319

PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;

6320

PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;

6321

#endif

6322

6323

PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;

6324

PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;

6325

PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;

6326

PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;

6327

PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;

6328

PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;

6329

6330

PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;

6331

PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;

6332

PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;

6333

PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;

6334

PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;

6335

6336

PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;

6337

PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;

6338

6339

PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;

6340

6341

PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;

6342

PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;

6343

PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;

6344

PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;

6345

PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;

6346

6347

PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;

6348

6349

PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;

6350

PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;

6351

6352

PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;

6353

6354

PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;

6355

PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;

6356

6357

PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;

6358

6359

PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;

6360

PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;

6361

6362

#if !defined(GLEW_MX)

6363

6364

GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;

6365

GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;

6366

GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;

6367

GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;

6368

GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;

6369

GLboolean __GLXEW_3DFX_multisample = GL_FALSE;

6370

GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;

6371

GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;

6372

GLboolean __GLXEW_ARB_multisample = GL_FALSE;

6373

GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;

6374

GLboolean __GLXEW_ATI_render_texture = GL_FALSE;

6375

GLboolean __GLXEW_EXT_import_context = GL_FALSE;

6376

GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;

6377

GLboolean __GLXEW_EXT_visual_info = GL_FALSE;

6378

GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;

6379

GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;

6380

GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;

6381

GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;

6382

GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;

6383

GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;

6384

GLboolean __GLXEW_NV_float_buffer = GL_FALSE;

6385

GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;

6386

GLboolean __GLXEW_OML_swap_method = GL_FALSE;

6387

#ifdef GLX_OML_sync_control

6388

GLboolean __GLXEW_OML_sync_control = GL_FALSE;

6389

#endif

6390

GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;

6391

GLboolean __GLXEW_SGIS_color_range = GL_FALSE;

6392

GLboolean __GLXEW_SGIS_multisample = GL_FALSE;

6393

GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;

6394

GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;

6395

GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;

6396

GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;

6397

GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;

6398

GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;

6399

GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;

6400

GLboolean __GLXEW_SGI_cushion = GL_FALSE;

6401

GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;

6402

GLboolean __GLXEW_SGI_swap_control = GL_FALSE;

6403

GLboolean __GLXEW_SGI_video_sync = GL_FALSE;

6404

GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;

6405

GLboolean __GLXEW_SUN_video_resize = GL_FALSE;

6406

6407

#endif /* !GLEW_MX */

6408

6409

#ifdef GLX_VERSION_1_2

6410

6411

static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT)

6412

{

6413

GLboolean r = GL_FALSE;

6414

6415

r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;

6416

6417

return r;

6418

}

6419

6420

#endif /* GLX_VERSION_1_2 */

6421

6422

#ifdef GLX_VERSION_1_3

6423

6424

static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT)

6425

{

6426

GLboolean r = GL_FALSE;

6427

6428

r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;

6429

r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;

6430

r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;

6431

r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;

6432

r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;

6433

r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;

6434

r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;

6435

r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;

6436

r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;

6437

r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;

6438

r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;

6439

r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;

6440

r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;

6441

r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;

6442

r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;

6443

r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;

6444

r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;

6445

6446

return r;

6447

}

6448

6449

#endif /* GLX_VERSION_1_3 */

6450

6451

#ifdef GLX_VERSION_1_4

6452

6453

#endif /* GLX_VERSION_1_4 */

6454

6455

#ifdef GLX_3DFX_multisample

6456

6457

#endif /* GLX_3DFX_multisample */

6458

6459

#ifdef GLX_ARB_fbconfig_float

6460

6461

#endif /* GLX_ARB_fbconfig_float */

6462

6463

#ifdef GLX_ARB_get_proc_address

6464

6465

#endif /* GLX_ARB_get_proc_address */

6466

6467

#ifdef GLX_ARB_multisample

6468

6469

#endif /* GLX_ARB_multisample */

6470

6471

#ifdef GLX_ATI_pixel_format_float

6472

6473

#endif /* GLX_ATI_pixel_format_float */

6474

6475

#ifdef GLX_ATI_render_texture

6476

6477

static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT)

6478

{

6479

GLboolean r = GL_FALSE;

6480

6481

r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;

6482

r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;

6483

r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;

6484

6485

return r;

6486

}

6487

6488

#endif /* GLX_ATI_render_texture */

6489

6490

#ifdef GLX_EXT_import_context

6491

6492

static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)

6493

{

6494

GLboolean r = GL_FALSE;

6495

6496

r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;

6497

r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;

6498

r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;

6499

r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;

6500

6501

return r;

6502

}

6503

6504

#endif /* GLX_EXT_import_context */

6505

6506

#ifdef GLX_EXT_scene_marker

6507

6508

#endif /* GLX_EXT_scene_marker */

6509

6510

#ifdef GLX_EXT_visual_info

6511

6512

#endif /* GLX_EXT_visual_info */

6513

6514

#ifdef GLX_EXT_visual_rating

6515

6516

#endif /* GLX_EXT_visual_rating */

6517

6518

#ifdef GLX_MESA_agp_offset

6519

6520

static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)

6521

{

6522

GLboolean r = GL_FALSE;

6523

6524

r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;

6525

6526

return r;

6527

}

6528

6529

#endif /* GLX_MESA_agp_offset */

6530

6531

#ifdef GLX_MESA_copy_sub_buffer

6532

6533

static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT)

6534

{

6535

GLboolean r = GL_FALSE;

6536

6537

r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;

6538

6539

return r;

6540

}

6541

6542

#endif /* GLX_MESA_copy_sub_buffer */

6543

6544

#ifdef GLX_MESA_pixmap_colormap

6545

6546

static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT)

6547

{

6548

GLboolean r = GL_FALSE;

6549

6550

r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;

6551

6552

return r;

6553

}

6554

6555

#endif /* GLX_MESA_pixmap_colormap */

6556

6557

#ifdef GLX_MESA_release_buffers

6558

6559

static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT)

6560

{

6561

GLboolean r = GL_FALSE;

6562

6563

r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;

6564

6565

return r;

6566

}

6567

6568

#endif /* GLX_MESA_release_buffers */

6569

6570

#ifdef GLX_MESA_set_3dfx_mode

6571

6572

static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)

6573

{

6574

GLboolean r = GL_FALSE;

6575

6576

r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;

6577

6578

return r;

6579

}

6580

6581

#endif /* GLX_MESA_set_3dfx_mode */

6582

6583

#ifdef GLX_NV_float_buffer

6584

6585

#endif /* GLX_NV_float_buffer */

6586

6587

#ifdef GLX_NV_vertex_array_range

6588

6589

static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT)

6590

{

6591

GLboolean r = GL_FALSE;

6592

6593

r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;

6594

r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;

6595

6596

return r;

6597

}

6598

6599

#endif /* GLX_NV_vertex_array_range */

6600

6601

#ifdef GLX_OML_swap_method

6602

6603

#endif /* GLX_OML_swap_method */

6604

6605

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

6606

#include <inttypes.h>

6607

6608

static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT)

6609

{

6610

GLboolean r = GL_FALSE;

6611

6612

r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;

6613

r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;

6614

r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;

6615

r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;

6616

r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;

6617

6618

return r;

6619

}

6620

6621

#endif /* GLX_OML_sync_control */

6622

6623

#ifdef GLX_SGIS_blended_overlay

6624

6625

#endif /* GLX_SGIS_blended_overlay */

6626

6627

#ifdef GLX_SGIS_color_range

6628

6629

#endif /* GLX_SGIS_color_range */

6630

6631

#ifdef GLX_SGIS_multisample

6632

6633

#endif /* GLX_SGIS_multisample */

6634

6635

#ifdef GLX_SGIS_shared_multisample

6636

6637

#endif /* GLX_SGIS_shared_multisample */

6638

6639

#ifdef GLX_SGIX_fbconfig

6640

6641

static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT)

6642

{

6643

GLboolean r = GL_FALSE;

6644

6645

r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;

6646

r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;

6647

r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;

6648

r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;

6649

r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;

6650

r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;

6651

6652

return r;

6653

}

6654

6655

#endif /* GLX_SGIX_fbconfig */

6656

6657

#ifdef GLX_SGIX_pbuffer

6658

6659

static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT)

6660

{

6661

GLboolean r = GL_FALSE;

6662

6663

r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;

6664

r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;

6665

r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;

6666

r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;

6667

r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;

6668

6669

return r;

6670

}

6671

6672

#endif /* GLX_SGIX_pbuffer */

6673

6674

#ifdef GLX_SGIX_swap_barrier

6675

6676

static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT)

6677

{

6678

GLboolean r = GL_FALSE;

6679

6680

r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;

6681

r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;

6682

6683

return r;

6684

}

6685

6686

#endif /* GLX_SGIX_swap_barrier */

6687

6688

#ifdef GLX_SGIX_swap_group

6689

6690

static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)

6691

{

6692

GLboolean r = GL_FALSE;

6693

6694

r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;

6695

6696

return r;

6697

}

6698

6699

#endif /* GLX_SGIX_swap_group */

6700

6701

#ifdef GLX_SGIX_video_resize

6702

6703

static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)

6704

{

6705

GLboolean r = GL_FALSE;

6706

6707

r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;

6708

r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;

6709

r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;

6710

r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;

6711

r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;

6712

6713

return r;

6714

}

6715

6716

#endif /* GLX_SGIX_video_resize */

6717

6718

#ifdef GLX_SGIX_visual_select_group

6719

6720

#endif /* GLX_SGIX_visual_select_group */

6721

6722

#ifdef GLX_SGI_cushion

6723

6724

static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT)

6725

{

6726

GLboolean r = GL_FALSE;

6727

6728

r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;

6729

6730

return r;

6731

}

6732

6733

#endif /* GLX_SGI_cushion */

6734

6735

#ifdef GLX_SGI_make_current_read

6736

6737

static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT)

6738

{

6739

GLboolean r = GL_FALSE;

6740

6741

r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;

6742

r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;

6743

6744

return r;

6745

}

6746

6747

#endif /* GLX_SGI_make_current_read */

6748

6749

#ifdef GLX_SGI_swap_control

6750

6751

static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)

6752

{

6753

GLboolean r = GL_FALSE;

6754

6755

r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;

6756

6757

return r;

6758

}

6759

6760

#endif /* GLX_SGI_swap_control */

6761

6762

#ifdef GLX_SGI_video_sync

6763

6764

static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT)

6765

{

6766

GLboolean r = GL_FALSE;

6767

6768

r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;

6769

r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;

6770

6771

return r;

6772

}

6773

6774

#endif /* GLX_SGI_video_sync */

6775

6776

#ifdef GLX_SUN_get_transparent_index

6777

6778

static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT)

6779

{

6780

GLboolean r = GL_FALSE;

6781

6782

r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;

6783

6784

return r;

6785

}

6786

6787

#endif /* GLX_SUN_get_transparent_index */

6788

6789

#ifdef GLX_SUN_video_resize

6790

6791

static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)

6792

{

6793

GLboolean r = GL_FALSE;

6794

6795

r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;

6796

r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;

6797

6798

return r;

6799

}

6800

6801

#endif /* GLX_SUN_video_resize */

6802

6803

/* ------------------------------------------------------------------------ */

6804

6805

GLboolean glxewGetExtension (const char* name)

6806

{

6807

GLubyte* p;

6808

GLubyte* end;

6809

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

6810

/* if (glXQueryExtensionsString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE; */

6811

/* p = (GLubyte*)glXQueryExtensionsString(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay())); */

6812

if (glXGetClientString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE;

6813

p = (GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);

6814

if (0 == p) return GL_FALSE;

6815

end = p + _glewStrLen(p);

6816

while (p < end)

6817

{

6818

GLuint n = _glewStrCLen(p, ' ');

6819

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

6820

p += n+1;

6821

}

6822

return GL_FALSE;

6823

}

6824

6825

GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)

6826

{

6827

int major, minor;

6828

/* initialize core GLX 1.2 */

6829

if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY;

6830

/* initialize flags */

6831

GLXEW_VERSION_1_0 = GL_TRUE;

6832

GLXEW_VERSION_1_1 = GL_TRUE;

6833

GLXEW_VERSION_1_2 = GL_TRUE;

6834

GLXEW_VERSION_1_3 = GL_TRUE;

6835

GLXEW_VERSION_1_4 = GL_TRUE;

6836

/* query GLX version */

6837

glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);

6838

if (major == 1 && minor <= 3)

6839

{

6840

switch (minor)

6841

{

6842

case 3:

6843

GLXEW_VERSION_1_4 = GL_FALSE;

6844

break;

6845

case 2:

6846

GLXEW_VERSION_1_4 = GL_FALSE;

6847

GLXEW_VERSION_1_3 = GL_FALSE;

6848

break;

6849

default:

6850

return GLEW_ERROR_GLX_VERSION_11_ONLY;

6851

break;

6852

}

6853

}

6854

/* initialize extensions */

6855

#ifdef GLX_VERSION_1_3

6856

if (glewExperimental || GLXEW_VERSION_1_3) GLXEW_VERSION_1_3 = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);

6857

#endif /* GLX_VERSION_1_3 */

6858

#ifdef GLX_3DFX_multisample

6859

GLXEW_3DFX_multisample = glxewGetExtension("GLX_3DFX_multisample");

6860

#endif /* GLX_3DFX_multisample */

6861

#ifdef GLX_ARB_fbconfig_float

6862

GLXEW_ARB_fbconfig_float = glxewGetExtension("GLX_ARB_fbconfig_float");

6863

#endif /* GLX_ARB_fbconfig_float */

6864

#ifdef GLX_ARB_get_proc_address

6865

GLXEW_ARB_get_proc_address = glxewGetExtension("GLX_ARB_get_proc_address");

6866

#endif /* GLX_ARB_get_proc_address */

6867

#ifdef GLX_ARB_multisample

6868

GLXEW_ARB_multisample = glxewGetExtension("GLX_ARB_multisample");

6869

#endif /* GLX_ARB_multisample */

6870

#ifdef GLX_ATI_pixel_format_float

6871

GLXEW_ATI_pixel_format_float = glxewGetExtension("GLX_ATI_pixel_format_float");

6872

#endif /* GLX_ATI_pixel_format_float */

6873

#ifdef GLX_ATI_render_texture

6874

GLXEW_ATI_render_texture = glxewGetExtension("GLX_ATI_render_texture");

6875

if (glewExperimental || GLXEW_ATI_render_texture) GLXEW_ATI_render_texture = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);

6876

#endif /* GLX_ATI_render_texture */

6877

#ifdef GLX_EXT_import_context

6878

GLXEW_EXT_import_context = glxewGetExtension("GLX_EXT_import_context");

6879

if (glewExperimental || GLXEW_EXT_import_context) GLXEW_EXT_import_context = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT);

6880

#endif /* GLX_EXT_import_context */

6881

#ifdef GLX_EXT_scene_marker

6882

GLXEW_EXT_scene_marker = glxewGetExtension("GLX_EXT_scene_marker");

6883

#endif /* GLX_EXT_scene_marker */

6884

#ifdef GLX_EXT_visual_info

6885

GLXEW_EXT_visual_info = glxewGetExtension("GLX_EXT_visual_info");

6886

#endif /* GLX_EXT_visual_info */

6887

#ifdef GLX_EXT_visual_rating

6888

GLXEW_EXT_visual_rating = glxewGetExtension("GLX_EXT_visual_rating");

6889

#endif /* GLX_EXT_visual_rating */

6890

#ifdef GLX_MESA_agp_offset

6891

GLXEW_MESA_agp_offset = glxewGetExtension("GLX_MESA_agp_offset");

6892

if (glewExperimental || GLXEW_MESA_agp_offset) GLXEW_MESA_agp_offset = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);

6893

#endif /* GLX_MESA_agp_offset */

6894

#ifdef GLX_MESA_copy_sub_buffer

6895

GLXEW_MESA_copy_sub_buffer = glxewGetExtension("GLX_MESA_copy_sub_buffer");

6896

if (glewExperimental || GLXEW_MESA_copy_sub_buffer) GLXEW_MESA_copy_sub_buffer = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT);

6897

#endif /* GLX_MESA_copy_sub_buffer */

6898

#ifdef GLX_MESA_pixmap_colormap

6899

GLXEW_MESA_pixmap_colormap = glxewGetExtension("GLX_MESA_pixmap_colormap");

6900

if (glewExperimental || GLXEW_MESA_pixmap_colormap) GLXEW_MESA_pixmap_colormap = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT);

6901

#endif /* GLX_MESA_pixmap_colormap */

6902

#ifdef GLX_MESA_release_buffers

6903

GLXEW_MESA_release_buffers = glxewGetExtension("GLX_MESA_release_buffers");

6904

if (glewExperimental || GLXEW_MESA_release_buffers) GLXEW_MESA_release_buffers = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT);

6905

#endif /* GLX_MESA_release_buffers */

6906

#ifdef GLX_MESA_set_3dfx_mode

6907

GLXEW_MESA_set_3dfx_mode = glxewGetExtension("GLX_MESA_set_3dfx_mode");

6908

if (glewExperimental || GLXEW_MESA_set_3dfx_mode) GLXEW_MESA_set_3dfx_mode = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT);

6909

#endif /* GLX_MESA_set_3dfx_mode */

6910

#ifdef GLX_NV_float_buffer

6911

GLXEW_NV_float_buffer = glxewGetExtension("GLX_NV_float_buffer");

6912

#endif /* GLX_NV_float_buffer */

6913

#ifdef GLX_NV_vertex_array_range

6914

GLXEW_NV_vertex_array_range = glxewGetExtension("GLX_NV_vertex_array_range");

6915

if (glewExperimental || GLXEW_NV_vertex_array_range) GLXEW_NV_vertex_array_range = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);

6916

#endif /* GLX_NV_vertex_array_range */

6917

#ifdef GLX_OML_swap_method

6918

GLXEW_OML_swap_method = glxewGetExtension("GLX_OML_swap_method");

6919

#endif /* GLX_OML_swap_method */

6920

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

6921

#include <inttypes.h>

6922

GLXEW_OML_sync_control = glxewGetExtension("GLX_OML_sync_control");

6923

if (glewExperimental || GLXEW_OML_sync_control) GLXEW_OML_sync_control = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);

6924

#endif /* GLX_OML_sync_control */

6925

#ifdef GLX_SGIS_blended_overlay

6926

GLXEW_SGIS_blended_overlay = glxewGetExtension("GLX_SGIS_blended_overlay");

6927

#endif /* GLX_SGIS_blended_overlay */

6928

#ifdef GLX_SGIS_color_range

6929

GLXEW_SGIS_color_range = glxewGetExtension("GLX_SGIS_color_range");

6930

#endif /* GLX_SGIS_color_range */

6931

#ifdef GLX_SGIS_multisample

6932

GLXEW_SGIS_multisample = glxewGetExtension("GLX_SGIS_multisample");

6933

#endif /* GLX_SGIS_multisample */

6934

#ifdef GLX_SGIS_shared_multisample

6935

GLXEW_SGIS_shared_multisample = glxewGetExtension("GLX_SGIS_shared_multisample");

6936

#endif /* GLX_SGIS_shared_multisample */

6937

#ifdef GLX_SGIX_fbconfig

6938

GLXEW_SGIX_fbconfig = glxewGetExtension("GLX_SGIX_fbconfig");

6939

if (glewExperimental || GLXEW_SGIX_fbconfig) GLXEW_SGIX_fbconfig = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT);

6940

#endif /* GLX_SGIX_fbconfig */

6941

#ifdef GLX_SGIX_pbuffer

6942

GLXEW_SGIX_pbuffer = glxewGetExtension("GLX_SGIX_pbuffer");

6943

if (glewExperimental || GLXEW_SGIX_pbuffer) GLXEW_SGIX_pbuffer = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);

6944

#endif /* GLX_SGIX_pbuffer */

6945

#ifdef GLX_SGIX_swap_barrier

6946

GLXEW_SGIX_swap_barrier = glxewGetExtension("GLX_SGIX_swap_barrier");

6947

if (glewExperimental || GLXEW_SGIX_swap_barrier) GLXEW_SGIX_swap_barrier = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT);

6948

#endif /* GLX_SGIX_swap_barrier */

6949

#ifdef GLX_SGIX_swap_group

6950

GLXEW_SGIX_swap_group = glxewGetExtension("GLX_SGIX_swap_group");

6951

if (glewExperimental || GLXEW_SGIX_swap_group) GLXEW_SGIX_swap_group = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);

6952

#endif /* GLX_SGIX_swap_group */

6953

#ifdef GLX_SGIX_video_resize

6954

GLXEW_SGIX_video_resize = glxewGetExtension("GLX_SGIX_video_resize");

6955

if (glewExperimental || GLXEW_SGIX_video_resize) GLXEW_SGIX_video_resize = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);

6956

#endif /* GLX_SGIX_video_resize */

6957

#ifdef GLX_SGIX_visual_select_group

6958

GLXEW_SGIX_visual_select_group = glxewGetExtension("GLX_SGIX_visual_select_group");

6959

#endif /* GLX_SGIX_visual_select_group */

6960

#ifdef GLX_SGI_cushion

6961

GLXEW_SGI_cushion = glxewGetExtension("GLX_SGI_cushion");

6962

if (glewExperimental || GLXEW_SGI_cushion) GLXEW_SGI_cushion = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT);

6963

#endif /* GLX_SGI_cushion */

6964

#ifdef GLX_SGI_make_current_read

6965

GLXEW_SGI_make_current_read = glxewGetExtension("GLX_SGI_make_current_read");

6966

if (glewExperimental || GLXEW_SGI_make_current_read) GLXEW_SGI_make_current_read = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);

6967

#endif /* GLX_SGI_make_current_read */

6968

#ifdef GLX_SGI_swap_control

6969

GLXEW_SGI_swap_control = glxewGetExtension("GLX_SGI_swap_control");

6970

if (glewExperimental || GLXEW_SGI_swap_control) GLXEW_SGI_swap_control = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);

6971

#endif /* GLX_SGI_swap_control */

6972

#ifdef GLX_SGI_video_sync

6973

GLXEW_SGI_video_sync = glxewGetExtension("GLX_SGI_video_sync");

6974

if (glewExperimental || GLXEW_SGI_video_sync) GLXEW_SGI_video_sync = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT);

6975

#endif /* GLX_SGI_video_sync */

6976

#ifdef GLX_SUN_get_transparent_index

6977

GLXEW_SUN_get_transparent_index = glxewGetExtension("GLX_SUN_get_transparent_index");

6978

if (glewExperimental || GLXEW_SUN_get_transparent_index) GLXEW_SUN_get_transparent_index = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT);

6979

#endif /* GLX_SUN_get_transparent_index */

6980

#ifdef GLX_SUN_video_resize

6981

GLXEW_SUN_video_resize = glxewGetExtension("GLX_SUN_video_resize");

6982

if (glewExperimental || GLXEW_SUN_video_resize) GLXEW_SUN_video_resize = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);

6983

#endif /* GLX_SUN_video_resize */

6984

6985

return GLEW_OK;

6986

}

6987

6988

#endif /* !__APPLE__ || GLEW_APPLE_GLX */

6989

6990

/* ------------------------------------------------------------------------ */

6991

6992

const GLubyte* glewGetErrorString (GLenum error)

6993

{

6994

static const GLubyte* _glewErrorString[] =

6995

{

6996

(const GLubyte*)"No error",

6997

(const GLubyte*)"Missing GL version",

6998

(const GLubyte*)"GL 1.1 and up are not supported",

6999

(const GLubyte*)"GLX 1.2 and up are not supported",

7000

(const GLubyte*)"Unknown error"

7001

};

7002

const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;

7003

return _glewErrorString[(int)error > max_error ? max_error : (int)error];

7004

}

7005

7006

const GLubyte* glewGetString (GLenum name)

7007

{

7008

static const GLubyte* _glewString[] =

7009

{

7010

(const GLubyte*)NULL,

7011

(const GLubyte*)"1.3.1"

7012

};

7013

const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;

7014

return _glewString[(int)name > max_string ? 0 : (int)name];

7015

}

7016

7017

/* ------------------------------------------------------------------------ */

7018

7019

GLboolean glewExperimental = GL_FALSE;

7020

7021

#if !defined(GLEW_MX)

7022

7023

#if defined(_WIN32)

7024

extern GLenum wglewContextInit (void);

7025

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

7026

extern GLenum glxewContextInit (void);

7027

#endif /* _WIN32 */

7028

7029

GLenum glewInit ()

7030

{

7031

GLenum r;

7032

if ( (r = glewContextInit()) ) return r;

7033

#if defined(_WIN32)

7034

return wglewContextInit();

7035

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */

7036

return glxewContextInit();

7037

#else

7038

return r;

7039

#endif /* _WIN32 */

7040

}

7041

7042

#endif /* !GLEW_MX */

7043

#ifdef GLEW_MX

7044

GLboolean glewContextIsSupported (GLEWContext* ctx, const char* name)

7045

#else

7046

GLboolean glewIsSupported (const char* name)

7047

#endif

7048

{

7049

GLubyte* pos = (GLubyte*)name;

7050

GLuint len = _glewStrLen(pos);

7051

GLboolean ret = GL_TRUE;

7052

while (ret && len > 0)

7053

{

7054

if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))

7055

{

7056

if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

7057

{

7058

#ifdef GL_VERSION_1_2

7059

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

7060

{

7061

ret = GLEW_VERSION_1_2;

7062

continue;

7063

}

7064

#endif

7065

#ifdef GL_VERSION_1_3

7066

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

7067

{

7068

ret = GLEW_VERSION_1_3;

7069

continue;

7070

}

7071

#endif

7072

#ifdef GL_VERSION_1_4

7073

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

7074

{

7075

ret = GLEW_VERSION_1_4;

7076

continue;

7077

}

7078

#endif

7079

#ifdef GL_VERSION_1_5

7080

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))

7081

{

7082

ret = GLEW_VERSION_1_5;

7083

continue;

7084

}

7085

#endif

7086

#ifdef GL_VERSION_2_0

7087

if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))

7088

{

7089

ret = GLEW_VERSION_2_0;

7090

continue;

7091

}

7092

#endif

7093

}

7094

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

7095

{

7096

#ifdef GL_3DFX_multisample

7097

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

7098

{

7099

ret = GLEW_3DFX_multisample;

7100

continue;

7101

}

7102

#endif

7103

#ifdef GL_3DFX_tbuffer

7104

if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))

7105

{

7106

ret = GLEW_3DFX_tbuffer;

7107

continue;

7108

}

7109

#endif

7110

#ifdef GL_3DFX_texture_compression_FXT1

7111

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))

7112

{

7113

ret = GLEW_3DFX_texture_compression_FXT1;

7114

continue;

7115

}

7116

#endif

7117

}

7118

if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))

7119

{

7120

#ifdef GL_APPLE_client_storage

7121

if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))

7122

{

7123

ret = GLEW_APPLE_client_storage;

7124

continue;

7125

}

7126

#endif

7127

#ifdef GL_APPLE_element_array

7128

if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

7129

{

7130

ret = GLEW_APPLE_element_array;

7131

continue;

7132

}

7133

#endif

7134

#ifdef GL_APPLE_fence

7135

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

7136

{

7137

ret = GLEW_APPLE_fence;

7138

continue;

7139

}

7140

#endif

7141

#ifdef GL_APPLE_float_pixels

7142

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))

7143

{

7144

ret = GLEW_APPLE_float_pixels;

7145

continue;

7146

}

7147

#endif

7148

#ifdef GL_APPLE_specular_vector

7149

if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))

7150

{

7151

ret = GLEW_APPLE_specular_vector;

7152

continue;

7153

}

7154

#endif

7155

#ifdef GL_APPLE_texture_range

7156

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

7157

{

7158

ret = GLEW_APPLE_texture_range;

7159

continue;

7160

}

7161

#endif

7162

#ifdef GL_APPLE_transform_hint

7163

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))

7164

{

7165

ret = GLEW_APPLE_transform_hint;

7166

continue;

7167

}

7168

#endif

7169

#ifdef GL_APPLE_vertex_array_object

7170

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

7171

{

7172

ret = GLEW_APPLE_vertex_array_object;

7173

continue;

7174

}

7175

#endif

7176

#ifdef GL_APPLE_vertex_array_range

7177

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

7178

{

7179

ret = GLEW_APPLE_vertex_array_range;

7180

continue;

7181

}

7182

#endif

7183

#ifdef GL_APPLE_ycbcr_422

7184

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))

7185

{

7186

ret = GLEW_APPLE_ycbcr_422;

7187

continue;

7188

}

7189

#endif

7190

}

7191

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

7192

{

7193

#ifdef GL_ARB_color_buffer_float

7194

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))

7195

{

7196

ret = GLEW_ARB_color_buffer_float;

7197

continue;

7198

}

7199

#endif

7200

#ifdef GL_ARB_depth_texture

7201

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

7202

{

7203

ret = GLEW_ARB_depth_texture;

7204

continue;

7205

}

7206

#endif

7207

#ifdef GL_ARB_draw_buffers

7208

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

7209

{

7210

ret = GLEW_ARB_draw_buffers;

7211

continue;

7212

}

7213

#endif

7214

#ifdef GL_ARB_fragment_program

7215

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

7216

{

7217

ret = GLEW_ARB_fragment_program;

7218

continue;

7219

}

7220

#endif

7221

#ifdef GL_ARB_fragment_program_shadow

7222

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))

7223

{

7224

ret = GLEW_ARB_fragment_program_shadow;

7225

continue;

7226

}

7227

#endif

7228

#ifdef GL_ARB_fragment_shader

7229

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

7230

{

7231

ret = GLEW_ARB_fragment_shader;

7232

continue;

7233

}

7234

#endif

7235

#ifdef GL_ARB_half_float_pixel

7236

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))

7237

{

7238

ret = GLEW_ARB_half_float_pixel;

7239

continue;

7240

}

7241

#endif

7242

#ifdef GL_ARB_imaging

7243

if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))

7244

{

7245

ret = GLEW_ARB_imaging;

7246

continue;

7247

}

7248

#endif

7249

#ifdef GL_ARB_matrix_palette

7250

if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))

7251

{

7252

ret = GLEW_ARB_matrix_palette;

7253

continue;

7254

}

7255

#endif

7256

#ifdef GL_ARB_multisample

7257

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

7258

{

7259

ret = GLEW_ARB_multisample;

7260

continue;

7261

}

7262

#endif

7263

#ifdef GL_ARB_multitexture

7264

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))

7265

{

7266

ret = GLEW_ARB_multitexture;

7267

continue;

7268

}

7269

#endif

7270

#ifdef GL_ARB_occlusion_query

7271

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

7272

{

7273

ret = GLEW_ARB_occlusion_query;

7274

continue;

7275

}

7276

#endif

7277

#ifdef GL_ARB_pixel_buffer_object

7278

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

7279

{

7280

ret = GLEW_ARB_pixel_buffer_object;

7281

continue;

7282

}

7283

#endif

7284

#ifdef GL_ARB_point_parameters

7285

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

7286

{

7287

ret = GLEW_ARB_point_parameters;

7288

continue;

7289

}

7290

#endif

7291

#ifdef GL_ARB_point_sprite

7292

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

7293

{

7294

ret = GLEW_ARB_point_sprite;

7295

continue;

7296

}

7297

#endif

7298

#ifdef GL_ARB_shader_objects

7299

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))

7300

{

7301

ret = GLEW_ARB_shader_objects;

7302

continue;

7303

}

7304

#endif

7305

#ifdef GL_ARB_shading_language_100

7306

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))

7307

{

7308

ret = GLEW_ARB_shading_language_100;

7309

continue;

7310

}

7311

#endif

7312

#ifdef GL_ARB_shadow

7313

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

7314

{

7315

ret = GLEW_ARB_shadow;

7316

continue;

7317

}

7318

#endif

7319

#ifdef GL_ARB_shadow_ambient

7320

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

7321

{

7322

ret = GLEW_ARB_shadow_ambient;

7323

continue;

7324

}

7325

#endif

7326

#ifdef GL_ARB_texture_border_clamp

7327

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

7328

{

7329

ret = GLEW_ARB_texture_border_clamp;

7330

continue;

7331

}

7332

#endif

7333

#ifdef GL_ARB_texture_compression

7334

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))

7335

{

7336

ret = GLEW_ARB_texture_compression;

7337

continue;

7338

}

7339

#endif

7340

#ifdef GL_ARB_texture_cube_map

7341

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

7342

{

7343

ret = GLEW_ARB_texture_cube_map;

7344

continue;

7345

}

7346

#endif

7347

#ifdef GL_ARB_texture_env_add

7348

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

7349

{

7350

ret = GLEW_ARB_texture_env_add;

7351

continue;

7352

}

7353

#endif

7354

#ifdef GL_ARB_texture_env_combine

7355

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

7356

{

7357

ret = GLEW_ARB_texture_env_combine;

7358

continue;

7359

}

7360

#endif

7361

#ifdef GL_ARB_texture_env_crossbar

7362

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))

7363

{

7364

ret = GLEW_ARB_texture_env_crossbar;

7365

continue;

7366

}

7367

#endif

7368

#ifdef GL_ARB_texture_env_dot3

7369

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

7370

{

7371

ret = GLEW_ARB_texture_env_dot3;

7372

continue;

7373

}

7374

#endif

7375

#ifdef GL_ARB_texture_float

7376

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

7377

{

7378

ret = GLEW_ARB_texture_float;

7379

continue;

7380

}

7381

#endif

7382

#ifdef GL_ARB_texture_mirrored_repeat

7383

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

7384

{

7385

ret = GLEW_ARB_texture_mirrored_repeat;

7386

continue;

7387

}

7388

#endif

7389

#ifdef GL_ARB_texture_non_power_of_two

7390

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))

7391

{

7392

ret = GLEW_ARB_texture_non_power_of_two;

7393

continue;

7394

}

7395

#endif

7396

#ifdef GL_ARB_texture_rectangle

7397

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

7398

{

7399

ret = GLEW_ARB_texture_rectangle;

7400

continue;

7401

}

7402

#endif

7403

#ifdef GL_ARB_transpose_matrix

7404

if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))

7405

{

7406

ret = GLEW_ARB_transpose_matrix;

7407

continue;

7408

}

7409

#endif

7410

#ifdef GL_ARB_vertex_blend

7411

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))

7412

{

7413

ret = GLEW_ARB_vertex_blend;

7414

continue;

7415

}

7416

#endif

7417

#ifdef GL_ARB_vertex_buffer_object

7418

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))

7419

{

7420

ret = GLEW_ARB_vertex_buffer_object;

7421

continue;

7422

}

7423

#endif

7424

#ifdef GL_ARB_vertex_program

7425

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

7426

{

7427

ret = GLEW_ARB_vertex_program;

7428

continue;

7429

}

7430

#endif

7431

#ifdef GL_ARB_vertex_shader

7432

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

7433

{

7434

ret = GLEW_ARB_vertex_shader;

7435

continue;

7436

}

7437

#endif

7438

#ifdef GL_ARB_window_pos

7439

if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

7440

{

7441

ret = GLEW_ARB_window_pos;

7442

continue;

7443

}

7444

#endif

7445

}

7446

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))

7447

{

7448

#ifdef GL_ATIX_point_sprites

7449

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))

7450

{

7451

ret = GLEW_ATIX_point_sprites;

7452

continue;

7453

}

7454

#endif

7455

#ifdef GL_ATIX_texture_env_combine3

7456

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

7457

{

7458

ret = GLEW_ATIX_texture_env_combine3;

7459

continue;

7460

}

7461

#endif

7462

#ifdef GL_ATIX_texture_env_route

7463

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))

7464

{

7465

ret = GLEW_ATIX_texture_env_route;

7466

continue;

7467

}

7468

#endif

7469

#ifdef GL_ATIX_vertex_shader_output_point_size

7470

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))

7471

{

7472

ret = GLEW_ATIX_vertex_shader_output_point_size;

7473

continue;

7474

}

7475

#endif

7476

}

7477

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

7478

{

7479

#ifdef GL_ATI_draw_buffers

7480

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))

7481

{

7482

ret = GLEW_ATI_draw_buffers;

7483

continue;

7484

}

7485

#endif

7486

#ifdef GL_ATI_element_array

7487

if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))

7488

{

7489

ret = GLEW_ATI_element_array;

7490

continue;

7491

}

7492

#endif

7493

#ifdef GL_ATI_envmap_bumpmap

7494

if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))

7495

{

7496

ret = GLEW_ATI_envmap_bumpmap;

7497

continue;

7498

}

7499

#endif

7500

#ifdef GL_ATI_fragment_shader

7501

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))

7502

{

7503

ret = GLEW_ATI_fragment_shader;

7504

continue;

7505

}

7506

#endif

7507

#ifdef GL_ATI_map_object_buffer

7508

if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))

7509

{

7510

ret = GLEW_ATI_map_object_buffer;

7511

continue;

7512

}

7513

#endif

7514

#ifdef GL_ATI_pn_triangles

7515

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))

7516

{

7517

ret = GLEW_ATI_pn_triangles;

7518

continue;

7519

}

7520

#endif

7521

#ifdef GL_ATI_separate_stencil

7522

if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))

7523

{

7524

ret = GLEW_ATI_separate_stencil;

7525

continue;

7526

}

7527

#endif

7528

#ifdef GL_ATI_text_fragment_shader

7529

if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))

7530

{

7531

ret = GLEW_ATI_text_fragment_shader;

7532

continue;

7533

}

7534

#endif

7535

#ifdef GL_ATI_texture_compression_3dc

7536

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))

7537

{

7538

ret = GLEW_ATI_texture_compression_3dc;

7539

continue;

7540

}

7541

#endif

7542

#ifdef GL_ATI_texture_env_combine3

7543

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))

7544

{

7545

ret = GLEW_ATI_texture_env_combine3;

7546

continue;

7547

}

7548

#endif

7549

#ifdef GL_ATI_texture_float

7550

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))

7551

{

7552

ret = GLEW_ATI_texture_float;

7553

continue;

7554

}

7555

#endif

7556

#ifdef GL_ATI_texture_mirror_once

7557

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))

7558

{

7559

ret = GLEW_ATI_texture_mirror_once;

7560

continue;

7561

}

7562

#endif

7563

#ifdef GL_ATI_vertex_array_object

7564

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))

7565

{

7566

ret = GLEW_ATI_vertex_array_object;

7567

continue;

7568

}

7569

#endif

7570

#ifdef GL_ATI_vertex_attrib_array_object

7571

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))

7572

{

7573

ret = GLEW_ATI_vertex_attrib_array_object;

7574

continue;

7575

}

7576

#endif

7577

#ifdef GL_ATI_vertex_streams

7578

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))

7579

{

7580

ret = GLEW_ATI_vertex_streams;

7581

continue;

7582

}

7583

#endif

7584

}

7585

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

7586

{

7587

#ifdef GL_EXT_422_pixels

7588

if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))

7589

{

7590

ret = GLEW_EXT_422_pixels;

7591

continue;

7592

}

7593

#endif

7594

#ifdef GL_EXT_Cg_shader

7595

if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))

7596

{

7597

ret = GLEW_EXT_Cg_shader;

7598

continue;

7599

}

7600

#endif

7601

#ifdef GL_EXT_abgr

7602

if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))

7603

{

7604

ret = GLEW_EXT_abgr;

7605

continue;

7606

}

7607

#endif

7608

#ifdef GL_EXT_bgra

7609

if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))

7610

{

7611

ret = GLEW_EXT_bgra;

7612

continue;

7613

}

7614

#endif

7615

#ifdef GL_EXT_blend_color

7616

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))

7617

{

7618

ret = GLEW_EXT_blend_color;

7619

continue;

7620

}

7621

#endif

7622

#ifdef GL_EXT_blend_equation_separate

7623

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))

7624

{

7625

ret = GLEW_EXT_blend_equation_separate;

7626

continue;

7627

}

7628

#endif

7629

#ifdef GL_EXT_blend_func_separate

7630

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))

7631

{

7632

ret = GLEW_EXT_blend_func_separate;

7633

continue;

7634

}

7635

#endif

7636

#ifdef GL_EXT_blend_logic_op

7637

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))

7638

{

7639

ret = GLEW_EXT_blend_logic_op;

7640

continue;

7641

}

7642

#endif

7643

#ifdef GL_EXT_blend_minmax

7644

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))

7645

{

7646

ret = GLEW_EXT_blend_minmax;

7647

continue;

7648

}

7649

#endif

7650

#ifdef GL_EXT_blend_subtract

7651

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))

7652

{

7653

ret = GLEW_EXT_blend_subtract;

7654

continue;

7655

}

7656

#endif

7657

#ifdef GL_EXT_clip_volume_hint

7658

if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))

7659

{

7660

ret = GLEW_EXT_clip_volume_hint;

7661

continue;

7662

}

7663

#endif

7664

#ifdef GL_EXT_cmyka

7665

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))

7666

{

7667

ret = GLEW_EXT_cmyka;

7668

continue;

7669

}

7670

#endif

7671

#ifdef GL_EXT_color_subtable

7672

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))

7673

{

7674

ret = GLEW_EXT_color_subtable;

7675

continue;

7676

}

7677

#endif

7678

#ifdef GL_EXT_compiled_vertex_array

7679

if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))

7680

{

7681

ret = GLEW_EXT_compiled_vertex_array;

7682

continue;

7683

}

7684

#endif

7685

#ifdef GL_EXT_convolution

7686

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))

7687

{

7688

ret = GLEW_EXT_convolution;

7689

continue;

7690

}

7691

#endif

7692

#ifdef GL_EXT_coordinate_frame

7693

if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))

7694

{

7695

ret = GLEW_EXT_coordinate_frame;

7696

continue;

7697

}

7698

#endif

7699

#ifdef GL_EXT_copy_texture

7700

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))

7701

{

7702

ret = GLEW_EXT_copy_texture;

7703

continue;

7704

}

7705

#endif

7706

#ifdef GL_EXT_cull_vertex

7707

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

7708

{

7709

ret = GLEW_EXT_cull_vertex;

7710

continue;

7711

}

7712

#endif

7713

#ifdef GL_EXT_depth_bounds_test

7714

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))

7715

{

7716

ret = GLEW_EXT_depth_bounds_test;

7717

continue;

7718

}

7719

#endif

7720

#ifdef GL_EXT_draw_range_elements

7721

if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))

7722

{

7723

ret = GLEW_EXT_draw_range_elements;

7724

continue;

7725

}

7726

#endif

7727

#ifdef GL_EXT_fog_coord

7728

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))

7729

{

7730

ret = GLEW_EXT_fog_coord;

7731

continue;

7732

}

7733

#endif

7734

#ifdef GL_EXT_fragment_lighting

7735

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))

7736

{

7737

ret = GLEW_EXT_fragment_lighting;

7738

continue;

7739

}

7740

#endif

7741

#ifdef GL_EXT_framebuffer_object

7742

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))

7743

{

7744

ret = GLEW_EXT_framebuffer_object;

7745

continue;

7746

}

7747

#endif

7748

#ifdef GL_EXT_histogram

7749

if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))

7750

{

7751

ret = GLEW_EXT_histogram;

7752

continue;

7753

}

7754

#endif

7755

#ifdef GL_EXT_index_array_formats

7756

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))

7757

{

7758

ret = GLEW_EXT_index_array_formats;

7759

continue;

7760

}

7761

#endif

7762

#ifdef GL_EXT_index_func

7763

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))

7764

{

7765

ret = GLEW_EXT_index_func;

7766

continue;

7767

}

7768

#endif

7769

#ifdef GL_EXT_index_material

7770

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))

7771

{

7772

ret = GLEW_EXT_index_material;

7773

continue;

7774

}

7775

#endif

7776

#ifdef GL_EXT_index_texture

7777

if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))

7778

{

7779

ret = GLEW_EXT_index_texture;

7780

continue;

7781

}

7782

#endif

7783

#ifdef GL_EXT_light_texture

7784

if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))

7785

{

7786

ret = GLEW_EXT_light_texture;

7787

continue;

7788

}

7789

#endif

7790

#ifdef GL_EXT_misc_attribute

7791

if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))

7792

{

7793

ret = GLEW_EXT_misc_attribute;

7794

continue;

7795

}

7796

#endif

7797

#ifdef GL_EXT_multi_draw_arrays

7798

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))

7799

{

7800

ret = GLEW_EXT_multi_draw_arrays;

7801

continue;

7802

}

7803

#endif

7804

#ifdef GL_EXT_multisample

7805

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

7806

{

7807

ret = GLEW_EXT_multisample;

7808

continue;

7809

}

7810

#endif

7811

#ifdef GL_EXT_packed_pixels

7812

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))

7813

{

7814

ret = GLEW_EXT_packed_pixels;

7815

continue;

7816

}

7817

#endif

7818

#ifdef GL_EXT_paletted_texture

7819

if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))

7820

{

7821

ret = GLEW_EXT_paletted_texture;

7822

continue;

7823

}

7824

#endif

7825

#ifdef GL_EXT_pixel_buffer_object

7826

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))

7827

{

7828

ret = GLEW_EXT_pixel_buffer_object;

7829

continue;

7830

}

7831

#endif

7832

#ifdef GL_EXT_pixel_transform

7833

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))

7834

{

7835

ret = GLEW_EXT_pixel_transform;

7836

continue;

7837

}

7838

#endif

7839

#ifdef GL_EXT_pixel_transform_color_table

7840

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))

7841

{

7842

ret = GLEW_EXT_pixel_transform_color_table;

7843

continue;

7844

}

7845

#endif

7846

#ifdef GL_EXT_point_parameters

7847

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))

7848

{

7849

ret = GLEW_EXT_point_parameters;

7850

continue;

7851

}

7852

#endif

7853

#ifdef GL_EXT_polygon_offset

7854

if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))

7855

{

7856

ret = GLEW_EXT_polygon_offset;

7857

continue;

7858

}

7859

#endif

7860

#ifdef GL_EXT_rescale_normal

7861

if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))

7862

{

7863

ret = GLEW_EXT_rescale_normal;

7864

continue;

7865

}

7866

#endif

7867

#ifdef GL_EXT_scene_marker

7868

if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

7869

{

7870

ret = GLEW_EXT_scene_marker;

7871

continue;

7872

}

7873

#endif

7874

#ifdef GL_EXT_secondary_color

7875

if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))

7876

{

7877

ret = GLEW_EXT_secondary_color;

7878

continue;

7879

}

7880

#endif

7881

#ifdef GL_EXT_separate_specular_color

7882

if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))

7883

{

7884

ret = GLEW_EXT_separate_specular_color;

7885

continue;

7886

}

7887

#endif

7888

#ifdef GL_EXT_shadow_funcs

7889

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))

7890

{

7891

ret = GLEW_EXT_shadow_funcs;

7892

continue;

7893

}

7894

#endif

7895

#ifdef GL_EXT_shared_texture_palette

7896

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))

7897

{

7898

ret = GLEW_EXT_shared_texture_palette;

7899

continue;

7900

}

7901

#endif

7902

#ifdef GL_EXT_stencil_two_side

7903

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))

7904

{

7905

ret = GLEW_EXT_stencil_two_side;

7906

continue;

7907

}

7908

#endif

7909

#ifdef GL_EXT_stencil_wrap

7910

if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))

7911

{

7912

ret = GLEW_EXT_stencil_wrap;

7913

continue;

7914

}

7915

#endif

7916

#ifdef GL_EXT_subtexture

7917

if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))

7918

{

7919

ret = GLEW_EXT_subtexture;

7920

continue;

7921

}

7922

#endif

7923

#ifdef GL_EXT_texture

7924

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))

7925

{

7926

ret = GLEW_EXT_texture;

7927

continue;

7928

}

7929

#endif

7930

#ifdef GL_EXT_texture3D

7931

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))

7932

{

7933

ret = GLEW_EXT_texture3D;

7934

continue;

7935

}

7936

#endif

7937

#ifdef GL_EXT_texture_compression_dxt1

7938

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))

7939

{

7940

ret = GLEW_EXT_texture_compression_dxt1;

7941

continue;

7942

}

7943

#endif

7944

#ifdef GL_EXT_texture_compression_s3tc

7945

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))

7946

{

7947

ret = GLEW_EXT_texture_compression_s3tc;

7948

continue;

7949

}

7950

#endif

7951

#ifdef GL_EXT_texture_cube_map

7952

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))

7953

{

7954

ret = GLEW_EXT_texture_cube_map;

7955

continue;

7956

}

7957

#endif

7958

#ifdef GL_EXT_texture_edge_clamp

7959

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

7960

{

7961

ret = GLEW_EXT_texture_edge_clamp;

7962

continue;

7963

}

7964

#endif

7965

#ifdef GL_EXT_texture_env

7966

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))

7967

{

7968

ret = GLEW_EXT_texture_env;

7969

continue;

7970

}

7971

#endif

7972

#ifdef GL_EXT_texture_env_add

7973

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))

7974

{

7975

ret = GLEW_EXT_texture_env_add;

7976

continue;

7977

}

7978

#endif

7979

#ifdef GL_EXT_texture_env_combine

7980

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))

7981

{

7982

ret = GLEW_EXT_texture_env_combine;

7983

continue;

7984

}

7985

#endif

7986

#ifdef GL_EXT_texture_env_dot3

7987

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))

7988

{

7989

ret = GLEW_EXT_texture_env_dot3;

7990

continue;

7991

}

7992

#endif

7993

#ifdef GL_EXT_texture_filter_anisotropic

7994

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))

7995

{

7996

ret = GLEW_EXT_texture_filter_anisotropic;

7997

continue;

7998

}

7999

#endif

8000

#ifdef GL_EXT_texture_lod_bias

8001

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

8002

{

8003

ret = GLEW_EXT_texture_lod_bias;

8004

continue;

8005

}

8006

#endif

8007

#ifdef GL_EXT_texture_mirror_clamp

8008

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))

8009

{

8010

ret = GLEW_EXT_texture_mirror_clamp;

8011

continue;

8012

}

8013

#endif

8014

#ifdef GL_EXT_texture_object

8015

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))

8016

{

8017

ret = GLEW_EXT_texture_object;

8018

continue;

8019

}

8020

#endif

8021

#ifdef GL_EXT_texture_perturb_normal

8022

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))

8023

{

8024

ret = GLEW_EXT_texture_perturb_normal;

8025

continue;

8026

}

8027

#endif

8028

#ifdef GL_EXT_texture_rectangle

8029

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

8030

{

8031

ret = GLEW_EXT_texture_rectangle;

8032

continue;

8033

}

8034

#endif

8035

#ifdef GL_EXT_vertex_array

8036

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))

8037

{

8038

ret = GLEW_EXT_vertex_array;

8039

continue;

8040

}

8041

#endif

8042

#ifdef GL_EXT_vertex_shader

8043

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))

8044

{

8045

ret = GLEW_EXT_vertex_shader;

8046

continue;

8047

}

8048

#endif

8049

#ifdef GL_EXT_vertex_weighting

8050

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))

8051

{

8052

ret = GLEW_EXT_vertex_weighting;

8053

continue;

8054

}

8055

#endif

8056

}

8057

if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))

8058

{

8059

#ifdef GL_HP_convolution_border_modes

8060

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

8061

{

8062

ret = GLEW_HP_convolution_border_modes;

8063

continue;

8064

}

8065

#endif

8066

#ifdef GL_HP_image_transform

8067

if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))

8068

{

8069

ret = GLEW_HP_image_transform;

8070

continue;

8071

}

8072

#endif

8073

#ifdef GL_HP_occlusion_test

8074

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))

8075

{

8076

ret = GLEW_HP_occlusion_test;

8077

continue;

8078

}

8079

#endif

8080

#ifdef GL_HP_texture_lighting

8081

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))

8082

{

8083

ret = GLEW_HP_texture_lighting;

8084

continue;

8085

}

8086

#endif

8087

}

8088

if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))

8089

{

8090

#ifdef GL_IBM_cull_vertex

8091

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))

8092

{

8093

ret = GLEW_IBM_cull_vertex;

8094

continue;

8095

}

8096

#endif

8097

#ifdef GL_IBM_multimode_draw_arrays

8098

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))

8099

{

8100

ret = GLEW_IBM_multimode_draw_arrays;

8101

continue;

8102

}

8103

#endif

8104

#ifdef GL_IBM_rasterpos_clip

8105

if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))

8106

{

8107

ret = GLEW_IBM_rasterpos_clip;

8108

continue;

8109

}

8110

#endif

8111

#ifdef GL_IBM_static_data

8112

if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))

8113

{

8114

ret = GLEW_IBM_static_data;

8115

continue;

8116

}

8117

#endif

8118

#ifdef GL_IBM_texture_mirrored_repeat

8119

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))

8120

{

8121

ret = GLEW_IBM_texture_mirrored_repeat;

8122

continue;

8123

}

8124

#endif

8125

#ifdef GL_IBM_vertex_array_lists

8126

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))

8127

{

8128

ret = GLEW_IBM_vertex_array_lists;

8129

continue;

8130

}

8131

#endif

8132

}

8133

if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))

8134

{

8135

#ifdef GL_INGR_color_clamp

8136

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))

8137

{

8138

ret = GLEW_INGR_color_clamp;

8139

continue;

8140

}

8141

#endif

8142

#ifdef GL_INGR_interlace_read

8143

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))

8144

{

8145

ret = GLEW_INGR_interlace_read;

8146

continue;

8147

}

8148

#endif

8149

}

8150

if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))

8151

{

8152

#ifdef GL_INTEL_parallel_arrays

8153

if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))

8154

{

8155

ret = GLEW_INTEL_parallel_arrays;

8156

continue;

8157

}

8158

#endif

8159

#ifdef GL_INTEL_texture_scissor

8160

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))

8161

{

8162

ret = GLEW_INTEL_texture_scissor;

8163

continue;

8164

}

8165

#endif

8166

}

8167

if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))

8168

{

8169

#ifdef GL_KTX_buffer_region

8170

if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

8171

{

8172

ret = GLEW_KTX_buffer_region;

8173

continue;

8174

}

8175

#endif

8176

}

8177

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

8178

{

8179

#ifdef GL_MESA_pack_invert

8180

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))

8181

{

8182

ret = GLEW_MESA_pack_invert;

8183

continue;

8184

}

8185

#endif

8186

#ifdef GL_MESA_resize_buffers

8187

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))

8188

{

8189

ret = GLEW_MESA_resize_buffers;

8190

continue;

8191

}

8192

#endif

8193

#ifdef GL_MESA_window_pos

8194

if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))

8195

{

8196

ret = GLEW_MESA_window_pos;

8197

continue;

8198

}

8199

#endif

8200

#ifdef GL_MESA_ycbcr_texture

8201

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))

8202

{

8203

ret = GLEW_MESA_ycbcr_texture;

8204

continue;

8205

}

8206

#endif

8207

}

8208

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

8209

{

8210

#ifdef GL_NV_blend_square

8211

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))

8212

{

8213

ret = GLEW_NV_blend_square;

8214

continue;

8215

}

8216

#endif

8217

#ifdef GL_NV_copy_depth_to_color

8218

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))

8219

{

8220

ret = GLEW_NV_copy_depth_to_color;

8221

continue;

8222

}

8223

#endif

8224

#ifdef GL_NV_depth_clamp

8225

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))

8226

{

8227

ret = GLEW_NV_depth_clamp;

8228

continue;

8229

}

8230

#endif

8231

#ifdef GL_NV_evaluators

8232

if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))

8233

{

8234

ret = GLEW_NV_evaluators;

8235

continue;

8236

}

8237

#endif

8238

#ifdef GL_NV_fence

8239

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))

8240

{

8241

ret = GLEW_NV_fence;

8242

continue;

8243

}

8244

#endif

8245

#ifdef GL_NV_float_buffer

8246

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

8247

{

8248

ret = GLEW_NV_float_buffer;

8249

continue;

8250

}

8251

#endif

8252

#ifdef GL_NV_fog_distance

8253

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))

8254

{

8255

ret = GLEW_NV_fog_distance;

8256

continue;

8257

}

8258

#endif

8259

#ifdef GL_NV_fragment_program

8260

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))

8261

{

8262

ret = GLEW_NV_fragment_program;

8263

continue;

8264

}

8265

#endif

8266

#ifdef GL_NV_fragment_program2

8267

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))

8268

{

8269

ret = GLEW_NV_fragment_program2;

8270

continue;

8271

}

8272

#endif

8273

#ifdef GL_NV_fragment_program_option

8274

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))

8275

{

8276

ret = GLEW_NV_fragment_program_option;

8277

continue;

8278

}

8279

#endif

8280

#ifdef GL_NV_half_float

8281

if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))

8282

{

8283

ret = GLEW_NV_half_float;

8284

continue;

8285

}

8286

#endif

8287

#ifdef GL_NV_light_max_exponent

8288

if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))

8289

{

8290

ret = GLEW_NV_light_max_exponent;

8291

continue;

8292

}

8293

#endif

8294

#ifdef GL_NV_multisample_filter_hint

8295

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))

8296

{

8297

ret = GLEW_NV_multisample_filter_hint;

8298

continue;

8299

}

8300

#endif

8301

#ifdef GL_NV_occlusion_query

8302

if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))

8303

{

8304

ret = GLEW_NV_occlusion_query;

8305

continue;

8306

}

8307

#endif

8308

#ifdef GL_NV_packed_depth_stencil

8309

if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))

8310

{

8311

ret = GLEW_NV_packed_depth_stencil;

8312

continue;

8313

}

8314

#endif

8315

#ifdef GL_NV_pixel_data_range

8316

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))

8317

{

8318

ret = GLEW_NV_pixel_data_range;

8319

continue;

8320

}

8321

#endif

8322

#ifdef GL_NV_point_sprite

8323

if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))

8324

{

8325

ret = GLEW_NV_point_sprite;

8326

continue;

8327

}

8328

#endif

8329

#ifdef GL_NV_primitive_restart

8330

if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))

8331

{

8332

ret = GLEW_NV_primitive_restart;

8333

continue;

8334

}

8335

#endif

8336

#ifdef GL_NV_register_combiners

8337

if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))

8338

{

8339

ret = GLEW_NV_register_combiners;

8340

continue;

8341

}

8342

#endif

8343

#ifdef GL_NV_register_combiners2

8344

if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))

8345

{

8346

ret = GLEW_NV_register_combiners2;

8347

continue;

8348

}

8349

#endif

8350

#ifdef GL_NV_texgen_emboss

8351

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))

8352

{

8353

ret = GLEW_NV_texgen_emboss;

8354

continue;

8355

}

8356

#endif

8357

#ifdef GL_NV_texgen_reflection

8358

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))

8359

{

8360

ret = GLEW_NV_texgen_reflection;

8361

continue;

8362

}

8363

#endif

8364

#ifdef GL_NV_texture_compression_vtc

8365

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))

8366

{

8367

ret = GLEW_NV_texture_compression_vtc;

8368

continue;

8369

}

8370

#endif

8371

#ifdef GL_NV_texture_env_combine4

8372

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))

8373

{

8374

ret = GLEW_NV_texture_env_combine4;

8375

continue;

8376

}

8377

#endif

8378

#ifdef GL_NV_texture_expand_normal

8379

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))

8380

{

8381

ret = GLEW_NV_texture_expand_normal;

8382

continue;

8383

}

8384

#endif

8385

#ifdef GL_NV_texture_rectangle

8386

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))

8387

{

8388

ret = GLEW_NV_texture_rectangle;

8389

continue;

8390

}

8391

#endif

8392

#ifdef GL_NV_texture_shader

8393

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))

8394

{

8395

ret = GLEW_NV_texture_shader;

8396

continue;

8397

}

8398

#endif

8399

#ifdef GL_NV_texture_shader2

8400

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))

8401

{

8402

ret = GLEW_NV_texture_shader2;

8403

continue;

8404

}

8405

#endif

8406

#ifdef GL_NV_texture_shader3

8407

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))

8408

{

8409

ret = GLEW_NV_texture_shader3;

8410

continue;

8411

}

8412

#endif

8413

#ifdef GL_NV_vertex_array_range

8414

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

8415

{

8416

ret = GLEW_NV_vertex_array_range;

8417

continue;

8418

}

8419

#endif

8420

#ifdef GL_NV_vertex_array_range2

8421

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))

8422

{

8423

ret = GLEW_NV_vertex_array_range2;

8424

continue;

8425

}

8426

#endif

8427

#ifdef GL_NV_vertex_program

8428

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))

8429

{

8430

ret = GLEW_NV_vertex_program;

8431

continue;

8432

}

8433

#endif

8434

#ifdef GL_NV_vertex_program1_1

8435

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))

8436

{

8437

ret = GLEW_NV_vertex_program1_1;

8438

continue;

8439

}

8440

#endif

8441

#ifdef GL_NV_vertex_program2

8442

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))

8443

{

8444

ret = GLEW_NV_vertex_program2;

8445

continue;

8446

}

8447

#endif

8448

#ifdef GL_NV_vertex_program2_option

8449

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))

8450

{

8451

ret = GLEW_NV_vertex_program2_option;

8452

continue;

8453

}

8454

#endif

8455

#ifdef GL_NV_vertex_program3

8456

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))

8457

{

8458

ret = GLEW_NV_vertex_program3;

8459

continue;

8460

}

8461

#endif

8462

}

8463

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

8464

{

8465

#ifdef GL_OML_interlace

8466

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

8467

{

8468

ret = GLEW_OML_interlace;

8469

continue;

8470

}

8471

#endif

8472

#ifdef GL_OML_resample

8473

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

8474

{

8475

ret = GLEW_OML_resample;

8476

continue;

8477

}

8478

#endif

8479

#ifdef GL_OML_subsample

8480

if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))

8481

{

8482

ret = GLEW_OML_subsample;

8483

continue;

8484

}

8485

#endif

8486

}

8487

if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))

8488

{

8489

#ifdef GL_PGI_misc_hints

8490

if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))

8491

{

8492

ret = GLEW_PGI_misc_hints;

8493

continue;

8494

}

8495

#endif

8496

#ifdef GL_PGI_vertex_hints

8497

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))

8498

{

8499

ret = GLEW_PGI_vertex_hints;

8500

continue;

8501

}

8502

#endif

8503

}

8504

if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))

8505

{

8506

#ifdef GL_REND_screen_coordinates

8507

if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))

8508

{

8509

ret = GLEW_REND_screen_coordinates;

8510

continue;

8511

}

8512

#endif

8513

}

8514

if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))

8515

{

8516

#ifdef GL_S3_s3tc

8517

if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))

8518

{

8519

ret = GLEW_S3_s3tc;

8520

continue;

8521

}

8522

#endif

8523

}

8524

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

8525

{

8526

#ifdef GL_SGIS_color_range

8527

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

8528

{

8529

ret = GLEW_SGIS_color_range;

8530

continue;

8531

}

8532

#endif

8533

#ifdef GL_SGIS_detail_texture

8534

if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))

8535

{

8536

ret = GLEW_SGIS_detail_texture;

8537

continue;

8538

}

8539

#endif

8540

#ifdef GL_SGIS_fog_function

8541

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))

8542

{

8543

ret = GLEW_SGIS_fog_function;

8544

continue;

8545

}

8546

#endif

8547

#ifdef GL_SGIS_generate_mipmap

8548

if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))

8549

{

8550

ret = GLEW_SGIS_generate_mipmap;

8551

continue;

8552

}

8553

#endif

8554

#ifdef GL_SGIS_multisample

8555

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

8556

{

8557

ret = GLEW_SGIS_multisample;

8558

continue;

8559

}

8560

#endif

8561

#ifdef GL_SGIS_pixel_texture

8562

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

8563

{

8564

ret = GLEW_SGIS_pixel_texture;

8565

continue;

8566

}

8567

#endif

8568

#ifdef GL_SGIS_sharpen_texture

8569

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))

8570

{

8571

ret = GLEW_SGIS_sharpen_texture;

8572

continue;

8573

}

8574

#endif

8575

#ifdef GL_SGIS_texture4D

8576

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))

8577

{

8578

ret = GLEW_SGIS_texture4D;

8579

continue;

8580

}

8581

#endif

8582

#ifdef GL_SGIS_texture_border_clamp

8583

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))

8584

{

8585

ret = GLEW_SGIS_texture_border_clamp;

8586

continue;

8587

}

8588

#endif

8589

#ifdef GL_SGIS_texture_edge_clamp

8590

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))

8591

{

8592

ret = GLEW_SGIS_texture_edge_clamp;

8593

continue;

8594

}

8595

#endif

8596

#ifdef GL_SGIS_texture_filter4

8597

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))

8598

{

8599

ret = GLEW_SGIS_texture_filter4;

8600

continue;

8601

}

8602

#endif

8603

#ifdef GL_SGIS_texture_lod

8604

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))

8605

{

8606

ret = GLEW_SGIS_texture_lod;

8607

continue;

8608

}

8609

#endif

8610

#ifdef GL_SGIS_texture_select

8611

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))

8612

{

8613

ret = GLEW_SGIS_texture_select;

8614

continue;

8615

}

8616

#endif

8617

}

8618

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

8619

{

8620

#ifdef GL_SGIX_async

8621

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))

8622

{

8623

ret = GLEW_SGIX_async;

8624

continue;

8625

}

8626

#endif

8627

#ifdef GL_SGIX_async_histogram

8628

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))

8629

{

8630

ret = GLEW_SGIX_async_histogram;

8631

continue;

8632

}

8633

#endif

8634

#ifdef GL_SGIX_async_pixel

8635

if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))

8636

{

8637

ret = GLEW_SGIX_async_pixel;

8638

continue;

8639

}

8640

#endif

8641

#ifdef GL_SGIX_blend_alpha_minmax

8642

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))

8643

{

8644

ret = GLEW_SGIX_blend_alpha_minmax;

8645

continue;

8646

}

8647

#endif

8648

#ifdef GL_SGIX_clipmap

8649

if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))

8650

{

8651

ret = GLEW_SGIX_clipmap;

8652

continue;

8653

}

8654

#endif

8655

#ifdef GL_SGIX_depth_texture

8656

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))

8657

{

8658

ret = GLEW_SGIX_depth_texture;

8659

continue;

8660

}

8661

#endif

8662

#ifdef GL_SGIX_flush_raster

8663

if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))

8664

{

8665

ret = GLEW_SGIX_flush_raster;

8666

continue;

8667

}

8668

#endif

8669

#ifdef GL_SGIX_fog_offset

8670

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))

8671

{

8672

ret = GLEW_SGIX_fog_offset;

8673

continue;

8674

}

8675

#endif

8676

#ifdef GL_SGIX_fog_texture

8677

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))

8678

{

8679

ret = GLEW_SGIX_fog_texture;

8680

continue;

8681

}

8682

#endif

8683

#ifdef GL_SGIX_fragment_specular_lighting

8684

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))

8685

{

8686

ret = GLEW_SGIX_fragment_specular_lighting;

8687

continue;

8688

}

8689

#endif

8690

#ifdef GL_SGIX_framezoom

8691

if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))

8692

{

8693

ret = GLEW_SGIX_framezoom;

8694

continue;

8695

}

8696

#endif

8697

#ifdef GL_SGIX_interlace

8698

if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))

8699

{

8700

ret = GLEW_SGIX_interlace;

8701

continue;

8702

}

8703

#endif

8704

#ifdef GL_SGIX_ir_instrument1

8705

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))

8706

{

8707

ret = GLEW_SGIX_ir_instrument1;

8708

continue;

8709

}

8710

#endif

8711

#ifdef GL_SGIX_list_priority

8712

if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))

8713

{

8714

ret = GLEW_SGIX_list_priority;

8715

continue;

8716

}

8717

#endif

8718

#ifdef GL_SGIX_pixel_texture

8719

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))

8720

{

8721

ret = GLEW_SGIX_pixel_texture;

8722

continue;

8723

}

8724

#endif

8725

#ifdef GL_SGIX_pixel_texture_bits

8726

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))

8727

{

8728

ret = GLEW_SGIX_pixel_texture_bits;

8729

continue;

8730

}

8731

#endif

8732

#ifdef GL_SGIX_reference_plane

8733

if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))

8734

{

8735

ret = GLEW_SGIX_reference_plane;

8736

continue;

8737

}

8738

#endif

8739

#ifdef GL_SGIX_resample

8740

if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))

8741

{

8742

ret = GLEW_SGIX_resample;

8743

continue;

8744

}

8745

#endif

8746

#ifdef GL_SGIX_shadow

8747

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))

8748

{

8749

ret = GLEW_SGIX_shadow;

8750

continue;

8751

}

8752

#endif

8753

#ifdef GL_SGIX_shadow_ambient

8754

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))

8755

{

8756

ret = GLEW_SGIX_shadow_ambient;

8757

continue;

8758

}

8759

#endif

8760

#ifdef GL_SGIX_sprite

8761

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))

8762

{

8763

ret = GLEW_SGIX_sprite;

8764

continue;

8765

}

8766

#endif

8767

#ifdef GL_SGIX_tag_sample_buffer

8768

if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))

8769

{

8770

ret = GLEW_SGIX_tag_sample_buffer;

8771

continue;

8772

}

8773

#endif

8774

#ifdef GL_SGIX_texture_add_env

8775

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))

8776

{

8777

ret = GLEW_SGIX_texture_add_env;

8778

continue;

8779

}

8780

#endif

8781

#ifdef GL_SGIX_texture_coordinate_clamp

8782

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))

8783

{

8784

ret = GLEW_SGIX_texture_coordinate_clamp;

8785

continue;

8786

}

8787

#endif

8788

#ifdef GL_SGIX_texture_lod_bias

8789

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))

8790

{

8791

ret = GLEW_SGIX_texture_lod_bias;

8792

continue;

8793

}

8794

#endif

8795

#ifdef GL_SGIX_texture_multi_buffer

8796

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))

8797

{

8798

ret = GLEW_SGIX_texture_multi_buffer;

8799

continue;

8800

}

8801

#endif

8802

#ifdef GL_SGIX_texture_range

8803

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))

8804

{

8805

ret = GLEW_SGIX_texture_range;

8806

continue;

8807

}

8808

#endif

8809

#ifdef GL_SGIX_texture_scale_bias

8810

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))

8811

{

8812

ret = GLEW_SGIX_texture_scale_bias;

8813

continue;

8814

}

8815

#endif

8816

#ifdef GL_SGIX_vertex_preclip

8817

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))

8818

{

8819

ret = GLEW_SGIX_vertex_preclip;

8820

continue;

8821

}

8822

#endif

8823

#ifdef GL_SGIX_vertex_preclip_hint

8824

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))

8825

{

8826

ret = GLEW_SGIX_vertex_preclip_hint;

8827

continue;

8828

}

8829

#endif

8830

#ifdef GL_SGIX_ycrcb

8831

if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))

8832

{

8833

ret = GLEW_SGIX_ycrcb;

8834

continue;

8835

}

8836

#endif

8837

}

8838

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

8839

{

8840

#ifdef GL_SGI_color_matrix

8841

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))

8842

{

8843

ret = GLEW_SGI_color_matrix;

8844

continue;

8845

}

8846

#endif

8847

#ifdef GL_SGI_color_table

8848

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))

8849

{

8850

ret = GLEW_SGI_color_table;

8851

continue;

8852

}

8853

#endif

8854

#ifdef GL_SGI_texture_color_table

8855

if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))

8856

{

8857

ret = GLEW_SGI_texture_color_table;

8858

continue;

8859

}

8860

#endif

8861

}

8862

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))

8863

{

8864

#ifdef GL_SUNX_constant_data

8865

if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))

8866

{

8867

ret = GLEW_SUNX_constant_data;

8868

continue;

8869

}

8870

#endif

8871

}

8872

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

8873

{

8874

#ifdef GL_SUN_convolution_border_modes

8875

if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))

8876

{

8877

ret = GLEW_SUN_convolution_border_modes;

8878

continue;

8879

}

8880

#endif

8881

#ifdef GL_SUN_global_alpha

8882

if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))

8883

{

8884

ret = GLEW_SUN_global_alpha;

8885

continue;

8886

}

8887

#endif

8888

#ifdef GL_SUN_mesh_array

8889

if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))

8890

{

8891

ret = GLEW_SUN_mesh_array;

8892

continue;

8893

}

8894

#endif

8895

#ifdef GL_SUN_read_video_pixels

8896

if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))

8897

{

8898

ret = GLEW_SUN_read_video_pixels;

8899

continue;

8900

}

8901

#endif

8902

#ifdef GL_SUN_slice_accum

8903

if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))

8904

{

8905

ret = GLEW_SUN_slice_accum;

8906

continue;

8907

}

8908

#endif

8909

#ifdef GL_SUN_triangle_list

8910

if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))

8911

{

8912

ret = GLEW_SUN_triangle_list;

8913

continue;

8914

}

8915

#endif

8916

#ifdef GL_SUN_vertex

8917

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))

8918

{

8919

ret = GLEW_SUN_vertex;

8920

continue;

8921

}

8922

#endif

8923

}

8924

if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))

8925

{

8926

#ifdef GL_WIN_phong_shading

8927

if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))

8928

{

8929

ret = GLEW_WIN_phong_shading;

8930

continue;

8931

}

8932

#endif

8933

#ifdef GL_WIN_specular_fog

8934

if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))

8935

{

8936

ret = GLEW_WIN_specular_fog;

8937

continue;

8938

}

8939

#endif

8940

#ifdef GL_WIN_swap_hint

8941

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))

8942

{

8943

ret = GLEW_WIN_swap_hint;

8944

continue;

8945

}

8946

#endif

8947

}

8948

}

8949

ret = (len == 0);

8950

}

8951

return ret;

8952

}

8953

8954

#if defined(_WIN32)

8955

8956

#if defined(GLEW_MX)

8957

GLboolean wglewContextIsSupported (WGLEWContext* ctx, const char* name)

8958

#else

8959

GLboolean wglewIsSupported (const char* name)

8960

#endif

8961

{

8962

GLubyte* pos = (GLubyte*)name;

8963

GLuint len = _glewStrLen(pos);

8964

GLboolean ret = GL_TRUE;

8965

while (ret && len > 0)

8966

{

8967

if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))

8968

{

8969

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

8970

{

8971

#ifdef WGL_3DFX_multisample

8972

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

8973

{

8974

ret = WGLEW_3DFX_multisample;

8975

continue;

8976

}

8977

#endif

8978

}

8979

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

8980

{

8981

#ifdef WGL_ARB_buffer_region

8982

if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))

8983

{

8984

ret = WGLEW_ARB_buffer_region;

8985

continue;

8986

}

8987

#endif

8988

#ifdef WGL_ARB_extensions_string

8989

if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

8990

{

8991

ret = WGLEW_ARB_extensions_string;

8992

continue;

8993

}

8994

#endif

8995

#ifdef WGL_ARB_make_current_read

8996

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

8997

{

8998

ret = WGLEW_ARB_make_current_read;

8999

continue;

9000

}

9001

#endif

9002

#ifdef WGL_ARB_multisample

9003

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9004

{

9005

ret = WGLEW_ARB_multisample;

9006

continue;

9007

}

9008

#endif

9009

#ifdef WGL_ARB_pbuffer

9010

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

9011

{

9012

ret = WGLEW_ARB_pbuffer;

9013

continue;

9014

}

9015

#endif

9016

#ifdef WGL_ARB_pixel_format

9017

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

9018

{

9019

ret = WGLEW_ARB_pixel_format;

9020

continue;

9021

}

9022

#endif

9023

#ifdef WGL_ARB_pixel_format_float

9024

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

9025

{

9026

ret = WGLEW_ARB_pixel_format_float;

9027

continue;

9028

}

9029

#endif

9030

#ifdef WGL_ARB_render_texture

9031

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

9032

{

9033

ret = WGLEW_ARB_render_texture;

9034

continue;

9035

}

9036

#endif

9037

}

9038

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

9039

{

9040

#ifdef WGL_ATI_pixel_format_float

9041

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

9042

{

9043

ret = WGLEW_ATI_pixel_format_float;

9044

continue;

9045

}

9046

#endif

9047

#ifdef WGL_ATI_render_texture_rectangle

9048

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

9049

{

9050

ret = WGLEW_ATI_render_texture_rectangle;

9051

continue;

9052

}

9053

#endif

9054

}

9055

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

9056

{

9057

#ifdef WGL_EXT_depth_float

9058

if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))

9059

{

9060

ret = WGLEW_EXT_depth_float;

9061

continue;

9062

}

9063

#endif

9064

#ifdef WGL_EXT_display_color_table

9065

if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))

9066

{

9067

ret = WGLEW_EXT_display_color_table;

9068

continue;

9069

}

9070

#endif

9071

#ifdef WGL_EXT_extensions_string

9072

if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))

9073

{

9074

ret = WGLEW_EXT_extensions_string;

9075

continue;

9076

}

9077

#endif

9078

#ifdef WGL_EXT_make_current_read

9079

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

9080

{

9081

ret = WGLEW_EXT_make_current_read;

9082

continue;

9083

}

9084

#endif

9085

#ifdef WGL_EXT_multisample

9086

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9087

{

9088

ret = WGLEW_EXT_multisample;

9089

continue;

9090

}

9091

#endif

9092

#ifdef WGL_EXT_pbuffer

9093

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

9094

{

9095

ret = WGLEW_EXT_pbuffer;

9096

continue;

9097

}

9098

#endif

9099

#ifdef WGL_EXT_pixel_format

9100

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))

9101

{

9102

ret = WGLEW_EXT_pixel_format;

9103

continue;

9104

}

9105

#endif

9106

#ifdef WGL_EXT_swap_control

9107

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

9108

{

9109

ret = WGLEW_EXT_swap_control;

9110

continue;

9111

}

9112

#endif

9113

}

9114

if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))

9115

{

9116

#ifdef WGL_I3D_digital_video_control

9117

if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))

9118

{

9119

ret = WGLEW_I3D_digital_video_control;

9120

continue;

9121

}

9122

#endif

9123

#ifdef WGL_I3D_gamma

9124

if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))

9125

{

9126

ret = WGLEW_I3D_gamma;

9127

continue;

9128

}

9129

#endif

9130

#ifdef WGL_I3D_genlock

9131

if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))

9132

{

9133

ret = WGLEW_I3D_genlock;

9134

continue;

9135

}

9136

#endif

9137

#ifdef WGL_I3D_image_buffer

9138

if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))

9139

{

9140

ret = WGLEW_I3D_image_buffer;

9141

continue;

9142

}

9143

#endif

9144

#ifdef WGL_I3D_swap_frame_lock

9145

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))

9146

{

9147

ret = WGLEW_I3D_swap_frame_lock;

9148

continue;

9149

}

9150

#endif

9151

#ifdef WGL_I3D_swap_frame_usage

9152

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))

9153

{

9154

ret = WGLEW_I3D_swap_frame_usage;

9155

continue;

9156

}

9157

#endif

9158

}

9159

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

9160

{

9161

#ifdef WGL_NV_float_buffer

9162

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

9163

{

9164

ret = WGLEW_NV_float_buffer;

9165

continue;

9166

}

9167

#endif

9168

#ifdef WGL_NV_render_depth_texture

9169

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))

9170

{

9171

ret = WGLEW_NV_render_depth_texture;

9172

continue;

9173

}

9174

#endif

9175

#ifdef WGL_NV_render_texture_rectangle

9176

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))

9177

{

9178

ret = WGLEW_NV_render_texture_rectangle;

9179

continue;

9180

}

9181

#endif

9182

#ifdef WGL_NV_vertex_array_range

9183

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

9184

{

9185

ret = WGLEW_NV_vertex_array_range;

9186

continue;

9187

}

9188

#endif

9189

}

9190

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

9191

{

9192

#ifdef WGL_OML_sync_control

9193

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

9194

{

9195

ret = WGLEW_OML_sync_control;

9196

continue;

9197

}

9198

#endif

9199

}

9200

}

9201

ret = (len == 0);

9202

}

9203

return ret;

9204

}

9205

9206

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

9207

9208

#if defined(GLEW_MX)

9209

GLboolean glxewContextIsSupported (GLXEWContext* ctx, const char* name)

9210

#else

9211

GLboolean glxewIsSupported (const char* name)

9212

#endif

9213

{

9214

GLubyte* pos = (GLubyte*)name;

9215

GLuint len = _glewStrLen(pos);

9216

GLboolean ret = GL_TRUE;

9217

while (ret && len > 0)

9218

{

9219

if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))

9220

{

9221

if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))

9222

{

9223

#ifdef GLX_VERSION_1_2

9224

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))

9225

{

9226

ret = GLXEW_VERSION_1_2;

9227

continue;

9228

}

9229

#endif

9230

#ifdef GLX_VERSION_1_3

9231

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))

9232

{

9233

ret = GLXEW_VERSION_1_3;

9234

continue;

9235

}

9236

#endif

9237

#ifdef GLX_VERSION_1_4

9238

if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))

9239

{

9240

ret = GLXEW_VERSION_1_4;

9241

continue;

9242

}

9243

#endif

9244

}

9245

if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))

9246

{

9247

#ifdef GLX_3DFX_multisample

9248

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9249

{

9250

ret = GLXEW_3DFX_multisample;

9251

continue;

9252

}

9253

#endif

9254

}

9255

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))

9256

{

9257

#ifdef GLX_ARB_fbconfig_float

9258

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))

9259

{

9260

ret = GLXEW_ARB_fbconfig_float;

9261

continue;

9262

}

9263

#endif

9264

#ifdef GLX_ARB_get_proc_address

9265

if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))

9266

{

9267

ret = GLXEW_ARB_get_proc_address;

9268

continue;

9269

}

9270

#endif

9271

#ifdef GLX_ARB_multisample

9272

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9273

{

9274

ret = GLXEW_ARB_multisample;

9275

continue;

9276

}

9277

#endif

9278

}

9279

if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))

9280

{

9281

#ifdef GLX_ATI_pixel_format_float

9282

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))

9283

{

9284

ret = GLXEW_ATI_pixel_format_float;

9285

continue;

9286

}

9287

#endif

9288

#ifdef GLX_ATI_render_texture

9289

if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))

9290

{

9291

ret = GLXEW_ATI_render_texture;

9292

continue;

9293

}

9294

#endif

9295

}

9296

if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))

9297

{

9298

#ifdef GLX_EXT_import_context

9299

if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))

9300

{

9301

ret = GLXEW_EXT_import_context;

9302

continue;

9303

}

9304

#endif

9305

#ifdef GLX_EXT_scene_marker

9306

if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))

9307

{

9308

ret = GLXEW_EXT_scene_marker;

9309

continue;

9310

}

9311

#endif

9312

#ifdef GLX_EXT_visual_info

9313

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))

9314

{

9315

ret = GLXEW_EXT_visual_info;

9316

continue;

9317

}

9318

#endif

9319

#ifdef GLX_EXT_visual_rating

9320

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))

9321

{

9322

ret = GLXEW_EXT_visual_rating;

9323

continue;

9324

}

9325

#endif

9326

}

9327

if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))

9328

{

9329

#ifdef GLX_MESA_agp_offset

9330

if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))

9331

{

9332

ret = GLXEW_MESA_agp_offset;

9333

continue;

9334

}

9335

#endif

9336

#ifdef GLX_MESA_copy_sub_buffer

9337

if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))

9338

{

9339

ret = GLXEW_MESA_copy_sub_buffer;

9340

continue;

9341

}

9342

#endif

9343

#ifdef GLX_MESA_pixmap_colormap

9344

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))

9345

{

9346

ret = GLXEW_MESA_pixmap_colormap;

9347

continue;

9348

}

9349

#endif

9350

#ifdef GLX_MESA_release_buffers

9351

if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))

9352

{

9353

ret = GLXEW_MESA_release_buffers;

9354

continue;

9355

}

9356

#endif

9357

#ifdef GLX_MESA_set_3dfx_mode

9358

if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))

9359

{

9360

ret = GLXEW_MESA_set_3dfx_mode;

9361

continue;

9362

}

9363

#endif

9364

}

9365

if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))

9366

{

9367

#ifdef GLX_NV_float_buffer

9368

if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))

9369

{

9370

ret = GLXEW_NV_float_buffer;

9371

continue;

9372

}

9373

#endif

9374

#ifdef GLX_NV_vertex_array_range

9375

if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))

9376

{

9377

ret = GLXEW_NV_vertex_array_range;

9378

continue;

9379

}

9380

#endif

9381

}

9382

if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))

9383

{

9384

#ifdef GLX_OML_swap_method

9385

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))

9386

{

9387

ret = GLXEW_OML_swap_method;

9388

continue;

9389

}

9390

#endif

9391

#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

9392

#include <inttypes.h>

9393

if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))

9394

{

9395

ret = GLXEW_OML_sync_control;

9396

continue;

9397

}

9398

#endif

9399

}

9400

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))

9401

{

9402

#ifdef GLX_SGIS_blended_overlay

9403

if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))

9404

{

9405

ret = GLXEW_SGIS_blended_overlay;

9406

continue;

9407

}

9408

#endif

9409

#ifdef GLX_SGIS_color_range

9410

if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))

9411

{

9412

ret = GLXEW_SGIS_color_range;

9413

continue;

9414

}

9415

#endif

9416

#ifdef GLX_SGIS_multisample

9417

if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))

9418

{

9419

ret = GLXEW_SGIS_multisample;

9420

continue;

9421

}

9422

#endif

9423

#ifdef GLX_SGIS_shared_multisample

9424

if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))

9425

{

9426

ret = GLXEW_SGIS_shared_multisample;

9427

continue;

9428

}

9429

#endif

9430

}

9431

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))

9432

{

9433

#ifdef GLX_SGIX_fbconfig

9434

if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))

9435

{

9436

ret = GLXEW_SGIX_fbconfig;

9437

continue;

9438

}

9439

#endif

9440

#ifdef GLX_SGIX_pbuffer

9441

if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))

9442

{

9443

ret = GLXEW_SGIX_pbuffer;

9444

continue;

9445

}

9446

#endif

9447

#ifdef GLX_SGIX_swap_barrier

9448

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))

9449

{

9450

ret = GLXEW_SGIX_swap_barrier;

9451

continue;

9452

}

9453

#endif

9454

#ifdef GLX_SGIX_swap_group

9455

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))

9456

{

9457

ret = GLXEW_SGIX_swap_group;

9458

continue;

9459

}

9460

#endif

9461

#ifdef GLX_SGIX_video_resize

9462

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

9463

{

9464

ret = GLXEW_SGIX_video_resize;

9465

continue;

9466

}

9467

#endif

9468

#ifdef GLX_SGIX_visual_select_group

9469

if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))

9470

{

9471

ret = GLXEW_SGIX_visual_select_group;

9472

continue;

9473

}

9474

#endif

9475

}

9476

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))

9477

{

9478

#ifdef GLX_SGI_cushion

9479

if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))

9480

{

9481

ret = GLXEW_SGI_cushion;

9482

continue;

9483

}

9484

#endif

9485

#ifdef GLX_SGI_make_current_read

9486

if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))

9487

{

9488

ret = GLXEW_SGI_make_current_read;

9489

continue;

9490

}

9491

#endif

9492

#ifdef GLX_SGI_swap_control

9493

if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))

9494

{

9495

ret = GLXEW_SGI_swap_control;

9496

continue;

9497

}

9498

#endif

9499

#ifdef GLX_SGI_video_sync

9500

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))

9501

{

9502

ret = GLXEW_SGI_video_sync;

9503

continue;

9504

}

9505

#endif

9506

}

9507

if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))

9508

{

9509

#ifdef GLX_SUN_get_transparent_index

9510

if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))

9511

{

9512

ret = GLXEW_SUN_get_transparent_index;

9513

continue;

9514

}

9515

#endif

9516

#ifdef GLX_SUN_video_resize

9517

if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))

9518

{

9519

ret = GLXEW_SUN_video_resize;

9520

continue;

9521

}

9522

#endif

9523

}

9524

}

9525

ret = (len == 0);

9526

}

9527

return ret;

9528

}

9529

9530

#endif /* _WIN32 */