Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/RenderSystems/GL/src/glew.cpp @ 5

Last change on this file since 5 was 5, checked in by anonymous, 17 years ago

=hoffentlich gehts jetzt
File size: 135.7 KB
Line 
1/*
2** The OpenGL Extension Wrangler Library
3** Copyright (C) 2002-2005, Milan Ikits <milan ikits[]ieee org>
4** Copyright (C) 2002-2005, Marcelo E. Magallon <mmagallo[]debian org>
5** Copyright (C) 2002, Lev Povalahev
6** All rights reserved.
7**
8** Redistribution and use in source and binary forms, with or without
9** modification, are permitted provided that the following conditions are met:
10**
11** * Redistributions of source code must retain the above copyright notice,
12**   this list of conditions and the following disclaimer.
13** * Redistributions in binary form must reproduce the above copyright notice,
14**   this list of conditions and the following disclaimer in the documentation
15**   and/or other materials provided with the distribution.
16** * The name of the author may be used to endorse or promote products
17**   derived from this software without specific prior written permission.
18**
19** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
29** THE POSSIBILITY OF SUCH DAMAGE.
30*/
31
32#include <GL/glew.h>
33
34#if defined(_WIN32)
35#include <GL/wglew.h>
36#endif
37
38#include "OgreGLSupport.h"
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 Ogre::GLSupport *glSupport
60#  define GLEW_CONTEXT_ARG_VAR_INIT glSupport
61#  define GLEW_CONTEXT_ARG_DEF_LIST Ogre::GLSupport *glSupport
62#  define WGLEW_CONTEXT_ARG_DEF_INIT Ogre::GLSupport *glSupport
63#  define WGLEW_CONTEXT_ARG_DEF_LIST Ogre::GLSupport *glSupport
64#  define GLXEW_CONTEXT_ARG_DEF_INIT void
65#  define GLXEW_CONTEXT_ARG_DEF_LIST void
66#endif /* GLEW_MX */
67
68/*
69 * GLEW, just like OpenGL or GLU, does not rely on the standard C library.
70 * These functions implement the functionality required in this file.
71 */
72
73static GLuint _glewStrLen (const GLubyte* s)
74{
75  GLuint i=0;
76  while (s+i != NULL && s[i] != '\0') i++;
77  return i;
78}
79
80static GLuint _glewStrCLen (const GLubyte* s, GLubyte c)
81{
82  GLuint i=0;
83  while (s+i != NULL && s[i] != '\0' && s[i] != c) i++;
84  return i;
85}
86
87static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n)
88{
89  GLuint i=0;
90  while (i < n && a+i != NULL && b+i != NULL && a[i] == b[i]) i++;
91  return i == n ? GL_TRUE : GL_FALSE;
92}
93
94static GLboolean _glewStrSame1 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
95{
96  while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t'))
97  {
98    (*a)++;
99    (*na)--;
100  }
101  if(*na >= nb)
102  {
103    GLuint i=0;
104    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
105        if(i == nb)
106        {
107                *a = *a + nb;
108                *na = *na - nb;
109                return GL_TRUE;
110        }
111  }
112  return GL_FALSE;
113}
114
115static GLboolean _glewStrSame2 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
116{
117  if(*na >= nb)
118  {
119    GLuint i=0;
120    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
121        if(i == nb)
122        {
123                *a = *a + nb;
124                *na = *na - nb;
125                return GL_TRUE;
126        }
127  }
128  return GL_FALSE;
129}
130
131static GLboolean _glewStrSame3 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
132{
133  if(*na >= nb)
134  {
135    GLuint i=0;
136    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
137    if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t'))
138    {
139      *a = *a + nb;
140      *na = *na - nb;
141      return GL_TRUE;
142    }
143  }
144  return GL_FALSE;
145}
146
147// Define procedure address
148#define glewGetProcAddress(name) glSupport->getProcAddress((const char*)(name))
149// Not experimental
150#define glewExperimental 0
151
152// Shut up MSVC compiler "inconsistent dll linkage" warning
153#if OGRE_COMPILER == OGRE_COMPILER_MSVC
154#  pragma warning (disable : 4273)
155#endif
156
157#if !defined(_WIN32) || !defined(GLEW_MX)
158
159PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;
160PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;
161PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;
162PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;
163
164PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;
165PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;
166PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;
167PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;
168PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;
169PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;
170PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;
171PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;
172PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;
173PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;
174PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;
175PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;
176PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;
177PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;
178PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;
179PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;
180PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;
181PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;
182PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;
183PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;
184PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;
185PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;
186PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;
187PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;
188PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;
189PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;
190PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;
191PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;
192PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;
193PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;
194PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;
195PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;
196PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;
197PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;
198PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;
199PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;
200PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;
201PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;
202PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;
203PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;
204PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;
205PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;
206PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;
207PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;
208PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;
209PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;
210
211PFNGLBLENDCOLORPROC __glewBlendColor = NULL;
212PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;
213PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;
214PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;
215PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;
216PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;
217PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;
218PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;
219PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;
220PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;
221PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;
222PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;
223PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;
224PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;
225PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;
226PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;
227PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;
228PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;
229PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;
230PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;
231PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;
232PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;
233PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;
234PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;
235PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;
236PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;
237PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;
238PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;
239PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;
240PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;
241PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;
242PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;
243PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;
244PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;
245PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;
246PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;
247PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;
248PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;
249PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;
250PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;
251PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;
252PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;
253PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;
254PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;
255PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;
256
257PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;
258PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;
259PFNGLBUFFERDATAPROC __glewBufferData = NULL;
260PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;
261PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;
262PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;
263PFNGLENDQUERYPROC __glewEndQuery = NULL;
264PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;
265PFNGLGENQUERIESPROC __glewGenQueries = NULL;
266PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;
267PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;
268PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;
269PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;
270PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;
271PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;
272PFNGLISBUFFERPROC __glewIsBuffer = NULL;
273PFNGLISQUERYPROC __glewIsQuery = NULL;
274PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;
275PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;
276
277PFNGLATTACHSHADERPROC __glewAttachShader = NULL;
278PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;
279PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;
280PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;
281PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;
282PFNGLCREATESHADERPROC __glewCreateShader = NULL;
283PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;
284PFNGLDELETESHADERPROC __glewDeleteShader = NULL;
285PFNGLDETACHSHADERPROC __glewDetachShader = NULL;
286PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;
287PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;
288PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;
289PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;
290PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;
291PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;
292PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;
293PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;
294PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;
295PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;
296PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;
297PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;
298PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;
299PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;
300PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;
301PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;
302PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;
303PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;
304PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;
305PFNGLISPROGRAMPROC __glewIsProgram = NULL;
306PFNGLISSHADERPROC __glewIsShader = NULL;
307PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;
308PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;
309PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;
310PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;
311PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;
312PFNGLUNIFORM1FPROC __glewUniform1f = NULL;
313PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;
314PFNGLUNIFORM1IPROC __glewUniform1i = NULL;
315PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;
316PFNGLUNIFORM2FPROC __glewUniform2f = NULL;
317PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;
318PFNGLUNIFORM2IPROC __glewUniform2i = NULL;
319PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;
320PFNGLUNIFORM3FPROC __glewUniform3f = NULL;
321PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;
322PFNGLUNIFORM3IPROC __glewUniform3i = NULL;
323PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;
324PFNGLUNIFORM4FPROC __glewUniform4f = NULL;
325PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;
326PFNGLUNIFORM4IPROC __glewUniform4i = NULL;
327PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;
328PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;
329PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;
330PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;
331PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;
332PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;
333PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;
334PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;
335PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;
336PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;
337PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;
338PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;
339PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;
340PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;
341PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;
342PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;
343PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;
344PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;
345PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;
346PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;
347PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;
348PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;
349PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;
350PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;
351PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;
352PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;
353PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;
354PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;
355PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;
356PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;
357PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;
358PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;
359PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;
360PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;
361PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;
362PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;
363PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;
364PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;
365PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;
366PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;
367PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;
368PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;
369PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;
370
371PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;
372PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;
373PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;
374PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;
375PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;
376PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;
377
378PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;
379
380PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;
381
382PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;
383PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;
384PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;
385PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;
386PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;
387PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;
388PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;
389PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;
390PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;
391PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;
392PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;
393PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;
394PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;
395PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;
396PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;
397PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;
398PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;
399PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;
400PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;
401PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;
402PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;
403PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;
404PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;
405PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;
406PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;
407PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;
408PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;
409PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;
410PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;
411PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;
412PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;
413PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;
414PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;
415PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;
416
417PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;
418PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;
419PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;
420PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;
421PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;
422PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;
423PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;
424PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;
425
426PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;
427PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;
428PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;
429PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;
430PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;
431PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;
432PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;
433PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;
434PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;
435PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;
436PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;
437PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;
438PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;
439PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;
440PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;
441PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;
442PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;
443PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;
444PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;
445PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;
446PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;
447PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;
448PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;
449PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;
450PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;
451PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;
452PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;
453PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;
454PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;
455PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;
456PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;
457PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;
458PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;
459PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;
460PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;
461PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;
462PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;
463PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;
464PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;
465
466PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;
467PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;
468PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;
469PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;
470PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;
471PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;
472PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;
473
474PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;
475PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;
476PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;
477PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;
478PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;
479PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;
480PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;
481PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;
482PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;
483PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;
484PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;
485
486PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;
487PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;
488PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;
489PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;
490PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;
491PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;
492PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;
493PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;
494PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;
495PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;
496PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;
497PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;
498PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;
499PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;
500PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;
501PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;
502PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;
503PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;
504PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;
505PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;
506PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;
507PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;
508PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;
509PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;
510PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;
511PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;
512PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;
513PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;
514PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;
515PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;
516PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;
517PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;
518PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;
519PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;
520PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;
521PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;
522PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;
523PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;
524PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;
525PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;
526PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;
527PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;
528PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;
529PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;
530PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;
531PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;
532PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;
533PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;
534PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;
535PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;
536PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;
537PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;
538PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;
539PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;
540PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;
541PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;
542PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;
543PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;
544PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;
545PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;
546PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;
547PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;
548
549PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;
550PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;
551PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;
552
553PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;
554
555PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;
556PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;
557PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;
558PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;
559PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;
560PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;
561PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;
562PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;
563PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;
564PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;
565PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;
566PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;
567PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;
568PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;
569
570PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;
571PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;
572PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;
573PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;
574PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;
575PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;
576PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;
577PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;
578PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;
579PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;
580PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;
581PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;
582PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;
583PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;
584PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;
585PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;
586PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;
587
588PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;
589PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;
590PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;
591PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;
592PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;
593PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;
594PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;
595PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;
596PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;
597PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;
598PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;
599PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;
600PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;
601PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;
602PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;
603PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;
604PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;
605
606PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
607
608PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;
609PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;
610PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;
611PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;
612PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;
613PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;
614
615PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;
616PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;
617PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;
618PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;
619PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;
620PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;
621PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;
622
623PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;
624PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;
625PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;
626PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;
627PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;
628PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;
629PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;
630PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;
631PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;
632PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;
633PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;
634PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;
635PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;
636
637PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;
638PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;
639
640PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;
641PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;
642PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;
643PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;
644PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;
645PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;
646PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;
647PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;
648PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;
649PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;
650PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;
651PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;
652PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;
653PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;
654PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;
655PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;
656PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;
657PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;
658PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;
659PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;
660PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;
661PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;
662PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;
663PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;
664PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;
665PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;
666PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;
667PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;
668PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;
669PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;
670PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;
671PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;
672PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;
673PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;
674PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;
675PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;
676PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;
677PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;
678PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;
679PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;
680PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;
681PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;
682PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;
683PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;
684PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;
685PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;
686PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;
687PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;
688PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;
689PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;
690PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;
691PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;
692PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;
693PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;
694PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;
695PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;
696PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;
697PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;
698PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;
699PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;
700PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;
701PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;
702PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;
703PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;
704// SJS
705PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;
706PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;
707PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;
708PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;
709// SJS
710
711#endif /* !WIN32 || !GLEW_MX */
712
713#if !defined(GLEW_MX)
714
715GLboolean __GLEW_VERSION_1_1 = GL_FALSE;
716GLboolean __GLEW_VERSION_1_2 = GL_FALSE;
717GLboolean __GLEW_VERSION_1_3 = GL_FALSE;
718GLboolean __GLEW_VERSION_1_4 = GL_FALSE;
719GLboolean __GLEW_VERSION_1_5 = GL_FALSE;
720GLboolean __GLEW_VERSION_2_0 = GL_FALSE;
721GLboolean __GLEW_VERSION_2_1 = GL_FALSE;
722GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;
723GLboolean __GLEW_ARB_fragment_program = GL_FALSE;
724GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;
725GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;
726GLboolean __GLEW_ARB_multisample = GL_FALSE;
727GLboolean __GLEW_ARB_multitexture = GL_FALSE;
728GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;
729GLboolean __GLEW_ARB_shader_objects = GL_FALSE;
730GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;
731GLboolean __GLEW_ARB_texture_compression = GL_FALSE;
732GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;
733GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;
734GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;
735GLboolean __GLEW_ARB_texture_float = GL_FALSE;
736GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;
737GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;
738GLboolean __GLEW_ARB_vertex_program = GL_FALSE;
739GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;
740GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;
741GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;
742GLboolean __GLEW_ATI_texture_float = GL_FALSE;
743GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;
744GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;
745GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;
746GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
747GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;
748GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;
749GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;
750GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;
751GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;
752GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;
753GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;
754GLboolean __GLEW_NV_fragment_program = GL_FALSE;
755GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;
756GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;
757GLboolean __GLEW_NV_occlusion_query = GL_FALSE;
758GLboolean __GLEW_NV_register_combiners = GL_FALSE;
759GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;
760GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;
761GLboolean __GLEW_NV_texture_shader = GL_FALSE;
762GLboolean __GLEW_NV_vertex_program = GL_FALSE;
763GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;
764GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;
765GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;
766// SJS changes for OGRE
767GLboolean __GLEW_EXT_point_sprite = GL_FALSE;
768GLboolean __GLEW_EXT_point_parameters = GL_FALSE;
769GLboolean __GLEW_ARB_point_parameters = GL_FALSE;
770GLboolean __GLEW_ARB_point_sprite = GL_FALSE;
771GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;
772// End changes
773
774#endif /* !GLEW_MX */
775
776#ifdef GL_VERSION_1_2
777
778static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)
779{
780  GLboolean r = GL_FALSE;
781
782  r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r;
783  r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r;
784  r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r;
785  r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r;
786 
787  return r;
788}
789
790#endif /* GL_VERSION_1_2 */
791
792#ifdef GL_VERSION_1_3
793
794static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)
795{
796  GLboolean r = GL_FALSE;
797
798  r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r;
799  r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r;
800  r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r;
801  r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r;
802  r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r;
803  r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r;
804  r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r;
805  r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r;
806  r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r;
807  r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r;
808  r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r;
809  r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r;
810  r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r;
811  r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r;
812  r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r;
813  r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r;
814  r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r;
815  r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r;
816  r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r;
817  r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r;
818  r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r;
819  r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r;
820  r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r;
821  r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r;
822  r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r;
823  r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r;
824  r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r;
825  r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r;
826  r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r;
827  r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r;
828  r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r;
829  r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r;
830  r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r;
831  r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r;
832  r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r;
833  r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r;
834  r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r;
835  r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r;
836  r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r;
837  r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r;
838  r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r;
839  r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r;
840  r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r;
841  r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r;
842  r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r;
843  r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r;
844
845  return r;
846}
847
848#endif /* GL_VERSION_1_3 */
849
850#ifdef GL_VERSION_1_4
851
852static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)
853{
854  GLboolean r = GL_FALSE;
855
856  r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r;
857  r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
858  r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r;
859  r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r;
860  r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r;
861  r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r;
862  r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r;
863  r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r;
864  r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r;
865  r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r;
866  r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r;
867  r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r;
868  r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r;
869  r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r;
870  r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r;
871  r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r;
872  r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r;
873  r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r;
874  r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r;
875  r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r;
876  r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r;
877  r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r;
878  r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r;
879  r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r;
880  r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r;
881  r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r;
882  r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r;
883  r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r;
884  r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r;
885  r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r;
886  r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r;
887  r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r;
888  r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r;
889  r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r;
890  r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r;
891  r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r;
892  r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r;
893  r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r;
894  r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r;
895  r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r;
896  r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r;
897  r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r;
898  r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r;
899  r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r;
900  r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r;
901
902  return r;
903}
904
905#endif /* GL_VERSION_1_4 */
906
907#ifdef GL_VERSION_1_5
908
909static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)
910{
911  GLboolean r = GL_FALSE;
912
913  r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r;
914  r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r;
915  r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r;
916  r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r;
917  r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r;
918  r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r;
919  r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r;
920  r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r;
921  r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r;
922  r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r;
923  r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r;
924  r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r;
925  r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r;
926  r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r;
927  r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r;
928  r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r;
929  r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r;
930  r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r;
931  r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r;
932
933  return r;
934}
935
936#endif /* GL_VERSION_1_5 */
937
938#ifdef GL_VERSION_2_0
939
940static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)
941{
942  GLboolean r = GL_FALSE;
943
944  r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r;
945  r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r;
946  r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r;
947  r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r;
948  r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r;
949  r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r;
950  r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r;
951  r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r;
952  r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r;
953  r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r;
954  r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r;
955  r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r;
956  r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r;
957  r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r;
958  r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r;
959  r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r;
960  r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r;
961  r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r;
962  r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r;
963  r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r;
964  r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r;
965  r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r;
966  r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r;
967  r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r;
968  r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r;
969  r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r;
970  r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r;
971  r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r;
972  r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r;
973  r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r;
974  r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r;
975  r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r;
976  r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r;
977  r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r;
978  r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r;
979  r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r;
980  r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r;
981  r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r;
982  r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r;
983  r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r;
984  r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r;
985  r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r;
986  r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r;
987  r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r;
988  r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r;
989  r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r;
990  r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r;
991  r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r;
992  r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r;
993  r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r;
994  r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r;
995  r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r;
996  r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r;
997  r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r;
998  r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r;
999  r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r;
1000  r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r;
1001  r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r;
1002  r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r;
1003  r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r;
1004  r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r;
1005  r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r;
1006  r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r;
1007  r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r;
1008  r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r;
1009  r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r;
1010  r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r;
1011  r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r;
1012  r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r;
1013  r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r;
1014  r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r;
1015  r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r;
1016  r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r;
1017  r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r;
1018  r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r;
1019  r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r;
1020  r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r;
1021  r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r;
1022  r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r;
1023  r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r;
1024  r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r;
1025  r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r;
1026  r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r;
1027  r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r;
1028  r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r;
1029  r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r;
1030  r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r;
1031  r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r;
1032  r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r;
1033  r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r;
1034  r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r;
1035  r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r;
1036  r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r;
1037
1038  return r;
1039}
1040
1041#endif /* GL_VERSION_2_0 */
1042
1043#ifdef GL_VERSION_2_1
1044
1045static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT)
1046{
1047  GLboolean r = GL_FALSE;
1048
1049  r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r;
1050  r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r;
1051  r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r;
1052  r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r;
1053  r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r;
1054  r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r;
1055
1056  return r;
1057}
1058
1059#endif /* GL_VERSION_2_1 */
1060
1061#ifdef GL_ARB_draw_buffers
1062
1063static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
1064{
1065  GLboolean r = GL_FALSE;
1066
1067  r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r;
1068
1069  return r;
1070}
1071
1072#endif /* GL_ARB_draw_buffers */
1073
1074#ifdef GL_ARB_fragment_program
1075
1076#endif /* GL_ARB_fragment_program */
1077
1078#ifdef GL_ARB_fragment_shader
1079
1080#endif /* GL_ARB_fragment_shader */
1081
1082#ifdef GL_ARB_half_float_pixel
1083
1084#endif /* GL_ARB_half_float_pixel */
1085
1086#ifdef GL_ARB_multisample
1087
1088static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
1089{
1090  GLboolean r = GL_FALSE;
1091
1092  r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r;
1093
1094  return r;
1095}
1096
1097#endif /* GL_ARB_multisample */
1098
1099#ifdef GL_ARB_multitexture
1100
1101static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)
1102{
1103  GLboolean r = GL_FALSE;
1104
1105  r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r;
1106  r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r;
1107  r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r;
1108  r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r;
1109  r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r;
1110  r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r;
1111  r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r;
1112  r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r;
1113  r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r;
1114  r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r;
1115  r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r;
1116  r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r;
1117  r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r;
1118  r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r;
1119  r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r;
1120  r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r;
1121  r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r;
1122  r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r;
1123  r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r;
1124  r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r;
1125  r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r;
1126  r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r;
1127  r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r;
1128  r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;
1129  r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;
1130  r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;
1131  r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;
1132  r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;
1133  r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;
1134  r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;
1135  r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;
1136  r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;
1137  r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;
1138  r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;
1139
1140  return r;
1141}
1142
1143#endif /* GL_ARB_multitexture */
1144
1145#ifdef GL_ARB_occlusion_query
1146
1147static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
1148{
1149  GLboolean r = GL_FALSE;
1150
1151  r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;
1152  r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;
1153  r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;
1154  r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;
1155  r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;
1156  r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;
1157  r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;
1158  r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;
1159
1160  return r;
1161}
1162
1163#endif /* GL_ARB_occlusion_query */
1164
1165#ifdef GL_ARB_shader_objects
1166
1167static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
1168{
1169  GLboolean r = GL_FALSE;
1170
1171  r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;
1172  r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;
1173  r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;
1174  r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;
1175  r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;
1176  r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;
1177  r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;
1178  r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;
1179  r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;
1180  r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;
1181  r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;
1182  r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;
1183  r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;
1184  r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;
1185  r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;
1186  r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;
1187  r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;
1188  r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;
1189  r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;
1190  r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;
1191  r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;
1192  r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;
1193  r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;
1194  r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;
1195  r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;
1196  r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;
1197  r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;
1198  r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;
1199  r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;
1200  r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;
1201  r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;
1202  r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;
1203  r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;
1204  r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;
1205  r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;
1206  r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;
1207  r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;
1208  r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;
1209  r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;
1210
1211  return r;
1212}
1213
1214#endif /* GL_ARB_shader_objects */
1215
1216#ifdef GL_ARB_shading_language_100
1217
1218#endif /* GL_ARB_shading_language_100 */
1219
1220#ifdef GL_ARB_texture_compression
1221
1222static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)
1223{
1224  GLboolean r = GL_FALSE;
1225
1226  r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;
1227  r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;
1228  r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;
1229  r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;
1230  r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;
1231  r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;
1232  r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;
1233
1234  return r;
1235}
1236
1237#endif /* GL_ARB_texture_compression */
1238
1239#ifdef GL_ARB_texture_cube_map
1240
1241#endif /* GL_ARB_texture_cube_map */
1242
1243#ifdef GL_ARB_texture_env_combine
1244
1245#endif /* GL_ARB_texture_env_combine */
1246
1247#ifdef GL_ARB_texture_env_dot3
1248
1249#endif /* GL_ARB_texture_env_dot3 */
1250
1251#ifdef GL_ARB_texture_float
1252
1253#endif /* GL_ARB_texture_float */
1254
1255#ifdef GL_ARB_texture_non_power_of_two
1256
1257#endif /* GL_ARB_texture_non_power_of_two */
1258
1259#ifdef GL_ARB_vertex_buffer_object
1260
1261static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
1262{
1263  GLboolean r = GL_FALSE;
1264
1265  r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;
1266  r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;
1267  r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;
1268  r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;
1269  r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;
1270  r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;
1271  r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;
1272  r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;
1273  r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;
1274  r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;
1275  r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;
1276
1277  return r;
1278}
1279
1280#endif /* GL_ARB_vertex_buffer_object */
1281
1282#ifdef GL_ARB_vertex_program
1283
1284static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
1285{
1286  GLboolean r = GL_FALSE;
1287
1288  r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;
1289  r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;
1290  r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;
1291  r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;
1292  r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;
1293  r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;
1294  r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;
1295  r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;
1296  r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;
1297  r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;
1298  r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;
1299  r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;
1300  r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;
1301  r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;
1302  r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;
1303  r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;
1304  r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;
1305  r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;
1306  r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;
1307  r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;
1308  r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;
1309  r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;
1310  r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;
1311  r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;
1312  r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;
1313  r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;
1314  r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;
1315  r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;
1316  r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;
1317  r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;
1318  r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;
1319  r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;
1320  r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;
1321  r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;
1322  r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;
1323  r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;
1324  r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;
1325  r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;
1326  r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;
1327  r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;
1328  r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;
1329  r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;
1330  r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;
1331  r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;
1332  r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;
1333  r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;
1334  r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;
1335  r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;
1336  r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;
1337  r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;
1338  r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;
1339  r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;
1340  r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;
1341  r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;
1342  r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;
1343  r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;
1344  r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;
1345  r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;
1346  r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;
1347  r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;
1348  r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;
1349  r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;
1350
1351  return r;
1352}
1353
1354#endif /* GL_ARB_vertex_program */
1355
1356#ifdef GL_ARB_vertex_shader
1357
1358static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
1359{
1360  GLboolean r = GL_FALSE;
1361
1362  r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;
1363  r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;
1364  r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;
1365
1366  return r;
1367}
1368
1369#endif /* GL_ARB_vertex_shader */
1370
1371#ifdef GL_ATI_draw_buffers
1372
1373static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
1374{
1375  GLboolean r = GL_FALSE;
1376
1377  r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;
1378
1379  return r;
1380}
1381
1382#endif /* GL_ATI_draw_buffers */
1383
1384#ifdef GL_ATI_fragment_shader
1385
1386static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)
1387{
1388  GLboolean r = GL_FALSE;
1389
1390  r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;
1391  r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;
1392  r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;
1393  r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;
1394  r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;
1395  r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;
1396  r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;
1397  r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;
1398  r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;
1399  r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;
1400  r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;
1401  r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;
1402  r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;
1403  r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;
1404
1405  return r;
1406}
1407
1408#endif /* GL_ATI_fragment_shader */
1409
1410#ifdef GL_ATI_texture_float
1411
1412#endif /* GL_ATI_texture_float */
1413
1414#ifdef GL_EXT_framebuffer_object
1415
1416static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
1417{
1418  GLboolean r = GL_FALSE;
1419
1420  r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;
1421  r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;
1422  r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;
1423  r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;
1424  r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;
1425  r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;
1426  r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;
1427  r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;
1428  r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;
1429  r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;
1430  r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;
1431  r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;
1432  r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;
1433  r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;
1434  r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;
1435  r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;
1436  r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;
1437
1438  return r;
1439}
1440
1441#endif /* GL_EXT_framebuffer_object */
1442
1443#ifdef GL_EXT_secondary_color
1444
1445static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)
1446{
1447  GLboolean r = GL_FALSE;
1448
1449  r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;
1450  r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;
1451  r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;
1452  r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;
1453  r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;
1454  r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;
1455  r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;
1456  r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;
1457  r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;
1458  r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;
1459  r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;
1460  r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;
1461  r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;
1462  r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;
1463  r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;
1464  r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;
1465  r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;
1466
1467  return r;
1468}
1469
1470#endif /* GL_EXT_secondary_color */
1471
1472#ifdef GL_EXT_stencil_two_side
1473
1474static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)
1475{
1476  GLboolean r = GL_FALSE;
1477
1478  r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;
1479
1480  return r;
1481}
1482
1483#endif /* GL_EXT_stencil_two_side */
1484
1485#ifdef GL_EXT_stencil_wrap
1486
1487#endif /* GL_EXT_stencil_wrap */
1488
1489#ifdef GL_EXT_texture_compression_s3tc
1490
1491#endif /* GL_EXT_texture_compression_s3tc */
1492
1493#ifdef GL_EXT_texture_cube_map
1494
1495#endif /* GL_EXT_texture_cube_map */
1496
1497#ifdef GL_EXT_texture_env_combine
1498
1499#endif /* GL_EXT_texture_env_combine */
1500
1501#ifdef GL_EXT_texture_env_dot3
1502
1503#endif /* GL_EXT_texture_env_dot3 */
1504
1505#ifdef GL_EXT_texture_filter_anisotropic
1506
1507#endif /* GL_EXT_texture_filter_anisotropic */
1508
1509#ifdef GL_NV_fragment_program
1510
1511static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)
1512{
1513  GLboolean r = GL_FALSE;
1514
1515  r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;
1516  r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;
1517  r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;
1518  r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;
1519  r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;
1520  r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;
1521
1522  return r;
1523}
1524
1525#endif /* GL_NV_fragment_program */
1526
1527#ifdef GL_NV_fragment_program2
1528
1529#endif /* GL_NV_fragment_program2 */
1530
1531#ifdef GL_NV_fragment_program_option
1532
1533#endif /* GL_NV_fragment_program_option */
1534
1535#ifdef GL_NV_occlusion_query
1536
1537static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
1538{
1539  GLboolean r = GL_FALSE;
1540
1541  r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;
1542  r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;
1543  r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;
1544  r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;
1545  r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;
1546  r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;
1547  r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;
1548
1549  return r;
1550}
1551
1552#endif /* GL_NV_occlusion_query */
1553
1554#ifdef GL_NV_register_combiners
1555
1556static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)
1557{
1558  GLboolean r = GL_FALSE;
1559
1560  r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;
1561  r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;
1562  r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;
1563  r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;
1564  r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;
1565  r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;
1566  r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;
1567  r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;
1568  r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;
1569  r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;
1570  r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;
1571  r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;
1572  r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;
1573
1574  return r;
1575}
1576
1577#endif /* GL_NV_register_combiners */
1578
1579#ifdef GL_NV_register_combiners2
1580
1581static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)
1582{
1583  GLboolean r = GL_FALSE;
1584
1585  r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;
1586  r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;
1587
1588  return r;
1589}
1590
1591#endif /* GL_NV_register_combiners2 */
1592
1593#ifdef GL_NV_texture_compression_vtc
1594
1595#endif /* GL_NV_texture_compression_vtc */
1596
1597#ifdef GL_NV_texture_shader
1598
1599#endif /* GL_NV_texture_shader */
1600
1601#ifdef GL_NV_vertex_program
1602
1603static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
1604{
1605  GLboolean r = GL_FALSE;
1606
1607  r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;
1608  r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;
1609  r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;
1610  r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;
1611  r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;
1612  r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;
1613  r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;
1614  r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;
1615  r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;
1616  r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;
1617  r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;
1618  r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;
1619  r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;
1620  r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;
1621  r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;
1622  r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;
1623  r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;
1624  r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;
1625  r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;
1626  r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;
1627  r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;
1628  r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;
1629  r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;
1630  r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;
1631  r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;
1632  r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;
1633  r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;
1634  r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;
1635  r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;
1636  r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;
1637  r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;
1638  r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;
1639  r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;
1640  r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;
1641  r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;
1642  r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;
1643  r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;
1644  r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;
1645  r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;
1646  r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;
1647  r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;
1648  r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;
1649  r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;
1650  r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;
1651  r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;
1652  r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;
1653  r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;
1654  r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;
1655  r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;
1656  r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;
1657  r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;
1658  r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;
1659  r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;
1660  r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;
1661  r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;
1662  r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;
1663  r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;
1664  r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;
1665  r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;
1666  r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;
1667  r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;
1668  r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;
1669  r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;
1670  r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;
1671
1672  return r;
1673}
1674
1675#endif /* GL_NV_vertex_program */
1676
1677#ifdef GL_NV_vertex_program2_option
1678
1679#endif /* GL_NV_vertex_program2_option */
1680
1681#ifdef GL_NV_vertex_program3
1682
1683#endif /* GL_NV_vertex_program3 */
1684
1685#ifdef GL_SGIS_generate_mipmap
1686
1687#endif /* GL_SGIS_generate_mipmap */
1688
1689// Begin SJS change for OGRE
1690#ifdef GL_ARB_point_parameters
1691static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
1692{
1693        GLboolean r = GL_FALSE;
1694
1695        r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;
1696        r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;
1697        // For convenience, if GL 1.4 not defined, assign same to non-ARB version since interface identical
1698        if (!GLEW_VERSION_1_4)
1699        {
1700                glPointParameterf = glPointParameterfARB;
1701                glPointParameterfv = glPointParameterfvARB;
1702        }
1703
1704        return r;
1705}
1706#endif /* GL_ARB_point_parameters */
1707
1708#ifdef GL_EXT_point_parameters
1709static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
1710{
1711        GLboolean r = GL_FALSE;
1712
1713        r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;
1714        r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;
1715        // For convenience, if GL 1.4 not defined, assign same to non-EXT version since interface identical
1716        if (!GLEW_VERSION_1_4)
1717        {
1718                glPointParameterf = glPointParameterfEXT;
1719                glPointParameterfv = glPointParameterfvEXT;
1720        }
1721
1722        return r;
1723}
1724#endif /* GL_EXT_point_parameters */
1725
1726// End SJS change for OGRE
1727
1728
1729/* ------------------------------------------------------------------------- */
1730
1731/*
1732 * Search for name in the extensions string. Use of strstr()
1733 * is not sufficient because extension names can be prefixes of
1734 * other extension names. Could use strtok() but the constant
1735 * string returned by glGetString might be in read-only memory.
1736 */
1737GLboolean glewGetExtension (const char* name)
1738{   
1739  GLubyte* p;
1740  GLubyte* end;
1741  GLuint len = _glewStrLen((const GLubyte*)name);
1742  p = (GLubyte*)glGetString(GL_EXTENSIONS);
1743  if (0 == p) return GL_FALSE;
1744  end = p + _glewStrLen(p);
1745  while (p < end)
1746  {
1747    GLuint n = _glewStrCLen(p, ' ');
1748    if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE;
1749    p += n+1;
1750  }
1751  return GL_FALSE;
1752}
1753
1754/* ------------------------------------------------------------------------- */
1755
1756GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
1757{
1758  const GLubyte* s;
1759  GLuint major, minor;
1760  /* check for SiS driver */
1761  s = glGetString(GL_RENDERER);
1762  if (s && _glewStrSame(s,(const GLubyte*)"SiS",3))
1763  {
1764          GLEW_VERSION_1_1 = GL_TRUE;
1765      GLEW_VERSION_1_2 = GL_FALSE;
1766      GLEW_VERSION_1_3 = GL_FALSE;
1767      GLEW_VERSION_1_4 = GL_FALSE;
1768      GLEW_VERSION_1_5 = GL_FALSE;
1769      GLEW_VERSION_2_0 = GL_FALSE;
1770      GLEW_VERSION_2_1 = GL_FALSE;
1771  }
1772  else
1773  {
1774        /* query opengl version */
1775        s = glGetString(GL_VERSION);
1776        if (!s) return GLEW_ERROR_NO_GL_VERSION;
1777        major = _glewStrCLen(s, '.')-1;
1778        minor = _glewStrCLen(s, '.')+1;
1779        if (s+major == NULL
1780          || s+minor-1 == NULL || s+minor == NULL
1781          || (s[major] == 1 && s[minor] < '1'))
1782        {
1783          return GLEW_ERROR_GL_VERSION_10_ONLY;
1784        }
1785        else
1786        {
1787          if (s[major] >= '2')
1788          {
1789                GLEW_VERSION_1_1 = GL_TRUE;
1790                GLEW_VERSION_1_2 = GL_TRUE;
1791                GLEW_VERSION_1_3 = GL_TRUE;
1792                GLEW_VERSION_1_4 = GL_TRUE;
1793                GLEW_VERSION_1_5 = GL_TRUE;
1794                GLEW_VERSION_2_0 = GL_TRUE;
1795        if (s[minor] >= '1')
1796        {
1797          GLEW_VERSION_2_1 = GL_TRUE;
1798        }
1799        else
1800        {
1801          GLEW_VERSION_2_1 = GL_FALSE;
1802        }
1803          }
1804          else
1805          {
1806                if (s[minor] >= '5')
1807                {
1808                  GLEW_VERSION_1_1 = GL_TRUE;
1809                  GLEW_VERSION_1_2 = GL_TRUE;
1810                  GLEW_VERSION_1_3 = GL_TRUE;
1811                  GLEW_VERSION_1_4 = GL_TRUE;
1812                  GLEW_VERSION_1_5 = GL_TRUE;
1813                  GLEW_VERSION_2_0 = GL_FALSE;
1814          GLEW_VERSION_2_1 = GL_FALSE;
1815                }
1816            if (s[minor] == '4')
1817                {
1818                  GLEW_VERSION_1_1 = GL_TRUE;
1819                  GLEW_VERSION_1_2 = GL_TRUE;
1820                  GLEW_VERSION_1_3 = GL_TRUE;
1821                  GLEW_VERSION_1_4 = GL_TRUE;
1822                  GLEW_VERSION_1_5 = GL_FALSE;
1823                  GLEW_VERSION_2_0 = GL_FALSE;
1824          GLEW_VERSION_2_1 = GL_FALSE;
1825                }
1826                if (s[minor] == '3')
1827                {
1828                  GLEW_VERSION_1_1 = GL_TRUE;
1829                  GLEW_VERSION_1_2 = GL_TRUE;
1830                  GLEW_VERSION_1_3 = GL_TRUE;
1831                  GLEW_VERSION_1_4 = GL_FALSE;
1832                  GLEW_VERSION_1_5 = GL_FALSE;
1833                  GLEW_VERSION_2_0 = GL_FALSE;
1834          GLEW_VERSION_2_1 = GL_FALSE;
1835                }
1836                if (s[minor] == '2')
1837                {
1838                  GLEW_VERSION_1_1 = GL_TRUE;
1839                  GLEW_VERSION_1_2 = GL_TRUE;
1840                  GLEW_VERSION_1_3 = GL_FALSE;
1841                  GLEW_VERSION_1_4 = GL_FALSE;
1842                  GLEW_VERSION_1_5 = GL_FALSE;
1843                  GLEW_VERSION_2_0 = GL_FALSE;
1844          GLEW_VERSION_2_1 = GL_FALSE;
1845                }
1846                if (s[minor] < '2')
1847                {
1848                  GLEW_VERSION_1_1 = GL_TRUE;
1849                  GLEW_VERSION_1_2 = GL_FALSE;
1850                  GLEW_VERSION_1_3 = GL_FALSE;
1851                  GLEW_VERSION_1_4 = GL_FALSE;
1852                  GLEW_VERSION_1_5 = GL_FALSE;
1853                  GLEW_VERSION_2_0 = GL_FALSE;
1854          GLEW_VERSION_2_1 = GL_FALSE;
1855                }
1856          }
1857        }
1858  }
1859  /* initialize extensions */
1860#ifdef GL_VERSION_1_2
1861  if (glewExperimental || GLEW_VERSION_1_2) GLEW_VERSION_1_2 = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);
1862#endif /* GL_VERSION_1_2 */
1863#ifdef GL_VERSION_1_3
1864  if (glewExperimental || GLEW_VERSION_1_3) GLEW_VERSION_1_3 = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
1865#endif /* GL_VERSION_1_3 */
1866#ifdef GL_VERSION_1_4
1867  if (glewExperimental || GLEW_VERSION_1_4) GLEW_VERSION_1_4 = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);
1868#endif /* GL_VERSION_1_4 */
1869#ifdef GL_VERSION_1_5
1870  if (glewExperimental || GLEW_VERSION_1_5) GLEW_VERSION_1_5 = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);
1871#endif /* GL_VERSION_1_5 */
1872#ifdef GL_VERSION_2_0
1873  if (glewExperimental || GLEW_VERSION_2_0) GLEW_VERSION_2_0 = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);
1874#endif /* GL_VERSION_2_0 */
1875#ifdef GL_VERSION_2_1
1876  if (glewExperimental || GLEW_VERSION_2_1) GLEW_VERSION_2_1 = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT);
1877#endif /* GL_VERSION_2_1 */
1878#ifdef GL_ARB_draw_buffers
1879  GLEW_ARB_draw_buffers = glewGetExtension("GL_ARB_draw_buffers");
1880  if (glewExperimental || GLEW_ARB_draw_buffers) GLEW_ARB_draw_buffers = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
1881#endif /* GL_ARB_draw_buffers */
1882#ifdef GL_ARB_fragment_program
1883  GLEW_ARB_fragment_program = glewGetExtension("GL_ARB_fragment_program");
1884#endif /* GL_ARB_fragment_program */
1885#ifdef GL_ARB_fragment_shader
1886  GLEW_ARB_fragment_shader = glewGetExtension("GL_ARB_fragment_shader");
1887#endif /* GL_ARB_fragment_shader */
1888#ifdef GL_ARB_half_float_pixel
1889  GLEW_ARB_half_float_pixel = glewGetExtension("GL_ARB_half_float_pixel");
1890#endif /* GL_ARB_half_float_pixel */
1891#ifdef GL_ARB_multisample
1892  GLEW_ARB_multisample = glewGetExtension("GL_ARB_multisample");
1893  if (glewExperimental || GLEW_ARB_multisample) GLEW_ARB_multisample = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
1894#endif /* GL_ARB_multisample */
1895#ifdef GL_ARB_multitexture
1896  GLEW_ARB_multitexture = glewGetExtension("GL_ARB_multitexture");
1897  if (glewExperimental || GLEW_ARB_multitexture) GLEW_ARB_multitexture = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);
1898#endif /* GL_ARB_multitexture */
1899#ifdef GL_ARB_occlusion_query
1900  GLEW_ARB_occlusion_query = glewGetExtension("GL_ARB_occlusion_query");
1901  if (glewExperimental || GLEW_ARB_occlusion_query) GLEW_ARB_occlusion_query = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
1902#endif /* GL_ARB_occlusion_query */
1903#ifdef GL_ARB_shader_objects
1904  GLEW_ARB_shader_objects = glewGetExtension("GL_ARB_shader_objects");
1905  if (glewExperimental || GLEW_ARB_shader_objects) GLEW_ARB_shader_objects = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
1906#endif /* GL_ARB_shader_objects */
1907#ifdef GL_ARB_shading_language_100
1908  GLEW_ARB_shading_language_100 = glewGetExtension("GL_ARB_shading_language_100");
1909#endif /* GL_ARB_shading_language_100 */
1910#ifdef GL_ARB_texture_compression
1911  GLEW_ARB_texture_compression = glewGetExtension("GL_ARB_texture_compression");
1912  if (glewExperimental || GLEW_ARB_texture_compression) GLEW_ARB_texture_compression = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);
1913#endif /* GL_ARB_texture_compression */
1914#ifdef GL_ARB_texture_cube_map
1915  GLEW_ARB_texture_cube_map = glewGetExtension("GL_ARB_texture_cube_map");
1916#endif /* GL_ARB_texture_cube_map */
1917#ifdef GL_ARB_texture_env_combine
1918  GLEW_ARB_texture_env_combine = glewGetExtension("GL_ARB_texture_env_combine");
1919#endif /* GL_ARB_texture_env_combine */
1920#ifdef GL_ARB_texture_env_dot3
1921  GLEW_ARB_texture_env_dot3 = glewGetExtension("GL_ARB_texture_env_dot3");
1922#endif /* GL_ARB_texture_env_dot3 */
1923#ifdef GL_ARB_texture_float
1924  GLEW_ARB_texture_float = glewGetExtension("GL_ARB_texture_float");
1925#endif /* GL_ARB_texture_float */
1926#ifdef GL_ARB_texture_non_power_of_two
1927  GLEW_ARB_texture_non_power_of_two = glewGetExtension("GL_ARB_texture_non_power_of_two");
1928#endif /* GL_ARB_texture_non_power_of_two */
1929#ifdef GL_ARB_vertex_buffer_object
1930  GLEW_ARB_vertex_buffer_object = glewGetExtension("GL_ARB_vertex_buffer_object");
1931  if (glewExperimental || GLEW_ARB_vertex_buffer_object) GLEW_ARB_vertex_buffer_object = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
1932#endif /* GL_ARB_vertex_buffer_object */
1933#ifdef GL_ARB_vertex_program
1934  GLEW_ARB_vertex_program = glewGetExtension("GL_ARB_vertex_program");
1935  if (glewExperimental || GLEW_ARB_vertex_program) GLEW_ARB_vertex_program = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
1936#endif /* GL_ARB_vertex_program */
1937#ifdef GL_ARB_vertex_shader
1938  GLEW_ARB_vertex_shader = glewGetExtension("GL_ARB_vertex_shader");
1939  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); }
1940#endif /* GL_ARB_vertex_shader */
1941#ifdef GL_ATI_draw_buffers
1942  GLEW_ATI_draw_buffers = glewGetExtension("GL_ATI_draw_buffers");
1943  if (glewExperimental || GLEW_ATI_draw_buffers) GLEW_ATI_draw_buffers = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
1944#endif /* GL_ATI_draw_buffers */
1945#ifdef GL_ATI_fragment_shader
1946  GLEW_ATI_fragment_shader = glewGetExtension("GL_ATI_fragment_shader");
1947  if (glewExperimental || GLEW_ATI_fragment_shader) GLEW_ATI_fragment_shader = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);
1948#endif /* GL_ATI_fragment_shader */
1949#ifdef GL_ATI_texture_float
1950  GLEW_ATI_texture_float = glewGetExtension("GL_ATI_texture_float");
1951#endif /* GL_ATI_texture_float */
1952#ifdef GL_EXT_framebuffer_object
1953  GLEW_EXT_framebuffer_object = glewGetExtension("GL_EXT_framebuffer_object");
1954  if (glewExperimental || GLEW_EXT_framebuffer_object) GLEW_EXT_framebuffer_object = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
1955#endif /* GL_EXT_framebuffer_object */
1956#ifdef GL_EXT_pixel_buffer_object
1957  GLEW_EXT_pixel_buffer_object = glewGetExtension("GL_EXT_pixel_buffer_object");
1958#endif /* GL_EXT_pixel_buffer_object */
1959#ifdef GL_ARB_pixel_buffer_object
1960  GLEW_ARB_pixel_buffer_object = glewGetExtension("GL_ARB_pixel_buffer_object");
1961#endif /* GL_ARB_pixel_buffer_object */
1962#ifdef GL_EXT_secondary_color
1963  GLEW_EXT_secondary_color = glewGetExtension("GL_EXT_secondary_color");
1964  if (glewExperimental || GLEW_EXT_secondary_color) GLEW_EXT_secondary_color = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);
1965#endif /* GL_EXT_secondary_color */
1966#ifdef GL_EXT_stencil_two_side
1967  GLEW_EXT_stencil_two_side = glewGetExtension("GL_EXT_stencil_two_side");
1968  if (glewExperimental || GLEW_EXT_stencil_two_side) GLEW_EXT_stencil_two_side = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT);
1969#endif /* GL_EXT_stencil_two_side */
1970#ifdef GL_EXT_stencil_wrap
1971  GLEW_EXT_stencil_wrap = glewGetExtension("GL_EXT_stencil_wrap");
1972#endif /* GL_EXT_stencil_wrap */
1973#ifdef GL_EXT_texture_compression_s3tc
1974  GLEW_EXT_texture_compression_s3tc = glewGetExtension("GL_EXT_texture_compression_s3tc");
1975#endif /* GL_EXT_texture_compression_s3tc */
1976#ifdef GL_EXT_texture_cube_map
1977  GLEW_EXT_texture_cube_map = glewGetExtension("GL_EXT_texture_cube_map");
1978#endif /* GL_EXT_texture_cube_map */
1979#ifdef GL_EXT_texture_env_combine
1980  GLEW_EXT_texture_env_combine = glewGetExtension("GL_EXT_texture_env_combine");
1981#endif /* GL_EXT_texture_env_combine */
1982#ifdef GL_EXT_texture_env_dot3
1983  GLEW_EXT_texture_env_dot3 = glewGetExtension("GL_EXT_texture_env_dot3");
1984#endif /* GL_EXT_texture_env_dot3 */
1985#ifdef GL_EXT_texture_filter_anisotropic
1986  GLEW_EXT_texture_filter_anisotropic = glewGetExtension("GL_EXT_texture_filter_anisotropic");
1987#endif /* GL_EXT_texture_filter_anisotropic */
1988#ifdef GL_NV_fragment_program
1989  GLEW_NV_fragment_program = glewGetExtension("GL_NV_fragment_program");
1990  if (glewExperimental || GLEW_NV_fragment_program) GLEW_NV_fragment_program = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);
1991#endif /* GL_NV_fragment_program */
1992#ifdef GL_NV_fragment_program2
1993  GLEW_NV_fragment_program2 = glewGetExtension("GL_NV_fragment_program2");
1994#endif /* GL_NV_fragment_program2 */
1995#ifdef GL_NV_fragment_program_option
1996  GLEW_NV_fragment_program_option = glewGetExtension("GL_NV_fragment_program_option");
1997#endif /* GL_NV_fragment_program_option */
1998#ifdef GL_NV_occlusion_query
1999  GLEW_NV_occlusion_query = glewGetExtension("GL_NV_occlusion_query");
2000  if (glewExperimental || GLEW_NV_occlusion_query) GLEW_NV_occlusion_query = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
2001#endif /* GL_NV_occlusion_query */
2002#ifdef GL_NV_register_combiners
2003  GLEW_NV_register_combiners = glewGetExtension("GL_NV_register_combiners");
2004  if (glewExperimental || GLEW_NV_register_combiners) GLEW_NV_register_combiners = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);
2005#endif /* GL_NV_register_combiners */
2006#ifdef GL_NV_register_combiners2
2007  GLEW_NV_register_combiners2 = glewGetExtension("GL_NV_register_combiners2");
2008  if (glewExperimental || GLEW_NV_register_combiners2) GLEW_NV_register_combiners2 = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);
2009#endif /* GL_NV_register_combiners2 */
2010#ifdef GL_NV_texture_compression_vtc
2011  GLEW_NV_texture_compression_vtc = glewGetExtension("GL_NV_texture_compression_vtc");
2012#endif /* GL_NV_texture_compression_vtc */
2013#ifdef GL_NV_texture_shader
2014  GLEW_NV_texture_shader = glewGetExtension("GL_NV_texture_shader");
2015#endif /* GL_NV_texture_shader */
2016#ifdef GL_NV_vertex_program
2017  GLEW_NV_vertex_program = glewGetExtension("GL_NV_vertex_program");
2018  if (glewExperimental || GLEW_NV_vertex_program) GLEW_NV_vertex_program = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
2019#endif /* GL_NV_vertex_program */
2020#ifdef GL_NV_vertex_program2_option
2021  GLEW_NV_vertex_program2_option = glewGetExtension("GL_NV_vertex_program2_option");
2022#endif /* GL_NV_vertex_program2_option */
2023#ifdef GL_NV_vertex_program3
2024  GLEW_NV_vertex_program3 = glewGetExtension("GL_NV_vertex_program3");
2025#endif /* GL_NV_vertex_program3 */
2026#ifdef GL_SGIS_generate_mipmap
2027  GLEW_SGIS_generate_mipmap = glewGetExtension("GL_SGIS_generate_mipmap");
2028#endif /* GL_SGIS_generate_mipmap */
2029// SJS Changes for OGRE
2030#ifdef GL_ARB_point_sprite
2031  GLEW_ARB_point_sprite = glewGetExtension("GL_ARB_point_sprite");
2032#endif /* GL_ARB_point_sprite */
2033#ifdef GL_EXT_point_parameters
2034  GLEW_EXT_point_parameters = glewGetExtension("GL_EXT_point_parameters");
2035  if (glewExperimental || GLEW_EXT_point_parameters) GLEW_EXT_point_parameters = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
2036#endif /* GL_EXT_point_parameters */
2037#ifdef GL_ARB_point_parameters
2038  GLEW_ARB_point_parameters = glewGetExtension("GL_ARB_point_parameters");
2039  if (glewExperimental || GLEW_ARB_point_parameters) GLEW_ARB_point_parameters = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
2040#endif /* GL_ARB_point_parameters */
2041#ifdef GL_EXT_texture_lod_bias
2042  GLEW_EXT_texture_lod_bias = glewGetExtension("GL_EXT_texture_lod_bias");
2043#endif /* GL_EXT_texture_lod_bias */
2044
2045// End SJS changes
2046
2047  return GLEW_OK;
2048}
2049
2050
2051#if defined(_WIN32)
2052
2053#if !defined(GLEW_MX)
2054
2055PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;
2056
2057PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;
2058PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;
2059PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;
2060PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;
2061PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;
2062
2063PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;
2064PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;
2065PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;
2066
2067PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;
2068PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;
2069PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;
2070
2071PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;
2072
2073PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;
2074PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;
2075GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;
2076GLboolean __WGLEW_ARB_multisample = GL_FALSE;
2077GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;
2078GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;
2079GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;
2080GLboolean __WGLEW_ARB_render_texture = GL_FALSE;
2081GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;
2082GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;
2083GLboolean __WGLEW_EXT_swap_control = GL_FALSE;
2084
2085#endif /* !GLEW_MX */
2086
2087#ifdef WGL_ARB_extensions_string
2088
2089static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
2090{
2091  GLboolean r = GL_FALSE;
2092
2093  r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;
2094
2095  return r;
2096}
2097
2098#endif /* WGL_ARB_extensions_string */
2099
2100#ifdef WGL_ARB_multisample
2101
2102#endif /* WGL_ARB_multisample */
2103
2104#ifdef WGL_ARB_pbuffer
2105
2106static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
2107{
2108  GLboolean r = GL_FALSE;
2109
2110  r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;
2111  r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;
2112  r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;
2113  r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;
2114  r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;
2115
2116  return r;
2117}
2118
2119#endif /* WGL_ARB_pbuffer */
2120
2121#ifdef WGL_ARB_pixel_format
2122
2123static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
2124{
2125  GLboolean r = GL_FALSE;
2126
2127  r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;
2128  r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;
2129  r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;
2130
2131  return r;
2132}
2133
2134#endif /* WGL_ARB_pixel_format */
2135
2136#ifdef WGL_ARB_pixel_format_float
2137
2138#endif /* WGL_ARB_pixel_format_float */
2139
2140#ifdef WGL_ARB_render_texture
2141
2142static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)
2143{
2144  GLboolean r = GL_FALSE;
2145
2146  r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;
2147  r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;
2148  r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;
2149
2150  return r;
2151}
2152
2153#endif /* WGL_ARB_render_texture */
2154
2155#ifdef WGL_ATI_pixel_format_float
2156
2157#endif /* WGL_ATI_pixel_format_float */
2158
2159#ifdef WGL_EXT_extensions_string
2160
2161static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
2162{
2163  GLboolean r = GL_FALSE;
2164
2165  r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;
2166
2167  return r;
2168}
2169
2170#endif /* WGL_EXT_extensions_string */
2171
2172#ifdef WGL_EXT_swap_control
2173
2174static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)
2175{
2176  GLboolean r = GL_FALSE;
2177
2178  r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;
2179  r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;
2180
2181  return r;
2182}
2183
2184#endif /* WGL_EXT_swap_control */
2185
2186/* ------------------------------------------------------------------------- */
2187
2188static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;
2189static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;
2190
2191GLboolean wglewGetExtension (const char* name)
2192{   
2193  GLubyte* p;
2194  GLubyte* end;
2195  GLuint len = _glewStrLen((const GLubyte*)name);
2196  if (_wglewGetExtensionsStringARB == NULL)
2197    if (_wglewGetExtensionsStringEXT == NULL)
2198      return GL_FALSE;
2199    else
2200      p = (GLubyte*)_wglewGetExtensionsStringEXT();
2201  else
2202    p = (GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
2203  if (0 == p) return GL_FALSE;
2204  end = p + _glewStrLen(p);
2205  while (p < end)
2206  {
2207    GLuint n = _glewStrCLen(p, ' ');
2208    if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE;
2209    p += n+1;
2210  }
2211  return GL_FALSE;
2212}
2213
2214GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
2215{
2216  GLboolean crippled;
2217  /* find wgl extension string query functions */
2218  if (_wglewGetExtensionsStringARB == NULL)
2219    _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");
2220  if (_wglewGetExtensionsStringEXT == NULL)
2221    _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");
2222  /* initialize extensions */
2223  crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;
2224#ifdef WGL_ARB_extensions_string
2225  WGLEW_ARB_extensions_string = wglewGetExtension("WGL_ARB_extensions_string");
2226  if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) WGLEW_ARB_extensions_string= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
2227#endif /* WGL_ARB_extensions_string */
2228#ifdef WGL_ARB_multisample
2229  WGLEW_ARB_multisample = wglewGetExtension("WGL_ARB_multisample");
2230#endif /* WGL_ARB_multisample */
2231#ifdef WGL_ARB_pbuffer
2232  WGLEW_ARB_pbuffer = wglewGetExtension("WGL_ARB_pbuffer");
2233  if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) WGLEW_ARB_pbuffer= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
2234#endif /* WGL_ARB_pbuffer */
2235#ifdef WGL_ARB_pixel_format
2236  WGLEW_ARB_pixel_format = wglewGetExtension("WGL_ARB_pixel_format");
2237  if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) WGLEW_ARB_pixel_format= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
2238#endif /* WGL_ARB_pixel_format */
2239#ifdef WGL_ARB_pixel_format_float
2240  WGLEW_ARB_pixel_format_float = wglewGetExtension("WGL_ARB_pixel_format_float");
2241#endif /* WGL_ARB_pixel_format_float */
2242#ifdef WGL_ARB_render_texture
2243  WGLEW_ARB_render_texture = wglewGetExtension("WGL_ARB_render_texture");
2244  if (glewExperimental || WGLEW_ARB_render_texture|| crippled) WGLEW_ARB_render_texture= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
2245#endif /* WGL_ARB_render_texture */
2246#ifdef WGL_ATI_pixel_format_float
2247  WGLEW_ATI_pixel_format_float = wglewGetExtension("WGL_ATI_pixel_format_float");
2248#endif /* WGL_ATI_pixel_format_float */
2249#ifdef WGL_EXT_extensions_string
2250  WGLEW_EXT_extensions_string = wglewGetExtension("WGL_EXT_extensions_string");
2251  if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) WGLEW_EXT_extensions_string= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
2252#endif /* WGL_EXT_extensions_string */
2253#ifdef WGL_EXT_swap_control
2254  WGLEW_EXT_swap_control = wglewGetExtension("WGL_EXT_swap_control");
2255  if (glewExperimental || WGLEW_EXT_swap_control|| crippled) WGLEW_EXT_swap_control= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
2256#endif /* WGL_EXT_swap_control */
2257
2258  return GLEW_OK;
2259}
2260
2261#endif /* !__APPLE__ || GLEW_APPLE_GLX */
2262
Note: See TracBrowser for help on using the repository browser.