1 /****************************************************************************
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
7 ** This file is part of the QtOpenGL module of the Qt Toolkit.
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
42 #ifndef QGLFUNCTIONS_H
43 #define QGLFUNCTIONS_H
46 #warning qglfunctions.h is not compatible with GLEW, GLEW defines will be undefined
47 #warning To use GLEW with Qt, do not include <QtOpenGL> or <QGLFunctions> after glew.h
50 #include <QtOpenGL/qgl.h>
58 // Types that aren't defined in all system's gl.h files.
59 typedef ptrdiff_t qgl_GLintptr;
60 typedef ptrdiff_t qgl_GLsizeiptr;
63 # ifndef QGLF_APIENTRYP
65 # define QGLF_APIENTRYP QGLF_APIENTRY *
67 # define QGLF_APIENTRY
68 # define QGLF_APIENTRYP *
72 struct QGLFunctionsPrivate;
74 // Undefine any macros from GLEW, qglextensions_p.h, etc that
75 // may interfere with the definition of QGLFunctions.
76 #undef glActiveTexture
78 #undef glBindAttribLocation
80 #undef glBindFramebuffer
81 #undef glBindRenderbuffer
83 #undef glBlendEquation
84 #undef glBlendEquationSeparate
85 #undef glBlendFuncSeparate
87 #undef glBufferSubData
88 #undef glCheckFramebufferStatus
90 #undef glCompileShader
91 #undef glCompressedTexImage2D
92 #undef glCompressedTexSubImage2D
93 #undef glCreateProgram
95 #undef glDeleteBuffers
96 #undef glDeleteFramebuffers
97 #undef glDeleteProgram
98 #undef glDeleteRenderbuffers
101 #undef glDetachShader
102 #undef glDisableVertexAttribArray
103 #undef glEnableVertexAttribArray
104 #undef glFramebufferRenderbuffer
105 #undef glFramebufferTexture2D
107 #undef glGenerateMipmap
108 #undef glGenFramebuffers
109 #undef glGenRenderbuffers
110 #undef glGetActiveAttrib
111 #undef glGetActiveUniform
112 #undef glGetAttachedShaders
113 #undef glGetAttribLocation
114 #undef glGetBufferParameteriv
115 #undef glGetFramebufferAttachmentParameteriv
116 #undef glGetProgramiv
117 #undef glGetProgramInfoLog
118 #undef glGetRenderbufferParameteriv
120 #undef glGetShaderInfoLog
121 #undef glGetShaderPrecisionFormat
122 #undef glGetShaderSource
123 #undef glGetUniformfv
124 #undef glGetUniformiv
125 #undef glGetUniformLocation
126 #undef glGetVertexAttribfv
127 #undef glGetVertexAttribiv
128 #undef glGetVertexAttribPointerv
130 #undef glIsFramebuffer
132 #undef glIsRenderbuffer
135 #undef glReleaseShaderCompiler
136 #undef glRenderbufferStorage
137 #undef glSampleCoverage
138 #undef glShaderBinary
139 #undef glShaderSource
140 #undef glStencilFuncSeparate
141 #undef glStencilMaskSeparate
142 #undef glStencilOpSeparate
159 #undef glUniformMatrix2fv
160 #undef glUniformMatrix3fv
161 #undef glUniformMatrix4fv
163 #undef glValidateProgram
164 #undef glVertexAttrib1f
165 #undef glVertexAttrib1fv
166 #undef glVertexAttrib2f
167 #undef glVertexAttrib2fv
168 #undef glVertexAttrib3f
169 #undef glVertexAttrib3fv
170 #undef glVertexAttrib4f
171 #undef glVertexAttrib4fv
172 #undef glVertexAttribPointer
174 class Q_OPENGL_EXPORT QGLFunctions
178 explicit QGLFunctions(const QGLContext *context);
183 Multitexture = 0x0001,
186 Framebuffers = 0x0008,
188 BlendEquation = 0x0020,
189 BlendEquationSeparate = 0x0040,
190 BlendFuncSeparate = 0x0080,
191 BlendSubtract = 0x0100,
192 CompressedTextures = 0x0200,
193 Multisample = 0x0400,
194 StencilSeparate = 0x0800,
195 NPOTTextures = 0x1000
197 Q_DECLARE_FLAGS(OpenGLFeatures, OpenGLFeature)
199 QGLFunctions::OpenGLFeatures openGLFeatures() const;
200 bool hasOpenGLFeature(QGLFunctions::OpenGLFeature feature) const;
202 void initializeGLFunctions(const QGLContext *context = 0);
204 void glActiveTexture(GLenum texture);
205 void glAttachShader(GLuint program, GLuint shader);
206 void glBindAttribLocation(GLuint program, GLuint index, const char* name);
207 void glBindBuffer(GLenum target, GLuint buffer);
208 void glBindFramebuffer(GLenum target, GLuint framebuffer);
209 void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
210 void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
211 void glBlendEquation(GLenum mode);
212 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
213 void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
214 void glBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
215 void glBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
216 GLenum glCheckFramebufferStatus(GLenum target);
217 void glClearDepthf(GLclampf depth);
218 void glCompileShader(GLuint shader);
219 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
220 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
221 GLuint glCreateProgram();
222 GLuint glCreateShader(GLenum type);
223 void glDeleteBuffers(GLsizei n, const GLuint* buffers);
224 void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
225 void glDeleteProgram(GLuint program);
226 void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);
227 void glDeleteShader(GLuint shader);
228 void glDepthRangef(GLclampf zNear, GLclampf zFar);
229 void glDetachShader(GLuint program, GLuint shader);
230 void glDisableVertexAttribArray(GLuint index);
231 void glEnableVertexAttribArray(GLuint index);
232 void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
233 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
234 void glGenBuffers(GLsizei n, GLuint* buffers);
235 void glGenerateMipmap(GLenum target);
236 void glGenFramebuffers(GLsizei n, GLuint* framebuffers);
237 void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers);
238 void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
239 void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
240 void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
241 int glGetAttribLocation(GLuint program, const char* name);
242 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
243 void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);
244 void glGetProgramiv(GLuint program, GLenum pname, GLint* params);
245 void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
246 void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);
247 void glGetShaderiv(GLuint shader, GLenum pname, GLint* params);
248 void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
249 void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
250 void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
251 void glGetUniformfv(GLuint program, GLint location, GLfloat* params);
252 void glGetUniformiv(GLuint program, GLint location, GLint* params);
253 int glGetUniformLocation(GLuint program, const char* name);
254 void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);
255 void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);
256 void glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer);
257 GLboolean glIsBuffer(GLuint buffer);
258 GLboolean glIsFramebuffer(GLuint framebuffer);
259 GLboolean glIsProgram(GLuint program);
260 GLboolean glIsRenderbuffer(GLuint renderbuffer);
261 GLboolean glIsShader(GLuint shader);
262 void glLinkProgram(GLuint program);
263 void glReleaseShaderCompiler();
264 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
265 void glSampleCoverage(GLclampf value, GLboolean invert);
266 void glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
267 void glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length);
268 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
269 void glStencilMaskSeparate(GLenum face, GLuint mask);
270 void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
271 void glUniform1f(GLint location, GLfloat x);
272 void glUniform1fv(GLint location, GLsizei count, const GLfloat* v);
273 void glUniform1i(GLint location, GLint x);
274 void glUniform1iv(GLint location, GLsizei count, const GLint* v);
275 void glUniform2f(GLint location, GLfloat x, GLfloat y);
276 void glUniform2fv(GLint location, GLsizei count, const GLfloat* v);
277 void glUniform2i(GLint location, GLint x, GLint y);
278 void glUniform2iv(GLint location, GLsizei count, const GLint* v);
279 void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
280 void glUniform3fv(GLint location, GLsizei count, const GLfloat* v);
281 void glUniform3i(GLint location, GLint x, GLint y, GLint z);
282 void glUniform3iv(GLint location, GLsizei count, const GLint* v);
283 void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
284 void glUniform4fv(GLint location, GLsizei count, const GLfloat* v);
285 void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
286 void glUniform4iv(GLint location, GLsizei count, const GLint* v);
287 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
288 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
289 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
290 void glUseProgram(GLuint program);
291 void glValidateProgram(GLuint program);
292 void glVertexAttrib1f(GLuint indx, GLfloat x);
293 void glVertexAttrib1fv(GLuint indx, const GLfloat* values);
294 void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
295 void glVertexAttrib2fv(GLuint indx, const GLfloat* values);
296 void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
297 void glVertexAttrib3fv(GLuint indx, const GLfloat* values);
298 void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
299 void glVertexAttrib4fv(GLuint indx, const GLfloat* values);
300 void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
303 QGLFunctionsPrivate *d_ptr;
304 static bool isInitialized(const QGLFunctionsPrivate *d) { return d != 0; }
307 Q_DECLARE_OPERATORS_FOR_FLAGS(QGLFunctions::OpenGLFeatures)
309 struct QGLFunctionsPrivate
311 QGLFunctionsPrivate(const QGLContext *context = 0);
313 #ifndef QT_OPENGL_ES_2
314 void (QGLF_APIENTRYP activeTexture)(GLenum texture);
315 void (QGLF_APIENTRYP attachShader)(GLuint program, GLuint shader);
316 void (QGLF_APIENTRYP bindAttribLocation)(GLuint program, GLuint index, const char* name);
317 void (QGLF_APIENTRYP bindBuffer)(GLenum target, GLuint buffer);
318 void (QGLF_APIENTRYP bindFramebuffer)(GLenum target, GLuint framebuffer);
319 void (QGLF_APIENTRYP bindRenderbuffer)(GLenum target, GLuint renderbuffer);
320 void (QGLF_APIENTRYP blendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
321 void (QGLF_APIENTRYP blendEquation)(GLenum mode);
322 void (QGLF_APIENTRYP blendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
323 void (QGLF_APIENTRYP blendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
324 void (QGLF_APIENTRYP bufferData)(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
325 void (QGLF_APIENTRYP bufferSubData)(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
326 GLenum (QGLF_APIENTRYP checkFramebufferStatus)(GLenum target);
327 void (QGLF_APIENTRYP compileShader)(GLuint shader);
328 void (QGLF_APIENTRYP compressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
329 void (QGLF_APIENTRYP compressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
330 GLuint (QGLF_APIENTRYP createProgram)();
331 GLuint (QGLF_APIENTRYP createShader)(GLenum type);
332 void (QGLF_APIENTRYP deleteBuffers)(GLsizei n, const GLuint* buffers);
333 void (QGLF_APIENTRYP deleteFramebuffers)(GLsizei n, const GLuint* framebuffers);
334 void (QGLF_APIENTRYP deleteProgram)(GLuint program);
335 void (QGLF_APIENTRYP deleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);
336 void (QGLF_APIENTRYP deleteShader)(GLuint shader);
337 void (QGLF_APIENTRYP detachShader)(GLuint program, GLuint shader);
338 void (QGLF_APIENTRYP disableVertexAttribArray)(GLuint index);
339 void (QGLF_APIENTRYP enableVertexAttribArray)(GLuint index);
340 void (QGLF_APIENTRYP framebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
341 void (QGLF_APIENTRYP framebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
342 void (QGLF_APIENTRYP genBuffers)(GLsizei n, GLuint* buffers);
343 void (QGLF_APIENTRYP generateMipmap)(GLenum target);
344 void (QGLF_APIENTRYP genFramebuffers)(GLsizei n, GLuint* framebuffers);
345 void (QGLF_APIENTRYP genRenderbuffers)(GLsizei n, GLuint* renderbuffers);
346 void (QGLF_APIENTRYP getActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
347 void (QGLF_APIENTRYP getActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
348 void (QGLF_APIENTRYP getAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
349 int (QGLF_APIENTRYP getAttribLocation)(GLuint program, const char* name);
350 void (QGLF_APIENTRYP getBufferParameteriv)(GLenum target, GLenum pname, GLint* params);
351 void (QGLF_APIENTRYP getFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
352 void (QGLF_APIENTRYP getProgramiv)(GLuint program, GLenum pname, GLint* params);
353 void (QGLF_APIENTRYP getProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
354 void (QGLF_APIENTRYP getRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
355 void (QGLF_APIENTRYP getShaderiv)(GLuint shader, GLenum pname, GLint* params);
356 void (QGLF_APIENTRYP getShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
357 void (QGLF_APIENTRYP getShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
358 void (QGLF_APIENTRYP getShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
359 void (QGLF_APIENTRYP getUniformfv)(GLuint program, GLint location, GLfloat* params);
360 void (QGLF_APIENTRYP getUniformiv)(GLuint program, GLint location, GLint* params);
361 int (QGLF_APIENTRYP getUniformLocation)(GLuint program, const char* name);
362 void (QGLF_APIENTRYP getVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);
363 void (QGLF_APIENTRYP getVertexAttribiv)(GLuint index, GLenum pname, GLint* params);
364 void (QGLF_APIENTRYP getVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);
365 GLboolean (QGLF_APIENTRYP isBuffer)(GLuint buffer);
366 GLboolean (QGLF_APIENTRYP isFramebuffer)(GLuint framebuffer);
367 GLboolean (QGLF_APIENTRYP isProgram)(GLuint program);
368 GLboolean (QGLF_APIENTRYP isRenderbuffer)(GLuint renderbuffer);
369 GLboolean (QGLF_APIENTRYP isShader)(GLuint shader);
370 void (QGLF_APIENTRYP linkProgram)(GLuint program);
371 void (QGLF_APIENTRYP releaseShaderCompiler)();
372 void (QGLF_APIENTRYP renderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
373 void (QGLF_APIENTRYP sampleCoverage)(GLclampf value, GLboolean invert);
374 void (QGLF_APIENTRYP shaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
375 void (QGLF_APIENTRYP shaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
376 void (QGLF_APIENTRYP stencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
377 void (QGLF_APIENTRYP stencilMaskSeparate)(GLenum face, GLuint mask);
378 void (QGLF_APIENTRYP stencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
379 void (QGLF_APIENTRYP uniform1f)(GLint location, GLfloat x);
380 void (QGLF_APIENTRYP uniform1fv)(GLint location, GLsizei count, const GLfloat* v);
381 void (QGLF_APIENTRYP uniform1i)(GLint location, GLint x);
382 void (QGLF_APIENTRYP uniform1iv)(GLint location, GLsizei count, const GLint* v);
383 void (QGLF_APIENTRYP uniform2f)(GLint location, GLfloat x, GLfloat y);
384 void (QGLF_APIENTRYP uniform2fv)(GLint location, GLsizei count, const GLfloat* v);
385 void (QGLF_APIENTRYP uniform2i)(GLint location, GLint x, GLint y);
386 void (QGLF_APIENTRYP uniform2iv)(GLint location, GLsizei count, const GLint* v);
387 void (QGLF_APIENTRYP uniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);
388 void (QGLF_APIENTRYP uniform3fv)(GLint location, GLsizei count, const GLfloat* v);
389 void (QGLF_APIENTRYP uniform3i)(GLint location, GLint x, GLint y, GLint z);
390 void (QGLF_APIENTRYP uniform3iv)(GLint location, GLsizei count, const GLint* v);
391 void (QGLF_APIENTRYP uniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
392 void (QGLF_APIENTRYP uniform4fv)(GLint location, GLsizei count, const GLfloat* v);
393 void (QGLF_APIENTRYP uniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);
394 void (QGLF_APIENTRYP uniform4iv)(GLint location, GLsizei count, const GLint* v);
395 void (QGLF_APIENTRYP uniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
396 void (QGLF_APIENTRYP uniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
397 void (QGLF_APIENTRYP uniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
398 void (QGLF_APIENTRYP useProgram)(GLuint program);
399 void (QGLF_APIENTRYP validateProgram)(GLuint program);
400 void (QGLF_APIENTRYP vertexAttrib1f)(GLuint indx, GLfloat x);
401 void (QGLF_APIENTRYP vertexAttrib1fv)(GLuint indx, const GLfloat* values);
402 void (QGLF_APIENTRYP vertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
403 void (QGLF_APIENTRYP vertexAttrib2fv)(GLuint indx, const GLfloat* values);
404 void (QGLF_APIENTRYP vertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
405 void (QGLF_APIENTRYP vertexAttrib3fv)(GLuint indx, const GLfloat* values);
406 void (QGLF_APIENTRYP vertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
407 void (QGLF_APIENTRYP vertexAttrib4fv)(GLuint indx, const GLfloat* values);
408 void (QGLF_APIENTRYP vertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
412 inline void QGLFunctions::glActiveTexture(GLenum texture)
414 #if defined(QT_OPENGL_ES_2)
415 ::glActiveTexture(texture);
417 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
418 d_ptr->activeTexture(texture);
422 inline void QGLFunctions::glAttachShader(GLuint program, GLuint shader)
424 #if defined(QT_OPENGL_ES_2)
425 ::glAttachShader(program, shader);
427 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
428 d_ptr->attachShader(program, shader);
432 inline void QGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
434 #if defined(QT_OPENGL_ES_2)
435 ::glBindAttribLocation(program, index, name);
437 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
438 d_ptr->bindAttribLocation(program, index, name);
442 inline void QGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
444 #if defined(QT_OPENGL_ES_2)
445 ::glBindBuffer(target, buffer);
447 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
448 d_ptr->bindBuffer(target, buffer);
452 inline void QGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffer)
454 #if defined(QT_OPENGL_ES_2)
455 ::glBindFramebuffer(target, framebuffer);
457 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
458 d_ptr->bindFramebuffer(target, framebuffer);
462 inline void QGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
464 #if defined(QT_OPENGL_ES_2)
465 ::glBindRenderbuffer(target, renderbuffer);
467 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
468 d_ptr->bindRenderbuffer(target, renderbuffer);
472 inline void QGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
474 #if defined(QT_OPENGL_ES_2)
475 ::glBlendColor(red, green, blue, alpha);
477 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
478 d_ptr->blendColor(red, green, blue, alpha);
482 inline void QGLFunctions::glBlendEquation(GLenum mode)
484 #if defined(QT_OPENGL_ES_2)
485 ::glBlendEquation(mode);
487 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
488 d_ptr->blendEquation(mode);
492 inline void QGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
494 #if defined(QT_OPENGL_ES_2)
495 ::glBlendEquationSeparate(modeRGB, modeAlpha);
497 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
498 d_ptr->blendEquationSeparate(modeRGB, modeAlpha);
502 inline void QGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
504 #if defined(QT_OPENGL_ES_2)
505 ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
507 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
508 d_ptr->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
512 inline void QGLFunctions::glBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage)
514 #if defined(QT_OPENGL_ES_2)
515 ::glBufferData(target, size, data, usage);
517 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
518 d_ptr->bufferData(target, size, data, usage);
522 inline void QGLFunctions::glBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data)
524 #if defined(QT_OPENGL_ES_2)
525 ::glBufferSubData(target, offset, size, data);
527 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
528 d_ptr->bufferSubData(target, offset, size, data);
532 inline GLenum QGLFunctions::glCheckFramebufferStatus(GLenum target)
534 #if defined(QT_OPENGL_ES_2)
535 return ::glCheckFramebufferStatus(target);
537 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
538 return d_ptr->checkFramebufferStatus(target);
542 inline void QGLFunctions::glClearDepthf(GLclampf depth)
545 ::glClearDepth(depth);
547 ::glClearDepthf(depth);
551 inline void QGLFunctions::glCompileShader(GLuint shader)
553 #if defined(QT_OPENGL_ES_2)
554 ::glCompileShader(shader);
556 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
557 d_ptr->compileShader(shader);
561 inline void QGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
563 #if defined(QT_OPENGL_ES_2)
564 ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
566 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
567 d_ptr->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
571 inline void QGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
573 #if defined(QT_OPENGL_ES_2)
574 ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
576 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
577 d_ptr->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
581 inline GLuint QGLFunctions::glCreateProgram()
583 #if defined(QT_OPENGL_ES_2)
584 return ::glCreateProgram();
586 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
587 return d_ptr->createProgram();
591 inline GLuint QGLFunctions::glCreateShader(GLenum type)
593 #if defined(QT_OPENGL_ES_2)
594 return ::glCreateShader(type);
596 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
597 return d_ptr->createShader(type);
601 inline void QGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
603 #if defined(QT_OPENGL_ES_2)
604 ::glDeleteBuffers(n, buffers);
606 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
607 d_ptr->deleteBuffers(n, buffers);
611 inline void QGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
613 #if defined(QT_OPENGL_ES_2)
614 ::glDeleteFramebuffers(n, framebuffers);
616 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
617 d_ptr->deleteFramebuffers(n, framebuffers);
621 inline void QGLFunctions::glDeleteProgram(GLuint program)
623 #if defined(QT_OPENGL_ES_2)
624 ::glDeleteProgram(program);
626 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
627 d_ptr->deleteProgram(program);
631 inline void QGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
633 #if defined(QT_OPENGL_ES_2)
634 ::glDeleteRenderbuffers(n, renderbuffers);
636 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
637 d_ptr->deleteRenderbuffers(n, renderbuffers);
641 inline void QGLFunctions::glDeleteShader(GLuint shader)
643 #if defined(QT_OPENGL_ES_2)
644 ::glDeleteShader(shader);
646 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
647 d_ptr->deleteShader(shader);
651 inline void QGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
654 ::glDepthRange(zNear, zFar);
656 ::glDepthRangef(zNear, zFar);
660 inline void QGLFunctions::glDetachShader(GLuint program, GLuint shader)
662 #if defined(QT_OPENGL_ES_2)
663 ::glDetachShader(program, shader);
665 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
666 d_ptr->detachShader(program, shader);
670 inline void QGLFunctions::glDisableVertexAttribArray(GLuint index)
672 #if defined(QT_OPENGL_ES_2)
673 ::glDisableVertexAttribArray(index);
675 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
676 d_ptr->disableVertexAttribArray(index);
680 inline void QGLFunctions::glEnableVertexAttribArray(GLuint index)
682 #if defined(QT_OPENGL_ES_2)
683 ::glEnableVertexAttribArray(index);
685 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
686 d_ptr->enableVertexAttribArray(index);
690 inline void QGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
692 #if defined(QT_OPENGL_ES_2)
693 ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
695 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
696 d_ptr->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
700 inline void QGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
702 #if defined(QT_OPENGL_ES_2)
703 ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
705 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
706 d_ptr->framebufferTexture2D(target, attachment, textarget, texture, level);
710 inline void QGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
712 #if defined(QT_OPENGL_ES_2)
713 ::glGenBuffers(n, buffers);
715 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
716 d_ptr->genBuffers(n, buffers);
720 inline void QGLFunctions::glGenerateMipmap(GLenum target)
722 #if defined(QT_OPENGL_ES_2)
723 ::glGenerateMipmap(target);
725 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
726 d_ptr->generateMipmap(target);
730 inline void QGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
732 #if defined(QT_OPENGL_ES_2)
733 ::glGenFramebuffers(n, framebuffers);
735 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
736 d_ptr->genFramebuffers(n, framebuffers);
740 inline void QGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
742 #if defined(QT_OPENGL_ES_2)
743 ::glGenRenderbuffers(n, renderbuffers);
745 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
746 d_ptr->genRenderbuffers(n, renderbuffers);
750 inline void QGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
752 #if defined(QT_OPENGL_ES_2)
753 ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
755 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
756 d_ptr->getActiveAttrib(program, index, bufsize, length, size, type, name);
760 inline void QGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
762 #if defined(QT_OPENGL_ES_2)
763 ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
765 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
766 d_ptr->getActiveUniform(program, index, bufsize, length, size, type, name);
770 inline void QGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
772 #if defined(QT_OPENGL_ES_2)
773 ::glGetAttachedShaders(program, maxcount, count, shaders);
775 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
776 d_ptr->getAttachedShaders(program, maxcount, count, shaders);
780 inline int QGLFunctions::glGetAttribLocation(GLuint program, const char* name)
782 #if defined(QT_OPENGL_ES_2)
783 return ::glGetAttribLocation(program, name);
785 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
786 return d_ptr->getAttribLocation(program, name);
790 inline void QGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
792 #if defined(QT_OPENGL_ES_2)
793 ::glGetBufferParameteriv(target, pname, params);
795 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
796 d_ptr->getBufferParameteriv(target, pname, params);
800 inline void QGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
802 #if defined(QT_OPENGL_ES_2)
803 ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
805 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
806 d_ptr->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
810 inline void QGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
812 #if defined(QT_OPENGL_ES_2)
813 ::glGetProgramiv(program, pname, params);
815 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
816 d_ptr->getProgramiv(program, pname, params);
820 inline void QGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
822 #if defined(QT_OPENGL_ES_2)
823 ::glGetProgramInfoLog(program, bufsize, length, infolog);
825 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
826 d_ptr->getProgramInfoLog(program, bufsize, length, infolog);
830 inline void QGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
832 #if defined(QT_OPENGL_ES_2)
833 ::glGetRenderbufferParameteriv(target, pname, params);
835 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
836 d_ptr->getRenderbufferParameteriv(target, pname, params);
840 inline void QGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
842 #if defined(QT_OPENGL_ES_2)
843 ::glGetShaderiv(shader, pname, params);
845 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
846 d_ptr->getShaderiv(shader, pname, params);
850 inline void QGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
852 #if defined(QT_OPENGL_ES_2)
853 ::glGetShaderInfoLog(shader, bufsize, length, infolog);
855 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
856 d_ptr->getShaderInfoLog(shader, bufsize, length, infolog);
860 inline void QGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
862 #if defined(QT_OPENGL_ES_2)
863 ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
865 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
866 d_ptr->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
870 inline void QGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
872 #if defined(QT_OPENGL_ES_2)
873 ::glGetShaderSource(shader, bufsize, length, source);
875 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
876 d_ptr->getShaderSource(shader, bufsize, length, source);
880 inline void QGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
882 #if defined(QT_OPENGL_ES_2)
883 ::glGetUniformfv(program, location, params);
885 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
886 d_ptr->getUniformfv(program, location, params);
890 inline void QGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint* params)
892 #if defined(QT_OPENGL_ES_2)
893 ::glGetUniformiv(program, location, params);
895 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
896 d_ptr->getUniformiv(program, location, params);
900 inline int QGLFunctions::glGetUniformLocation(GLuint program, const char* name)
902 #if defined(QT_OPENGL_ES_2)
903 return ::glGetUniformLocation(program, name);
905 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
906 return d_ptr->getUniformLocation(program, name);
910 inline void QGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
912 #if defined(QT_OPENGL_ES_2)
913 ::glGetVertexAttribfv(index, pname, params);
915 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
916 d_ptr->getVertexAttribfv(index, pname, params);
920 inline void QGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
922 #if defined(QT_OPENGL_ES_2)
923 ::glGetVertexAttribiv(index, pname, params);
925 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
926 d_ptr->getVertexAttribiv(index, pname, params);
930 inline void QGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
932 #if defined(QT_OPENGL_ES_2)
933 ::glGetVertexAttribPointerv(index, pname, pointer);
935 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
936 d_ptr->getVertexAttribPointerv(index, pname, pointer);
940 inline GLboolean QGLFunctions::glIsBuffer(GLuint buffer)
942 #if defined(QT_OPENGL_ES_2)
943 return ::glIsBuffer(buffer);
945 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
946 return d_ptr->isBuffer(buffer);
950 inline GLboolean QGLFunctions::glIsFramebuffer(GLuint framebuffer)
952 #if defined(QT_OPENGL_ES_2)
953 return ::glIsFramebuffer(framebuffer);
955 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
956 return d_ptr->isFramebuffer(framebuffer);
960 inline GLboolean QGLFunctions::glIsProgram(GLuint program)
962 #if defined(QT_OPENGL_ES_2)
963 return ::glIsProgram(program);
965 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
966 return d_ptr->isProgram(program);
970 inline GLboolean QGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
972 #if defined(QT_OPENGL_ES_2)
973 return ::glIsRenderbuffer(renderbuffer);
975 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
976 return d_ptr->isRenderbuffer(renderbuffer);
980 inline GLboolean QGLFunctions::glIsShader(GLuint shader)
982 #if defined(QT_OPENGL_ES_2)
983 return ::glIsShader(shader);
985 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
986 return d_ptr->isShader(shader);
990 inline void QGLFunctions::glLinkProgram(GLuint program)
992 #if defined(QT_OPENGL_ES_2)
993 ::glLinkProgram(program);
995 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
996 d_ptr->linkProgram(program);
1000 inline void QGLFunctions::glReleaseShaderCompiler()
1002 #if defined(QT_OPENGL_ES_2)
1003 ::glReleaseShaderCompiler();
1005 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1006 d_ptr->releaseShaderCompiler();
1010 inline void QGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1012 #if defined(QT_OPENGL_ES_2)
1013 ::glRenderbufferStorage(target, internalformat, width, height);
1015 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1016 d_ptr->renderbufferStorage(target, internalformat, width, height);
1020 inline void QGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
1022 #if defined(QT_OPENGL_ES_2)
1023 ::glSampleCoverage(value, invert);
1025 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1026 d_ptr->sampleCoverage(value, invert);
1030 inline void QGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
1032 #if defined(QT_OPENGL_ES_2)
1033 ::glShaderBinary(n, shaders, binaryformat, binary, length);
1035 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1036 d_ptr->shaderBinary(n, shaders, binaryformat, binary, length);
1040 inline void QGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
1042 #if defined(QT_OPENGL_ES_2)
1043 ::glShaderSource(shader, count, string, length);
1045 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1046 d_ptr->shaderSource(shader, count, string, length);
1050 inline void QGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1052 #if defined(QT_OPENGL_ES_2)
1053 ::glStencilFuncSeparate(face, func, ref, mask);
1055 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1056 d_ptr->stencilFuncSeparate(face, func, ref, mask);
1060 inline void QGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
1062 #if defined(QT_OPENGL_ES_2)
1063 ::glStencilMaskSeparate(face, mask);
1065 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1066 d_ptr->stencilMaskSeparate(face, mask);
1070 inline void QGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1072 #if defined(QT_OPENGL_ES_2)
1073 ::glStencilOpSeparate(face, fail, zfail, zpass);
1075 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1076 d_ptr->stencilOpSeparate(face, fail, zfail, zpass);
1080 inline void QGLFunctions::glUniform1f(GLint location, GLfloat x)
1082 #if defined(QT_OPENGL_ES_2)
1083 ::glUniform1f(location, x);
1085 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1086 d_ptr->uniform1f(location, x);
1090 inline void QGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
1092 #if defined(QT_OPENGL_ES_2)
1093 ::glUniform1fv(location, count, v);
1095 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1096 d_ptr->uniform1fv(location, count, v);
1100 inline void QGLFunctions::glUniform1i(GLint location, GLint x)
1102 #if defined(QT_OPENGL_ES_2)
1103 ::glUniform1i(location, x);
1105 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1106 d_ptr->uniform1i(location, x);
1110 inline void QGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint* v)
1112 #if defined(QT_OPENGL_ES_2)
1113 ::glUniform1iv(location, count, v);
1115 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1116 d_ptr->uniform1iv(location, count, v);
1120 inline void QGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
1122 #if defined(QT_OPENGL_ES_2)
1123 ::glUniform2f(location, x, y);
1125 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1126 d_ptr->uniform2f(location, x, y);
1130 inline void QGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
1132 #if defined(QT_OPENGL_ES_2)
1133 ::glUniform2fv(location, count, v);
1135 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1136 d_ptr->uniform2fv(location, count, v);
1140 inline void QGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
1142 #if defined(QT_OPENGL_ES_2)
1143 ::glUniform2i(location, x, y);
1145 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1146 d_ptr->uniform2i(location, x, y);
1150 inline void QGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint* v)
1152 #if defined(QT_OPENGL_ES_2)
1153 ::glUniform2iv(location, count, v);
1155 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1156 d_ptr->uniform2iv(location, count, v);
1160 inline void QGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
1162 #if defined(QT_OPENGL_ES_2)
1163 ::glUniform3f(location, x, y, z);
1165 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1166 d_ptr->uniform3f(location, x, y, z);
1170 inline void QGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
1172 #if defined(QT_OPENGL_ES_2)
1173 ::glUniform3fv(location, count, v);
1175 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1176 d_ptr->uniform3fv(location, count, v);
1180 inline void QGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)
1182 #if defined(QT_OPENGL_ES_2)
1183 ::glUniform3i(location, x, y, z);
1185 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1186 d_ptr->uniform3i(location, x, y, z);
1190 inline void QGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint* v)
1192 #if defined(QT_OPENGL_ES_2)
1193 ::glUniform3iv(location, count, v);
1195 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1196 d_ptr->uniform3iv(location, count, v);
1200 inline void QGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1202 #if defined(QT_OPENGL_ES_2)
1203 ::glUniform4f(location, x, y, z, w);
1205 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1206 d_ptr->uniform4f(location, x, y, z, w);
1210 inline void QGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
1212 #if defined(QT_OPENGL_ES_2)
1213 ::glUniform4fv(location, count, v);
1215 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1216 d_ptr->uniform4fv(location, count, v);
1220 inline void QGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
1222 #if defined(QT_OPENGL_ES_2)
1223 ::glUniform4i(location, x, y, z, w);
1225 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1226 d_ptr->uniform4i(location, x, y, z, w);
1230 inline void QGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint* v)
1232 #if defined(QT_OPENGL_ES_2)
1233 ::glUniform4iv(location, count, v);
1235 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1236 d_ptr->uniform4iv(location, count, v);
1240 inline void QGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1242 #if defined(QT_OPENGL_ES_2)
1243 ::glUniformMatrix2fv(location, count, transpose, value);
1245 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1246 d_ptr->uniformMatrix2fv(location, count, transpose, value);
1250 inline void QGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1252 #if defined(QT_OPENGL_ES_2)
1253 ::glUniformMatrix3fv(location, count, transpose, value);
1255 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1256 d_ptr->uniformMatrix3fv(location, count, transpose, value);
1260 inline void QGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1262 #if defined(QT_OPENGL_ES_2)
1263 ::glUniformMatrix4fv(location, count, transpose, value);
1265 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1266 d_ptr->uniformMatrix4fv(location, count, transpose, value);
1270 inline void QGLFunctions::glUseProgram(GLuint program)
1272 #if defined(QT_OPENGL_ES_2)
1273 ::glUseProgram(program);
1275 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1276 d_ptr->useProgram(program);
1280 inline void QGLFunctions::glValidateProgram(GLuint program)
1282 #if defined(QT_OPENGL_ES_2)
1283 ::glValidateProgram(program);
1285 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1286 d_ptr->validateProgram(program);
1290 inline void QGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
1292 #if defined(QT_OPENGL_ES_2)
1293 ::glVertexAttrib1f(indx, x);
1295 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1296 d_ptr->vertexAttrib1f(indx, x);
1300 inline void QGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
1302 #if defined(QT_OPENGL_ES_2)
1303 ::glVertexAttrib1fv(indx, values);
1305 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1306 d_ptr->vertexAttrib1fv(indx, values);
1310 inline void QGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
1312 #if defined(QT_OPENGL_ES_2)
1313 ::glVertexAttrib2f(indx, x, y);
1315 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1316 d_ptr->vertexAttrib2f(indx, x, y);
1320 inline void QGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
1322 #if defined(QT_OPENGL_ES_2)
1323 ::glVertexAttrib2fv(indx, values);
1325 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1326 d_ptr->vertexAttrib2fv(indx, values);
1330 inline void QGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
1332 #if defined(QT_OPENGL_ES_2)
1333 ::glVertexAttrib3f(indx, x, y, z);
1335 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1336 d_ptr->vertexAttrib3f(indx, x, y, z);
1340 inline void QGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
1342 #if defined(QT_OPENGL_ES_2)
1343 ::glVertexAttrib3fv(indx, values);
1345 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1346 d_ptr->vertexAttrib3fv(indx, values);
1350 inline void QGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1352 #if defined(QT_OPENGL_ES_2)
1353 ::glVertexAttrib4f(indx, x, y, z, w);
1355 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1356 d_ptr->vertexAttrib4f(indx, x, y, z, w);
1360 inline void QGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
1362 #if defined(QT_OPENGL_ES_2)
1363 ::glVertexAttrib4fv(indx, values);
1365 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1366 d_ptr->vertexAttrib4fv(indx, values);
1370 inline void QGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
1372 #if defined(QT_OPENGL_ES_2)
1373 ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
1375 Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
1376 d_ptr->vertexAttribPointer(indx, size, type, normalized, stride, ptr);
1380 #ifndef GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
1381 #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
1383 #ifndef GL_ACTIVE_ATTRIBUTES
1384 #define GL_ACTIVE_ATTRIBUTES 0x8B89
1386 #ifndef GL_ACTIVE_TEXTURE
1387 #define GL_ACTIVE_TEXTURE 0x84E0
1389 #ifndef GL_ACTIVE_UNIFORM_MAX_LENGTH
1390 #define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
1392 #ifndef GL_ACTIVE_UNIFORMS
1393 #define GL_ACTIVE_UNIFORMS 0x8B86
1395 #ifndef GL_ALIASED_LINE_WIDTH_RANGE
1396 #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
1398 #ifndef GL_ALIASED_POINT_SIZE_RANGE
1399 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D
1402 #define GL_ALPHA 0x1906
1404 #ifndef GL_ALPHA_BITS
1405 #define GL_ALPHA_BITS 0x0D55
1408 #define GL_ALWAYS 0x0207
1410 #ifndef GL_ARRAY_BUFFER
1411 #define GL_ARRAY_BUFFER 0x8892
1413 #ifndef GL_ARRAY_BUFFER_BINDING
1414 #define GL_ARRAY_BUFFER_BINDING 0x8894
1416 #ifndef GL_ATTACHED_SHADERS
1417 #define GL_ATTACHED_SHADERS 0x8B85
1420 #define GL_BACK 0x0405
1423 #define GL_BLEND 0x0BE2
1425 #ifndef GL_BLEND_COLOR
1426 #define GL_BLEND_COLOR 0x8005
1428 #ifndef GL_BLEND_DST_ALPHA
1429 #define GL_BLEND_DST_ALPHA 0x80CA
1431 #ifndef GL_BLEND_DST_RGB
1432 #define GL_BLEND_DST_RGB 0x80C8
1434 #ifndef GL_BLEND_EQUATION
1435 #define GL_BLEND_EQUATION 0x8009
1437 #ifndef GL_BLEND_EQUATION_ALPHA
1438 #define GL_BLEND_EQUATION_ALPHA 0x883D
1440 #ifndef GL_BLEND_EQUATION_RGB
1441 #define GL_BLEND_EQUATION_RGB 0x8009
1443 #ifndef GL_BLEND_SRC_ALPHA
1444 #define GL_BLEND_SRC_ALPHA 0x80CB
1446 #ifndef GL_BLEND_SRC_RGB
1447 #define GL_BLEND_SRC_RGB 0x80C9
1449 #ifndef GL_BLUE_BITS
1450 #define GL_BLUE_BITS 0x0D54
1453 #define GL_BOOL 0x8B56
1455 #ifndef GL_BOOL_VEC2
1456 #define GL_BOOL_VEC2 0x8B57
1458 #ifndef GL_BOOL_VEC3
1459 #define GL_BOOL_VEC3 0x8B58
1461 #ifndef GL_BOOL_VEC4
1462 #define GL_BOOL_VEC4 0x8B59
1464 #ifndef GL_BUFFER_SIZE
1465 #define GL_BUFFER_SIZE 0x8764
1467 #ifndef GL_BUFFER_USAGE
1468 #define GL_BUFFER_USAGE 0x8765
1471 #define GL_BYTE 0x1400
1474 #define GL_CCW 0x0901
1476 #ifndef GL_CLAMP_TO_EDGE
1477 #define GL_CLAMP_TO_EDGE 0x812F
1479 #ifndef GL_COLOR_ATTACHMENT0
1480 #define GL_COLOR_ATTACHMENT0 0x8CE0
1482 #ifndef GL_COLOR_BUFFER_BIT
1483 #define GL_COLOR_BUFFER_BIT 0x00004000
1485 #ifndef GL_COLOR_CLEAR_VALUE
1486 #define GL_COLOR_CLEAR_VALUE 0x0C22
1488 #ifndef GL_COLOR_WRITEMASK
1489 #define GL_COLOR_WRITEMASK 0x0C23
1491 #ifndef GL_COMPILE_STATUS
1492 #define GL_COMPILE_STATUS 0x8B81
1494 #ifndef GL_COMPRESSED_TEXTURE_FORMATS
1495 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
1497 #ifndef GL_CONSTANT_ALPHA
1498 #define GL_CONSTANT_ALPHA 0x8003
1500 #ifndef GL_CONSTANT_COLOR
1501 #define GL_CONSTANT_COLOR 0x8001
1503 #ifndef GL_CULL_FACE
1504 #define GL_CULL_FACE 0x0B44
1506 #ifndef GL_CULL_FACE_MODE
1507 #define GL_CULL_FACE_MODE 0x0B45
1509 #ifndef GL_CURRENT_PROGRAM
1510 #define GL_CURRENT_PROGRAM 0x8B8D
1512 #ifndef GL_CURRENT_VERTEX_ATTRIB
1513 #define GL_CURRENT_VERTEX_ATTRIB 0x8626
1516 #define GL_CW 0x0900
1519 #define GL_DECR 0x1E03
1521 #ifndef GL_DECR_WRAP
1522 #define GL_DECR_WRAP 0x8508
1524 #ifndef GL_DELETE_STATUS
1525 #define GL_DELETE_STATUS 0x8B80
1527 #ifndef GL_DEPTH_ATTACHMENT
1528 #define GL_DEPTH_ATTACHMENT 0x8D00
1530 #ifndef GL_DEPTH_BITS
1531 #define GL_DEPTH_BITS 0x0D56
1533 #ifndef GL_DEPTH_BUFFER_BIT
1534 #define GL_DEPTH_BUFFER_BIT 0x00000100
1536 #ifndef GL_DEPTH_CLEAR_VALUE
1537 #define GL_DEPTH_CLEAR_VALUE 0x0B73
1539 #ifndef GL_DEPTH_COMPONENT
1540 #define GL_DEPTH_COMPONENT 0x1902
1542 #ifndef GL_DEPTH_COMPONENT16
1543 #define GL_DEPTH_COMPONENT16 0x81A5
1545 #ifndef GL_DEPTH_FUNC
1546 #define GL_DEPTH_FUNC 0x0B74
1548 #ifndef GL_DEPTH_RANGE
1549 #define GL_DEPTH_RANGE 0x0B70
1551 #ifndef GL_DEPTH_TEST
1552 #define GL_DEPTH_TEST 0x0B71
1554 #ifndef GL_DEPTH_WRITEMASK
1555 #define GL_DEPTH_WRITEMASK 0x0B72
1558 #define GL_DITHER 0x0BD0
1560 #ifndef GL_DONT_CARE
1561 #define GL_DONT_CARE 0x1100
1563 #ifndef GL_DST_ALPHA
1564 #define GL_DST_ALPHA 0x0304
1566 #ifndef GL_DST_COLOR
1567 #define GL_DST_COLOR 0x0306
1569 #ifndef GL_DYNAMIC_DRAW
1570 #define GL_DYNAMIC_DRAW 0x88E8
1572 #ifndef GL_ELEMENT_ARRAY_BUFFER
1573 #define GL_ELEMENT_ARRAY_BUFFER 0x8893
1575 #ifndef GL_ELEMENT_ARRAY_BUFFER_BINDING
1576 #define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
1579 #define GL_EQUAL 0x0202
1581 #ifndef GL_EXTENSIONS
1582 #define GL_EXTENSIONS 0x1F03
1588 #define GL_FASTEST 0x1101
1591 #define GL_FIXED 0x140C
1594 #define GL_FLOAT 0x1406
1596 #ifndef GL_FLOAT_MAT2
1597 #define GL_FLOAT_MAT2 0x8B5A
1599 #ifndef GL_FLOAT_MAT3
1600 #define GL_FLOAT_MAT3 0x8B5B
1602 #ifndef GL_FLOAT_MAT4
1603 #define GL_FLOAT_MAT4 0x8B5C
1605 #ifndef GL_FLOAT_VEC2
1606 #define GL_FLOAT_VEC2 0x8B50
1608 #ifndef GL_FLOAT_VEC3
1609 #define GL_FLOAT_VEC3 0x8B51
1611 #ifndef GL_FLOAT_VEC4
1612 #define GL_FLOAT_VEC4 0x8B52
1614 #ifndef GL_FRAGMENT_SHADER
1615 #define GL_FRAGMENT_SHADER 0x8B30
1617 #ifndef GL_FRAMEBUFFER
1618 #define GL_FRAMEBUFFER 0x8D40
1620 #ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
1621 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
1623 #ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
1624 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
1626 #ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
1627 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
1629 #ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
1630 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
1632 #ifndef GL_FRAMEBUFFER_BINDING
1633 #define GL_FRAMEBUFFER_BINDING 0x8CA6
1635 #ifndef GL_FRAMEBUFFER_COMPLETE
1636 #define GL_FRAMEBUFFER_COMPLETE 0x8CD5
1638 #ifndef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
1639 #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
1641 #ifndef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
1642 #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9
1644 #ifndef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
1645 #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
1647 #ifndef GL_FRAMEBUFFER_UNSUPPORTED
1648 #define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
1651 #define GL_FRONT 0x0404
1653 #ifndef GL_FRONT_AND_BACK
1654 #define GL_FRONT_AND_BACK 0x0408
1656 #ifndef GL_FRONT_FACE
1657 #define GL_FRONT_FACE 0x0B46
1660 #define GL_FUNC_ADD 0x8006
1662 #ifndef GL_FUNC_REVERSE_SUBTRACT
1663 #define GL_FUNC_REVERSE_SUBTRACT 0x800B
1665 #ifndef GL_FUNC_SUBTRACT
1666 #define GL_FUNC_SUBTRACT 0x800A
1668 #ifndef GL_GENERATE_MIPMAP_HINT
1669 #define GL_GENERATE_MIPMAP_HINT 0x8192
1672 #define GL_GEQUAL 0x0206
1675 #define GL_GREATER 0x0204
1677 #ifndef GL_GREEN_BITS
1678 #define GL_GREEN_BITS 0x0D53
1680 #ifndef GL_HIGH_FLOAT
1681 #define GL_HIGH_FLOAT 0x8DF2
1684 #define GL_HIGH_INT 0x8DF5
1686 #ifndef GL_IMPLEMENTATION_COLOR_READ_FORMAT
1687 #define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
1689 #ifndef GL_IMPLEMENTATION_COLOR_READ_TYPE
1690 #define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A
1693 #define GL_INCR 0x1E02
1695 #ifndef GL_INCR_WRAP
1696 #define GL_INCR_WRAP 0x8507
1698 #ifndef GL_INFO_LOG_LENGTH
1699 #define GL_INFO_LOG_LENGTH 0x8B84
1702 #define GL_INT 0x1404
1705 #define GL_INT_VEC2 0x8B53
1708 #define GL_INT_VEC3 0x8B54
1711 #define GL_INT_VEC4 0x8B55
1713 #ifndef GL_INVALID_ENUM
1714 #define GL_INVALID_ENUM 0x0500
1716 #ifndef GL_INVALID_FRAMEBUFFER_OPERATION
1717 #define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
1719 #ifndef GL_INVALID_OPERATION
1720 #define GL_INVALID_OPERATION 0x0502
1722 #ifndef GL_INVALID_VALUE
1723 #define GL_INVALID_VALUE 0x0501
1726 #define GL_INVERT 0x150A
1729 #define GL_KEEP 0x1E00
1732 #define GL_LEQUAL 0x0203
1735 #define GL_LESS 0x0201
1738 #define GL_LINEAR 0x2601
1740 #ifndef GL_LINEAR_MIPMAP_LINEAR
1741 #define GL_LINEAR_MIPMAP_LINEAR 0x2703
1743 #ifndef GL_LINEAR_MIPMAP_NEAREST
1744 #define GL_LINEAR_MIPMAP_NEAREST 0x2701
1746 #ifndef GL_LINE_LOOP
1747 #define GL_LINE_LOOP 0x0002
1750 #define GL_LINES 0x0001
1752 #ifndef GL_LINE_STRIP
1753 #define GL_LINE_STRIP 0x0003
1755 #ifndef GL_LINE_WIDTH
1756 #define GL_LINE_WIDTH 0x0B21
1758 #ifndef GL_LINK_STATUS
1759 #define GL_LINK_STATUS 0x8B82
1761 #ifndef GL_LOW_FLOAT
1762 #define GL_LOW_FLOAT 0x8DF0
1765 #define GL_LOW_INT 0x8DF3
1767 #ifndef GL_LUMINANCE
1768 #define GL_LUMINANCE 0x1909
1770 #ifndef GL_LUMINANCE_ALPHA
1771 #define GL_LUMINANCE_ALPHA 0x190A
1773 #ifndef GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
1774 #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
1776 #ifndef GL_MAX_CUBE_MAP_TEXTURE_SIZE
1777 #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
1779 #ifndef GL_MAX_FRAGMENT_UNIFORM_VECTORS
1780 #define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD
1782 #ifndef GL_MAX_RENDERBUFFER_SIZE
1783 #define GL_MAX_RENDERBUFFER_SIZE 0x84E8
1785 #ifndef GL_MAX_TEXTURE_IMAGE_UNITS
1786 #define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
1788 #ifndef GL_MAX_TEXTURE_SIZE
1789 #define GL_MAX_TEXTURE_SIZE 0x0D33
1791 #ifndef GL_MAX_VARYING_VECTORS
1792 #define GL_MAX_VARYING_VECTORS 0x8DFC
1794 #ifndef GL_MAX_VERTEX_ATTRIBS
1795 #define GL_MAX_VERTEX_ATTRIBS 0x8869
1797 #ifndef GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
1798 #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
1800 #ifndef GL_MAX_VERTEX_UNIFORM_VECTORS
1801 #define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB
1803 #ifndef GL_MAX_VIEWPORT_DIMS
1804 #define GL_MAX_VIEWPORT_DIMS 0x0D3A
1806 #ifndef GL_MEDIUM_FLOAT
1807 #define GL_MEDIUM_FLOAT 0x8DF1
1809 #ifndef GL_MEDIUM_INT
1810 #define GL_MEDIUM_INT 0x8DF4
1812 #ifndef GL_MIRRORED_REPEAT
1813 #define GL_MIRRORED_REPEAT 0x8370
1816 #define GL_NEAREST 0x2600
1818 #ifndef GL_NEAREST_MIPMAP_LINEAR
1819 #define GL_NEAREST_MIPMAP_LINEAR 0x2702
1821 #ifndef GL_NEAREST_MIPMAP_NEAREST
1822 #define GL_NEAREST_MIPMAP_NEAREST 0x2700
1825 #define GL_NEVER 0x0200
1828 #define GL_NICEST 0x1102
1831 #define GL_NO_ERROR 0
1837 #define GL_NOTEQUAL 0x0205
1839 #ifndef GL_NUM_COMPRESSED_TEXTURE_FORMATS
1840 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
1842 #ifndef GL_NUM_SHADER_BINARY_FORMATS
1843 #define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9
1848 #ifndef GL_ONE_MINUS_CONSTANT_ALPHA
1849 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
1851 #ifndef GL_ONE_MINUS_CONSTANT_COLOR
1852 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
1854 #ifndef GL_ONE_MINUS_DST_ALPHA
1855 #define GL_ONE_MINUS_DST_ALPHA 0x0305
1857 #ifndef GL_ONE_MINUS_DST_COLOR
1858 #define GL_ONE_MINUS_DST_COLOR 0x0307
1860 #ifndef GL_ONE_MINUS_SRC_ALPHA
1861 #define GL_ONE_MINUS_SRC_ALPHA 0x0303
1863 #ifndef GL_ONE_MINUS_SRC_COLOR
1864 #define GL_ONE_MINUS_SRC_COLOR 0x0301
1866 #ifndef GL_OUT_OF_MEMORY
1867 #define GL_OUT_OF_MEMORY 0x0505
1869 #ifndef GL_PACK_ALIGNMENT
1870 #define GL_PACK_ALIGNMENT 0x0D05
1873 #define GL_POINTS 0x0000
1875 #ifndef GL_POLYGON_OFFSET_FACTOR
1876 #define GL_POLYGON_OFFSET_FACTOR 0x8038
1878 #ifndef GL_POLYGON_OFFSET_FILL
1879 #define GL_POLYGON_OFFSET_FILL 0x8037
1881 #ifndef GL_POLYGON_OFFSET_UNITS
1882 #define GL_POLYGON_OFFSET_UNITS 0x2A00
1885 #define GL_RED_BITS 0x0D52
1887 #ifndef GL_RENDERBUFFER
1888 #define GL_RENDERBUFFER 0x8D41
1890 #ifndef GL_RENDERBUFFER_ALPHA_SIZE
1891 #define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
1893 #ifndef GL_RENDERBUFFER_BINDING
1894 #define GL_RENDERBUFFER_BINDING 0x8CA7
1896 #ifndef GL_RENDERBUFFER_BLUE_SIZE
1897 #define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
1899 #ifndef GL_RENDERBUFFER_DEPTH_SIZE
1900 #define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
1902 #ifndef GL_RENDERBUFFER_GREEN_SIZE
1903 #define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
1905 #ifndef GL_RENDERBUFFER_HEIGHT
1906 #define GL_RENDERBUFFER_HEIGHT 0x8D43
1908 #ifndef GL_RENDERBUFFER_INTERNAL_FORMAT
1909 #define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
1911 #ifndef GL_RENDERBUFFER_RED_SIZE
1912 #define GL_RENDERBUFFER_RED_SIZE 0x8D50
1914 #ifndef GL_RENDERBUFFER_STENCIL_SIZE
1915 #define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
1917 #ifndef GL_RENDERBUFFER_WIDTH
1918 #define GL_RENDERBUFFER_WIDTH 0x8D42
1921 #define GL_RENDERER 0x1F01
1924 #define GL_REPEAT 0x2901
1927 #define GL_REPLACE 0x1E01
1930 #define GL_RGB 0x1907
1933 #define GL_RGB565 0x8D62
1936 #define GL_RGB5_A1 0x8057
1939 #define GL_RGBA 0x1908
1942 #define GL_RGBA4 0x8056
1945 #define GL_BGRA 0x80E1
1947 #ifndef GL_SAMPLE_ALPHA_TO_COVERAGE
1948 #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
1950 #ifndef GL_SAMPLE_BUFFERS
1951 #define GL_SAMPLE_BUFFERS 0x80A8
1953 #ifndef GL_SAMPLE_COVERAGE
1954 #define GL_SAMPLE_COVERAGE 0x80A0
1956 #ifndef GL_SAMPLE_COVERAGE_INVERT
1957 #define GL_SAMPLE_COVERAGE_INVERT 0x80AB
1959 #ifndef GL_SAMPLE_COVERAGE_VALUE
1960 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA
1962 #ifndef GL_SAMPLER_2D
1963 #define GL_SAMPLER_2D 0x8B5E
1965 #ifndef GL_SAMPLER_CUBE
1966 #define GL_SAMPLER_CUBE 0x8B60
1969 #define GL_SAMPLES 0x80A9
1971 #ifndef GL_SCISSOR_BOX
1972 #define GL_SCISSOR_BOX 0x0C10
1974 #ifndef GL_SCISSOR_TEST
1975 #define GL_SCISSOR_TEST 0x0C11
1977 #ifndef GL_SHADER_BINARY_FORMATS
1978 #define GL_SHADER_BINARY_FORMATS 0x8DF8
1980 #ifndef GL_SHADER_COMPILER
1981 #define GL_SHADER_COMPILER 0x8DFA
1983 #ifndef GL_SHADER_SOURCE_LENGTH
1984 #define GL_SHADER_SOURCE_LENGTH 0x8B88
1986 #ifndef GL_SHADER_TYPE
1987 #define GL_SHADER_TYPE 0x8B4F
1989 #ifndef GL_SHADING_LANGUAGE_VERSION
1990 #define GL_SHADING_LANGUAGE_VERSION 0x8B8C
1993 #define GL_SHORT 0x1402
1995 #ifndef GL_SRC_ALPHA
1996 #define GL_SRC_ALPHA 0x0302
1998 #ifndef GL_SRC_ALPHA_SATURATE
1999 #define GL_SRC_ALPHA_SATURATE 0x0308
2001 #ifndef GL_SRC_COLOR
2002 #define GL_SRC_COLOR 0x0300
2004 #ifndef GL_STATIC_DRAW
2005 #define GL_STATIC_DRAW 0x88E4
2007 #ifndef GL_STENCIL_ATTACHMENT
2008 #define GL_STENCIL_ATTACHMENT 0x8D20
2010 #ifndef GL_STENCIL_BACK_FAIL
2011 #define GL_STENCIL_BACK_FAIL 0x8801
2013 #ifndef GL_STENCIL_BACK_FUNC
2014 #define GL_STENCIL_BACK_FUNC 0x8800
2016 #ifndef GL_STENCIL_BACK_PASS_DEPTH_FAIL
2017 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
2019 #ifndef GL_STENCIL_BACK_PASS_DEPTH_PASS
2020 #define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
2022 #ifndef GL_STENCIL_BACK_REF
2023 #define GL_STENCIL_BACK_REF 0x8CA3
2025 #ifndef GL_STENCIL_BACK_VALUE_MASK
2026 #define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
2028 #ifndef GL_STENCIL_BACK_WRITEMASK
2029 #define GL_STENCIL_BACK_WRITEMASK 0x8CA5
2031 #ifndef GL_STENCIL_BITS
2032 #define GL_STENCIL_BITS 0x0D57
2034 #ifndef GL_STENCIL_BUFFER_BIT
2035 #define GL_STENCIL_BUFFER_BIT 0x00000400
2037 #ifndef GL_STENCIL_CLEAR_VALUE
2038 #define GL_STENCIL_CLEAR_VALUE 0x0B91
2040 #ifndef GL_STENCIL_FAIL
2041 #define GL_STENCIL_FAIL 0x0B94
2043 #ifndef GL_STENCIL_FUNC
2044 #define GL_STENCIL_FUNC 0x0B92
2046 #ifndef GL_STENCIL_INDEX
2047 #define GL_STENCIL_INDEX 0x1901
2049 #ifndef GL_STENCIL_INDEX8
2050 #define GL_STENCIL_INDEX8 0x8D48
2052 #ifndef GL_STENCIL_PASS_DEPTH_FAIL
2053 #define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
2055 #ifndef GL_STENCIL_PASS_DEPTH_PASS
2056 #define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
2058 #ifndef GL_STENCIL_REF
2059 #define GL_STENCIL_REF 0x0B97
2061 #ifndef GL_STENCIL_TEST
2062 #define GL_STENCIL_TEST 0x0B90
2064 #ifndef GL_STENCIL_VALUE_MASK
2065 #define GL_STENCIL_VALUE_MASK 0x0B93
2067 #ifndef GL_STENCIL_WRITEMASK
2068 #define GL_STENCIL_WRITEMASK 0x0B98
2070 #ifndef GL_STREAM_DRAW
2071 #define GL_STREAM_DRAW 0x88E0
2073 #ifndef GL_SUBPIXEL_BITS
2074 #define GL_SUBPIXEL_BITS 0x0D50
2077 #define GL_TEXTURE0 0x84C0
2080 #define GL_TEXTURE 0x1702
2082 #ifndef GL_TEXTURE10
2083 #define GL_TEXTURE10 0x84CA
2086 #define GL_TEXTURE1 0x84C1
2088 #ifndef GL_TEXTURE11
2089 #define GL_TEXTURE11 0x84CB
2091 #ifndef GL_TEXTURE12
2092 #define GL_TEXTURE12 0x84CC
2094 #ifndef GL_TEXTURE13
2095 #define GL_TEXTURE13 0x84CD
2097 #ifndef GL_TEXTURE14
2098 #define GL_TEXTURE14 0x84CE
2100 #ifndef GL_TEXTURE15
2101 #define GL_TEXTURE15 0x84CF
2103 #ifndef GL_TEXTURE16
2104 #define GL_TEXTURE16 0x84D0
2106 #ifndef GL_TEXTURE17
2107 #define GL_TEXTURE17 0x84D1
2109 #ifndef GL_TEXTURE18
2110 #define GL_TEXTURE18 0x84D2
2112 #ifndef GL_TEXTURE19
2113 #define GL_TEXTURE19 0x84D3
2115 #ifndef GL_TEXTURE20
2116 #define GL_TEXTURE20 0x84D4
2119 #define GL_TEXTURE2 0x84C2
2121 #ifndef GL_TEXTURE21
2122 #define GL_TEXTURE21 0x84D5
2124 #ifndef GL_TEXTURE22
2125 #define GL_TEXTURE22 0x84D6
2127 #ifndef GL_TEXTURE23
2128 #define GL_TEXTURE23 0x84D7
2130 #ifndef GL_TEXTURE24
2131 #define GL_TEXTURE24 0x84D8
2133 #ifndef GL_TEXTURE25
2134 #define GL_TEXTURE25 0x84D9
2136 #ifndef GL_TEXTURE26
2137 #define GL_TEXTURE26 0x84DA
2139 #ifndef GL_TEXTURE27
2140 #define GL_TEXTURE27 0x84DB
2142 #ifndef GL_TEXTURE28
2143 #define GL_TEXTURE28 0x84DC
2145 #ifndef GL_TEXTURE29
2146 #define GL_TEXTURE29 0x84DD
2148 #ifndef GL_TEXTURE_2D
2149 #define GL_TEXTURE_2D 0x0DE1
2151 #ifndef GL_TEXTURE30
2152 #define GL_TEXTURE30 0x84DE
2155 #define GL_TEXTURE3 0x84C3
2157 #ifndef GL_TEXTURE31
2158 #define GL_TEXTURE31 0x84DF
2161 #define GL_TEXTURE4 0x84C4
2164 #define GL_TEXTURE5 0x84C5
2167 #define GL_TEXTURE6 0x84C6
2170 #define GL_TEXTURE7 0x84C7
2173 #define GL_TEXTURE8 0x84C8
2176 #define GL_TEXTURE9 0x84C9
2178 #ifndef GL_TEXTURE_BINDING_2D
2179 #define GL_TEXTURE_BINDING_2D 0x8069
2181 #ifndef GL_TEXTURE_BINDING_CUBE_MAP
2182 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
2184 #ifndef GL_TEXTURE_CUBE_MAP
2185 #define GL_TEXTURE_CUBE_MAP 0x8513
2187 #ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_X
2188 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
2190 #ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
2191 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
2193 #ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
2194 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
2196 #ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_X
2197 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
2199 #ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Y
2200 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
2202 #ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Z
2203 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
2205 #ifndef GL_TEXTURE_MAG_FILTER
2206 #define GL_TEXTURE_MAG_FILTER 0x2800
2208 #ifndef GL_TEXTURE_MIN_FILTER
2209 #define GL_TEXTURE_MIN_FILTER 0x2801
2211 #ifndef GL_TEXTURE_WRAP_S
2212 #define GL_TEXTURE_WRAP_S 0x2802
2214 #ifndef GL_TEXTURE_WRAP_T
2215 #define GL_TEXTURE_WRAP_T 0x2803
2217 #ifndef GL_TRIANGLE_FAN
2218 #define GL_TRIANGLE_FAN 0x0006
2220 #ifndef GL_TRIANGLES
2221 #define GL_TRIANGLES 0x0004
2223 #ifndef GL_TRIANGLE_STRIP
2224 #define GL_TRIANGLE_STRIP 0x0005
2229 #ifndef GL_UNPACK_ALIGNMENT
2230 #define GL_UNPACK_ALIGNMENT 0x0CF5
2232 #ifndef GL_UNSIGNED_BYTE
2233 #define GL_UNSIGNED_BYTE 0x1401
2235 #ifndef GL_UNSIGNED_INT
2236 #define GL_UNSIGNED_INT 0x1405
2238 #ifndef GL_UNSIGNED_SHORT
2239 #define GL_UNSIGNED_SHORT 0x1403
2241 #ifndef GL_UNSIGNED_SHORT_4_4_4_4
2242 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
2244 #ifndef GL_UNSIGNED_SHORT_5_5_5_1
2245 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
2247 #ifndef GL_UNSIGNED_SHORT_5_6_5
2248 #define GL_UNSIGNED_SHORT_5_6_5 0x8363
2250 #ifndef GL_VALIDATE_STATUS
2251 #define GL_VALIDATE_STATUS 0x8B83
2254 #define GL_VENDOR 0x1F00
2257 #define GL_VERSION 0x1F02
2259 #ifndef GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
2260 #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
2262 #ifndef GL_VERTEX_ATTRIB_ARRAY_ENABLED
2263 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
2265 #ifndef GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
2266 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
2268 #ifndef GL_VERTEX_ATTRIB_ARRAY_POINTER
2269 #define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
2271 #ifndef GL_VERTEX_ATTRIB_ARRAY_SIZE
2272 #define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
2274 #ifndef GL_VERTEX_ATTRIB_ARRAY_STRIDE
2275 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
2277 #ifndef GL_VERTEX_ATTRIB_ARRAY_TYPE
2278 #define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
2280 #ifndef GL_VERTEX_SHADER
2281 #define GL_VERTEX_SHADER 0x8B31
2284 #define GL_VIEWPORT 0x0BA2