Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

Last change on this file since 3 was 3, checked in by anonymous, 17 years ago
=update
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
73	static GLuint _glewStrLen (const GLubyte* s)
74	{
75	GLuint i=0;
76	while (s+i != NULL && s[i] != '\0') i++;
77	return i;
78	}
79
80	static 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
87	static 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
94	static 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
115	static 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
131	static 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
159	PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;
160	PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;
161	PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;
162	PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;
163
164	PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;
165	PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;
166	PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;
167	PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;
168	PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;
169	PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;
170	PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;
171	PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;
172	PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;
173	PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;
174	PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;
175	PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;
176	PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;
177	PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;
178	PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;
179	PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;
180	PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;
181	PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;
182	PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;
183	PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;
184	PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;
185	PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;
186	PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;
187	PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;
188	PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;
189	PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;
190	PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;
191	PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;
192	PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;
193	PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;
194	PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;
195	PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;
196	PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;
197	PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;
198	PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;
199	PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;
200	PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;
201	PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;
202	PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;
203	PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;
204	PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;
205	PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;
206	PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;
207	PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;
208	PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;
209	PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;
210
211	PFNGLBLENDCOLORPROC __glewBlendColor = NULL;
212	PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;
213	PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;
214	PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;
215	PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;
216	PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;
217	PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;
218	PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;
219	PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;
220	PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;
221	PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;
222	PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;
223	PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;
224	PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;
225	PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;
226	PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;
227	PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;
228	PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;
229	PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;
230	PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;
231	PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;
232	PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;
233	PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;
234	PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;
235	PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;
236	PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;
237	PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;
238	PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;
239	PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;
240	PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;
241	PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;
242	PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;
243	PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;
244	PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;
245	PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;
246	PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;
247	PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;
248	PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;
249	PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;
250	PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;
251	PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;
252	PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;
253	PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;
254	PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;
255	PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;
256
257	PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;
258	PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;
259	PFNGLBUFFERDATAPROC __glewBufferData = NULL;
260	PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;
261	PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;
262	PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;
263	PFNGLENDQUERYPROC __glewEndQuery = NULL;
264	PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;
265	PFNGLGENQUERIESPROC __glewGenQueries = NULL;
266	PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;
267	PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;
268	PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;
269	PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;
270	PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;
271	PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;
272	PFNGLISBUFFERPROC __glewIsBuffer = NULL;
273	PFNGLISQUERYPROC __glewIsQuery = NULL;
274	PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;
275	PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;
276
277	PFNGLATTACHSHADERPROC __glewAttachShader = NULL;
278	PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;
279	PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;
280	PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;
281	PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;
282	PFNGLCREATESHADERPROC __glewCreateShader = NULL;
283	PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;
284	PFNGLDELETESHADERPROC __glewDeleteShader = NULL;
285	PFNGLDETACHSHADERPROC __glewDetachShader = NULL;
286	PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;
287	PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;
288	PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;
289	PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;
290	PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;
291	PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;
292	PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;
293	PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;
294	PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;
295	PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;
296	PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;
297	PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;
298	PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;
299	PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;
300	PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;
301	PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;
302	PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;
303	PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;
304	PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;
305	PFNGLISPROGRAMPROC __glewIsProgram = NULL;
306	PFNGLISSHADERPROC __glewIsShader = NULL;
307	PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;
308	PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;
309	PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;
310	PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;
311	PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;
312	PFNGLUNIFORM1FPROC __glewUniform1f = NULL;
313	PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;
314	PFNGLUNIFORM1IPROC __glewUniform1i = NULL;
315	PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;
316	PFNGLUNIFORM2FPROC __glewUniform2f = NULL;
317	PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;
318	PFNGLUNIFORM2IPROC __glewUniform2i = NULL;
319	PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;
320	PFNGLUNIFORM3FPROC __glewUniform3f = NULL;
321	PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;
322	PFNGLUNIFORM3IPROC __glewUniform3i = NULL;
323	PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;
324	PFNGLUNIFORM4FPROC __glewUniform4f = NULL;
325	PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;
326	PFNGLUNIFORM4IPROC __glewUniform4i = NULL;
327	PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;
328	PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;
329	PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;
330	PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;
331	PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;
332	PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;
333	PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;
334	PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;
335	PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;
336	PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;
337	PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;
338	PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;
339	PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;
340	PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;
341	PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;
342	PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;
343	PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;
344	PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;
345	PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;
346	PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;
347	PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;
348	PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;
349	PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;
350	PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;
351	PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;
352	PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;
353	PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;
354	PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;
355	PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;
356	PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;
357	PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;
358	PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;
359	PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;
360	PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;
361	PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;
362	PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;
363	PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;
364	PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;
365	PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;
366	PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;
367	PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;
368	PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;
369	PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;
370
371	PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;
372	PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;
373	PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;
374	PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;
375	PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;
376	PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;
377
378	PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;
379
380	PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;
381
382	PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;
383	PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;
384	PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;
385	PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;
386	PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;
387	PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;
388	PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;
389	PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;
390	PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;
391	PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;
392	PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;
393	PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;
394	PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;
395	PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;
396	PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;
397	PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;
398	PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;
399	PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;
400	PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;
401	PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;
402	PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;
403	PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;
404	PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;
405	PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;
406	PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;
407	PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;
408	PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;
409	PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;
410	PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;
411	PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;
412	PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;
413	PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;
414	PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;
415	PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;
416
417	PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;
418	PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;
419	PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;
420	PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;
421	PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;
422	PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;
423	PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;
424	PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;
425
426	PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;
427	PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;
428	PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;
429	PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;
430	PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;
431	PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;
432	PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;
433	PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;
434	PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;
435	PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;
436	PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;
437	PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;
438	PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;
439	PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;
440	PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;
441	PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;
442	PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;
443	PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;
444	PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;
445	PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;
446	PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;
447	PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;
448	PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;
449	PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;
450	PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;
451	PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;
452	PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;
453	PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;
454	PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;
455	PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;
456	PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;
457	PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;
458	PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;
459	PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;
460	PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;
461	PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;
462	PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;
463	PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;
464	PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;
465
466	PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;
467	PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;
468	PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;
469	PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;
470	PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;
471	PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;
472	PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;
473
474	PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;
475	PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;
476	PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;
477	PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;
478	PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;
479	PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;
480	PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;
481	PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;
482	PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;
483	PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;
484	PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;
485
486	PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;
487	PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;
488	PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;
489	PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;
490	PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;
491	PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;
492	PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;
493	PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;
494	PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;
495	PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;
496	PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;
497	PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;
498	PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;
499	PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;
500	PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;
501	PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;
502	PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;
503	PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;
504	PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;
505	PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;
506	PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;
507	PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;
508	PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;
509	PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;
510	PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;
511	PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;
512	PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;
513	PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;
514	PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;
515	PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;
516	PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;
517	PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;
518	PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;
519	PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;
520	PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;
521	PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;
522	PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;
523	PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;
524	PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;
525	PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;
526	PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;
527	PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;
528	PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;
529	PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;
530	PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;
531	PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;
532	PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;
533	PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;
534	PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;
535	PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;
536	PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;
537	PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;
538	PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;
539	PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;
540	PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;
541	PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;
542	PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;
543	PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;
544	PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;
545	PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;
546	PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;
547	PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;
548
549	PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;
550	PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;
551	PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;
552
553	PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;
554
555	PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;
556	PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;
557	PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;
558	PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;
559	PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;
560	PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;
561	PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;
562	PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;
563	PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;
564	PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;
565	PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;
566	PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;
567	PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;
568	PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;
569
570	PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;
571	PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;
572	PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;
573	PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;
574	PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;
575	PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;
576	PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;
577	PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;
578	PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;
579	PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;
580	PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;
581	PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;
582	PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;
583	PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;
584	PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;
585	PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;
586	PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;
587
588	PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;
589	PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;
590	PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;
591	PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;
592	PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;
593	PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;
594	PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;
595	PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;
596	PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;
597	PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;
598	PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;
599	PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;
600	PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;
601	PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;
602	PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;
603	PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;
604	PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;
605
606	PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
607
608	PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;
609	PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;
610	PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;
611	PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;
612	PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;
613	PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;
614
615	PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;
616	PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;
617	PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;
618	PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;
619	PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;
620	PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;
621	PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;
622
623	PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;
624	PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;
625	PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;
626	PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;
627	PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;
628	PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;
629	PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;
630	PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;
631	PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;
632	PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;
633	PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;
634	PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;
635	PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;
636
637	PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;
638	PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;
639
640	PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;
641	PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;
642	PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;
643	PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;
644	PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;
645	PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;
646	PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;
647	PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;
648	PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;
649	PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;
650	PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;
651	PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;
652	PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;
653	PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;
654	PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;
655	PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;
656	PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;
657	PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;
658	PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;
659	PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;
660	PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;
661	PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;
662	PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;
663	PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;
664	PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;
665	PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;
666	PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;
667	PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;
668	PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;
669	PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;
670	PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;
671	PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;
672	PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;
673	PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;
674	PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;
675	PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;
676	PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;
677	PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;
678	PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;
679	PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;
680	PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;
681	PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;
682	PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;
683	PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;
684	PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;
685	PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;
686	PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;
687	PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;
688	PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;
689	PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;
690	PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;
691	PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;
692	PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;
693	PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;
694	PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;
695	PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;
696	PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;
697	PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;
698	PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;
699	PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;
700	PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;
701	PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;
702	PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;
703	PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;
704	// SJS
705	PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;
706	PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;
707	PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;
708	PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;
709	// SJS
710
711	#endif /* !WIN32 \|\| !GLEW_MX */
712
713	#if !defined(GLEW_MX)
714
715	GLboolean __GLEW_VERSION_1_1 = GL_FALSE;
716	GLboolean __GLEW_VERSION_1_2 = GL_FALSE;
717	GLboolean __GLEW_VERSION_1_3 = GL_FALSE;
718	GLboolean __GLEW_VERSION_1_4 = GL_FALSE;
719	GLboolean __GLEW_VERSION_1_5 = GL_FALSE;
720	GLboolean __GLEW_VERSION_2_0 = GL_FALSE;
721	GLboolean __GLEW_VERSION_2_1 = GL_FALSE;
722	GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;
723	GLboolean __GLEW_ARB_fragment_program = GL_FALSE;
724	GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;
725	GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;
726	GLboolean __GLEW_ARB_multisample = GL_FALSE;
727	GLboolean __GLEW_ARB_multitexture = GL_FALSE;
728	GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;
729	GLboolean __GLEW_ARB_shader_objects = GL_FALSE;
730	GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;
731	GLboolean __GLEW_ARB_texture_compression = GL_FALSE;
732	GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;
733	GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;
734	GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;
735	GLboolean __GLEW_ARB_texture_float = GL_FALSE;
736	GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;
737	GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;
738	GLboolean __GLEW_ARB_vertex_program = GL_FALSE;
739	GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;
740	GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;
741	GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;
742	GLboolean __GLEW_ATI_texture_float = GL_FALSE;
743	GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;
744	GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;
745	GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;
746	GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
747	GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;
748	GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;
749	GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;
750	GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;
751	GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;
752	GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;
753	GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;
754	GLboolean __GLEW_NV_fragment_program = GL_FALSE;
755	GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;
756	GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;
757	GLboolean __GLEW_NV_occlusion_query = GL_FALSE;
758	GLboolean __GLEW_NV_register_combiners = GL_FALSE;
759	GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;
760	GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;
761	GLboolean __GLEW_NV_texture_shader = GL_FALSE;
762	GLboolean __GLEW_NV_vertex_program = GL_FALSE;
763	GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;
764	GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;
765	GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;
766	// SJS changes for OGRE
767	GLboolean __GLEW_EXT_point_sprite = GL_FALSE;
768	GLboolean __GLEW_EXT_point_parameters = GL_FALSE;
769	GLboolean __GLEW_ARB_point_parameters = GL_FALSE;
770	GLboolean __GLEW_ARB_point_sprite = GL_FALSE;
771	GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;
772	// End changes
773
774	#endif /* !GLEW_MX */
775
776	#ifdef GL_VERSION_1_2
777
778	static 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
794	static 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
852	static 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
909	static 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
940	static 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
1045	static 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
1063	static 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
1088	static 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
1101	static 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
1147	static 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
1167	static 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
1222	static 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
1261	static 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
1284	static 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
1358	static 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
1373	static 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
1386	static 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
1416	static 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
1445	static 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
1474	static 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
1511	static 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
1537	static 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
1556	static 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
1581	static 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
1603	static 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
1691	static 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
1709	static 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	*/
1737	GLboolean 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
1756	GLenum 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
2055	PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;
2056
2057	PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;
2058	PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;
2059	PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;
2060	PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;
2061	PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;
2062
2063	PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;
2064	PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;
2065	PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;
2066
2067	PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;
2068	PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;
2069	PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;
2070
2071	PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;
2072
2073	PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;
2074	PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;
2075	GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;
2076	GLboolean __WGLEW_ARB_multisample = GL_FALSE;
2077	GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;
2078	GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;
2079	GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;
2080	GLboolean __WGLEW_ARB_render_texture = GL_FALSE;
2081	GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;
2082	GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;
2083	GLboolean __WGLEW_EXT_swap_control = GL_FALSE;
2084
2085	#endif /* !GLEW_MX */
2086
2087	#ifdef WGL_ARB_extensions_string
2088
2089	static 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
2106	static 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
2123	static 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
2142	static 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
2161	static 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
2174	static 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
2188	static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;
2189	static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;
2190
2191	GLboolean 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
2214	GLenum 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.

Download in other formats: