Qt
Internal/Contributor docs for the Qt SDK. <b>Note:</b> These are NOT official API docs; those are found <a href='https://doc.qt.io/'>here</a>.
Loading...
Searching...
No Matches
qopenglfunctions_2_1.h
Go to the documentation of this file.
1// Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
2// Copyright (C) 2016 The Qt Company Ltd.
3// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4/***************************************************************************
5** This file was generated by glgen version 0.1
6** Command line was: glgen
7**
8** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
9**
10** This is an auto-generated file.
11** Do not edit! All changes made to it will be lost.
12**
13****************************************************************************/
14
15#ifndef QOPENGLVERSIONFUNCTIONS_2_1_H
16#define QOPENGLVERSIONFUNCTIONS_2_1_H
17
18#include <QtOpenGL/qtopenglglobal.h>
19
20#if !defined(QT_NO_OPENGL) && !QT_CONFIG(opengles2)
21
22#include <QtOpenGL/QOpenGLVersionProfile>
23#include <QtOpenGL/QOpenGLVersionFunctions>
24#include <QtGui/qopenglcontext.h>
25
27
28class Q_OPENGL_EXPORT QOpenGLFunctions_2_1 : public QAbstractOpenGLFunctions
29{
30public:
33
34 bool initializeOpenGLFunctions() override;
35
36 // OpenGL 1.0 core functions
37 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
38 void glDepthRange(GLdouble nearVal, GLdouble farVal);
39 GLboolean glIsEnabled(GLenum cap);
40 void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
41 void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
42 void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
43 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
44 void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
45 const GLubyte * glGetString(GLenum name);
46 void glGetIntegerv(GLenum pname, GLint *params);
47 void glGetFloatv(GLenum pname, GLfloat *params);
48 GLenum glGetError();
49 void glGetDoublev(GLenum pname, GLdouble *params);
50 void glGetBooleanv(GLenum pname, GLboolean *params);
51 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
52 void glReadBuffer(GLenum mode);
53 void glPixelStorei(GLenum pname, GLint param);
54 void glPixelStoref(GLenum pname, GLfloat param);
55 void glDepthFunc(GLenum func);
56 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
57 void glStencilFunc(GLenum func, GLint ref, GLuint mask);
58 void glLogicOp(GLenum opcode);
59 void glBlendFunc(GLenum sfactor, GLenum dfactor);
60 void glFlush();
61 void glFinish();
62 void glEnable(GLenum cap);
63 void glDisable(GLenum cap);
64 void glDepthMask(GLboolean flag);
66 void glStencilMask(GLuint mask);
67 void glClearDepth(GLdouble depth);
68 void glClearStencil(GLint s);
69 void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
70 void glClear(GLbitfield mask);
71 void glDrawBuffer(GLenum mode);
74 void glTexParameteriv(GLenum target, GLenum pname, const GLint *params);
75 void glTexParameteri(GLenum target, GLenum pname, GLint param);
76 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
77 void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
78 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
79 void glPolygonMode(GLenum face, GLenum mode);
80 void glPointSize(GLfloat size);
81 void glLineWidth(GLfloat width);
82 void glHint(GLenum target, GLenum mode);
83 void glFrontFace(GLenum mode);
84 void glCullFace(GLenum mode);
85
86 // OpenGL 1.1 core functions
87 void glIndexubv(const GLubyte *c);
88 void glIndexub(GLubyte c);
89 GLboolean glIsTexture(GLuint texture);
90 void glGenTextures(GLsizei n, GLuint *textures);
91 void glDeleteTextures(GLsizei n, const GLuint *textures);
92 void glBindTexture(GLenum target, GLuint texture);
94 void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
96 void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
99 void glPolygonOffset(GLfloat factor, GLfloat units);
100 void glGetPointerv(GLenum pname, GLvoid* *params);
101 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
102 void glDrawArrays(GLenum mode, GLint first, GLsizei count);
103
104 // OpenGL 1.2 core functions
108 void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
109 void glBlendEquation(GLenum mode);
110 void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
111
112 // OpenGL 1.3 core functions
113 void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img);
114 void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
115 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
117 void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
118 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
120 void glSampleCoverage(GLfloat value, GLboolean invert);
121 void glActiveTexture(GLenum texture);
122
123 // OpenGL 1.4 core functions
124 void glPointParameteriv(GLenum pname, const GLint *params);
125 void glPointParameteri(GLenum pname, GLint param);
126 void glPointParameterfv(GLenum pname, const GLfloat *params);
127 void glPointParameterf(GLenum pname, GLfloat param);
128 void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
129 void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
130 void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
131
132 // OpenGL 1.5 core functions
133 void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params);
134 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
135 GLboolean glUnmapBuffer(GLenum target);
136 GLvoid* glMapBuffer(GLenum target, GLenum access);
137 void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
138 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
139 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
140 GLboolean glIsBuffer(GLuint buffer);
141 void glGenBuffers(GLsizei n, GLuint *buffers);
142 void glDeleteBuffers(GLsizei n, const GLuint *buffers);
143 void glBindBuffer(GLenum target, GLuint buffer);
144 void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
145 void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);
146 void glGetQueryiv(GLenum target, GLenum pname, GLint *params);
147 void glEndQuery(GLenum target);
148 void glBeginQuery(GLenum target, GLuint id);
149 GLboolean glIsQuery(GLuint id);
150 void glDeleteQueries(GLsizei n, const GLuint *ids);
151 void glGenQueries(GLsizei n, GLuint *ids);
152
153 // OpenGL 2.0 core functions
154 void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
155 void glValidateProgram(GLuint program);
156 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
157 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
158 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
159 void glUniform4iv(GLint location, GLsizei count, const GLint *value);
160 void glUniform3iv(GLint location, GLsizei count, const GLint *value);
161 void glUniform2iv(GLint location, GLsizei count, const GLint *value);
162 void glUniform1iv(GLint location, GLsizei count, const GLint *value);
163 void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
164 void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
165 void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
166 void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
167 void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
168 void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
169 void glUniform2i(GLint location, GLint v0, GLint v1);
170 void glUniform1i(GLint location, GLint v0);
171 void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
172 void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
173 void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
174 void glUniform1f(GLint location, GLfloat v0);
175 void glUseProgram(GLuint program);
176 void glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
177 void glLinkProgram(GLuint program);
178 GLboolean glIsShader(GLuint shader);
179 GLboolean glIsProgram(GLuint program);
180 void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);
181 void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
182 void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
183 void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);
184 void glGetUniformiv(GLuint program, GLint location, GLint *params);
185 void glGetUniformfv(GLuint program, GLint location, GLfloat *params);
186 GLint glGetUniformLocation(GLuint program, const GLchar *name);
187 void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
188 void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
189 void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
190 void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
191 void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
192 GLint glGetAttribLocation(GLuint program, const GLchar *name);
193 void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
194 void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
196 void glEnableVertexAttribArray(GLuint index);
197 void glDisableVertexAttribArray(GLuint index);
198 void glDetachShader(GLuint program, GLuint shader);
199 void glDeleteShader(GLuint shader);
200 void glDeleteProgram(GLuint program);
201 GLuint glCreateShader(GLenum type);
202 GLuint glCreateProgram();
203 void glCompileShader(GLuint shader);
204 void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
205 void glAttachShader(GLuint program, GLuint shader);
206 void glStencilMaskSeparate(GLenum face, GLuint mask);
207 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
208 void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
209 void glDrawBuffers(GLsizei n, const GLenum *bufs);
210 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
211
212 // OpenGL 2.1 core functions
213 void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
214 void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
215 void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
216 void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
217 void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
218 void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
219
220 // OpenGL 1.0 deprecated functions
221 void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
222 void glTranslated(GLdouble x, GLdouble y, GLdouble z);
223 void glScalef(GLfloat x, GLfloat y, GLfloat z);
224 void glScaled(GLdouble x, GLdouble y, GLdouble z);
225 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
226 void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
227 void glPushMatrix();
228 void glPopMatrix();
230 void glMultMatrixd(const GLdouble *m);
231 void glMultMatrixf(const GLfloat *m);
232 void glMatrixMode(GLenum mode);
233 void glLoadMatrixd(const GLdouble *m);
234 void glLoadMatrixf(const GLfloat *m);
235 void glLoadIdentity();
237 GLboolean glIsList(GLuint list);
238 void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
239 void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
240 void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
241 void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
242 void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
243 void glGetPolygonStipple(GLubyte *mask);
244 void glGetPixelMapusv(GLenum map, GLushort *values);
245 void glGetPixelMapuiv(GLenum map, GLuint *values);
246 void glGetPixelMapfv(GLenum map, GLfloat *values);
247 void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
248 void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
249 void glGetMapiv(GLenum target, GLenum query, GLint *v);
250 void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
251 void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
252 void glGetLightiv(GLenum light, GLenum pname, GLint *params);
253 void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
254 void glGetClipPlane(GLenum plane, GLdouble *equation);
255 void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
256 void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
257 void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
258 void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
259 void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
260 void glPixelTransferi(GLenum pname, GLint param);
261 void glPixelTransferf(GLenum pname, GLfloat param);
262 void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
263 void glAlphaFunc(GLenum func, GLfloat ref);
264 void glEvalPoint2(GLint i, GLint j);
265 void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
266 void glEvalPoint1(GLint i);
267 void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
268 void glEvalCoord2fv(const GLfloat *u);
269 void glEvalCoord2f(GLfloat u, GLfloat v);
270 void glEvalCoord2dv(const GLdouble *u);
271 void glEvalCoord2d(GLdouble u, GLdouble v);
272 void glEvalCoord1fv(const GLfloat *u);
273 void glEvalCoord1f(GLfloat u);
274 void glEvalCoord1dv(const GLdouble *u);
275 void glEvalCoord1d(GLdouble u);
276 void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
277 void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
278 void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
279 void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
282 void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
284 void glPushAttrib(GLbitfield mask);
285 void glPopAttrib();
286 void glAccum(GLenum op, GLfloat value);
287 void glIndexMask(GLuint mask);
288 void glClearIndex(GLfloat c);
289 void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
290 void glPushName(GLuint name);
291 void glPopName();
292 void glPassThrough(GLfloat token);
293 void glLoadName(GLuint name);
294 void glInitNames();
295 GLint glRenderMode(GLenum mode);
296 void glSelectBuffer(GLsizei size, GLuint *buffer);
297 void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
298 void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
299 void glTexGeni(GLenum coord, GLenum pname, GLint param);
300 void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
301 void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
302 void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
303 void glTexGend(GLenum coord, GLenum pname, GLdouble param);
304 void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
305 void glTexEnvi(GLenum target, GLenum pname, GLint param);
306 void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
307 void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
308 void glShadeModel(GLenum mode);
309 void glPolygonStipple(const GLubyte *mask);
310 void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
311 void glMateriali(GLenum face, GLenum pname, GLint param);
312 void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
313 void glMaterialf(GLenum face, GLenum pname, GLfloat param);
314 void glLineStipple(GLint factor, GLushort pattern);
315 void glLightModeliv(GLenum pname, const GLint *params);
316 void glLightModeli(GLenum pname, GLint param);
317 void glLightModelfv(GLenum pname, const GLfloat *params);
318 void glLightModelf(GLenum pname, GLfloat param);
319 void glLightiv(GLenum light, GLenum pname, const GLint *params);
320 void glLighti(GLenum light, GLenum pname, GLint param);
321 void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
322 void glLightf(GLenum light, GLenum pname, GLfloat param);
323 void glFogiv(GLenum pname, const GLint *params);
324 void glFogi(GLenum pname, GLint param);
325 void glFogfv(GLenum pname, const GLfloat *params);
326 void glFogf(GLenum pname, GLfloat param);
327 void glColorMaterial(GLenum face, GLenum mode);
328 void glClipPlane(GLenum plane, const GLdouble *equation);
329 void glVertex4sv(const GLshort *v);
330 void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
331 void glVertex4iv(const GLint *v);
332 void glVertex4i(GLint x, GLint y, GLint z, GLint w);
333 void glVertex4fv(const GLfloat *v);
334 void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
335 void glVertex4dv(const GLdouble *v);
336 void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
337 void glVertex3sv(const GLshort *v);
338 void glVertex3s(GLshort x, GLshort y, GLshort z);
339 void glVertex3iv(const GLint *v);
340 void glVertex3i(GLint x, GLint y, GLint z);
341 void glVertex3fv(const GLfloat *v);
342 void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
343 void glVertex3dv(const GLdouble *v);
344 void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
345 void glVertex2sv(const GLshort *v);
346 void glVertex2s(GLshort x, GLshort y);
347 void glVertex2iv(const GLint *v);
348 void glVertex2i(GLint x, GLint y);
349 void glVertex2fv(const GLfloat *v);
350 void glVertex2f(GLfloat x, GLfloat y);
351 void glVertex2dv(const GLdouble *v);
352 void glVertex2d(GLdouble x, GLdouble y);
353 void glTexCoord4sv(const GLshort *v);
354 void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
355 void glTexCoord4iv(const GLint *v);
356 void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
357 void glTexCoord4fv(const GLfloat *v);
358 void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
359 void glTexCoord4dv(const GLdouble *v);
360 void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
361 void glTexCoord3sv(const GLshort *v);
362 void glTexCoord3s(GLshort s, GLshort t, GLshort r);
363 void glTexCoord3iv(const GLint *v);
364 void glTexCoord3i(GLint s, GLint t, GLint r);
365 void glTexCoord3fv(const GLfloat *v);
366 void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
367 void glTexCoord3dv(const GLdouble *v);
368 void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
369 void glTexCoord2sv(const GLshort *v);
370 void glTexCoord2s(GLshort s, GLshort t);
371 void glTexCoord2iv(const GLint *v);
372 void glTexCoord2i(GLint s, GLint t);
373 void glTexCoord2fv(const GLfloat *v);
374 void glTexCoord2f(GLfloat s, GLfloat t);
375 void glTexCoord2dv(const GLdouble *v);
376 void glTexCoord2d(GLdouble s, GLdouble t);
377 void glTexCoord1sv(const GLshort *v);
378 void glTexCoord1s(GLshort s);
379 void glTexCoord1iv(const GLint *v);
380 void glTexCoord1i(GLint s);
381 void glTexCoord1fv(const GLfloat *v);
382 void glTexCoord1f(GLfloat s);
383 void glTexCoord1dv(const GLdouble *v);
384 void glTexCoord1d(GLdouble s);
385 void glRectsv(const GLshort *v1, const GLshort *v2);
386 void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
387 void glRectiv(const GLint *v1, const GLint *v2);
388 void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
389 void glRectfv(const GLfloat *v1, const GLfloat *v2);
390 void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
391 void glRectdv(const GLdouble *v1, const GLdouble *v2);
392 void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
393 void glRasterPos4sv(const GLshort *v);
394 void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
395 void glRasterPos4iv(const GLint *v);
396 void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
397 void glRasterPos4fv(const GLfloat *v);
398 void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
399 void glRasterPos4dv(const GLdouble *v);
400 void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
401 void glRasterPos3sv(const GLshort *v);
402 void glRasterPos3s(GLshort x, GLshort y, GLshort z);
403 void glRasterPos3iv(const GLint *v);
404 void glRasterPos3i(GLint x, GLint y, GLint z);
405 void glRasterPos3fv(const GLfloat *v);
406 void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
407 void glRasterPos3dv(const GLdouble *v);
408 void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
409 void glRasterPos2sv(const GLshort *v);
410 void glRasterPos2s(GLshort x, GLshort y);
411 void glRasterPos2iv(const GLint *v);
412 void glRasterPos2i(GLint x, GLint y);
413 void glRasterPos2fv(const GLfloat *v);
414 void glRasterPos2f(GLfloat x, GLfloat y);
415 void glRasterPos2dv(const GLdouble *v);
416 void glRasterPos2d(GLdouble x, GLdouble y);
417 void glNormal3sv(const GLshort *v);
418 void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
419 void glNormal3iv(const GLint *v);
420 void glNormal3i(GLint nx, GLint ny, GLint nz);
421 void glNormal3fv(const GLfloat *v);
422 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
423 void glNormal3dv(const GLdouble *v);
424 void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
425 void glNormal3bv(const GLbyte *v);
426 void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
427 void glIndexsv(const GLshort *c);
428 void glIndexs(GLshort c);
429 void glIndexiv(const GLint *c);
430 void glIndexi(GLint c);
431 void glIndexfv(const GLfloat *c);
432 void glIndexf(GLfloat c);
433 void glIndexdv(const GLdouble *c);
434 void glIndexd(GLdouble c);
435 void glEnd();
436 void glEdgeFlagv(const GLboolean *flag);
437 void glEdgeFlag(GLboolean flag);
438 void glColor4usv(const GLushort *v);
439 void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
440 void glColor4uiv(const GLuint *v);
441 void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
442 void glColor4ubv(const GLubyte *v);
443 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
444 void glColor4sv(const GLshort *v);
445 void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
446 void glColor4iv(const GLint *v);
447 void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
448 void glColor4fv(const GLfloat *v);
449 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
450 void glColor4dv(const GLdouble *v);
452 void glColor4bv(const GLbyte *v);
453 void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
454 void glColor3usv(const GLushort *v);
455 void glColor3us(GLushort red, GLushort green, GLushort blue);
456 void glColor3uiv(const GLuint *v);
457 void glColor3ui(GLuint red, GLuint green, GLuint blue);
458 void glColor3ubv(const GLubyte *v);
459 void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
460 void glColor3sv(const GLshort *v);
461 void glColor3s(GLshort red, GLshort green, GLshort blue);
462 void glColor3iv(const GLint *v);
463 void glColor3i(GLint red, GLint green, GLint blue);
464 void glColor3fv(const GLfloat *v);
465 void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
466 void glColor3dv(const GLdouble *v);
467 void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
468 void glColor3bv(const GLbyte *v);
469 void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
470 void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
471 void glBegin(GLenum mode);
472 void glListBase(GLuint base);
473 GLuint glGenLists(GLsizei range);
474 void glDeleteLists(GLuint list, GLsizei range);
475 void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
476 void glCallList(GLuint list);
477 void glEndList();
478 void glNewList(GLuint list, GLenum mode);
479
480 // OpenGL 1.1 deprecated functions
481 void glPushClientAttrib(GLbitfield mask);
482 void glPopClientAttrib();
483 void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
484 GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
485 void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
486 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
487 void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
488 void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
489 void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
490 void glEnableClientState(GLenum array);
491 void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
492 void glDisableClientState(GLenum array);
493 void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
494 void glArrayElement(GLint i);
495
496 // OpenGL 1.2 deprecated functions
497 void glResetMinmax(GLenum target);
498 void glResetHistogram(GLenum target);
501 void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
502 void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
503 void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
504 void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
505 void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
506 void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
507 void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
508 void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
509 void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
510 void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
511 void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
512 void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
513 void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
514 void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
515 void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
516 void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
517 void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
518 void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
519 void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
520 void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
521 void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
522 void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
523 void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
524 void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
525 void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
526 void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
527 void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
528 void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
529
530 // OpenGL 1.3 deprecated functions
531 void glMultTransposeMatrixd(const GLdouble *m);
532 void glMultTransposeMatrixf(const GLfloat *m);
533 void glLoadTransposeMatrixd(const GLdouble *m);
534 void glLoadTransposeMatrixf(const GLfloat *m);
535 void glMultiTexCoord4sv(GLenum target, const GLshort *v);
536 void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
537 void glMultiTexCoord4iv(GLenum target, const GLint *v);
538 void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
539 void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
540 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
541 void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
542 void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
543 void glMultiTexCoord3sv(GLenum target, const GLshort *v);
544 void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
545 void glMultiTexCoord3iv(GLenum target, const GLint *v);
546 void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
547 void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
548 void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
549 void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
550 void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
551 void glMultiTexCoord2sv(GLenum target, const GLshort *v);
552 void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
553 void glMultiTexCoord2iv(GLenum target, const GLint *v);
554 void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
555 void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
556 void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
557 void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
558 void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
559 void glMultiTexCoord1sv(GLenum target, const GLshort *v);
560 void glMultiTexCoord1s(GLenum target, GLshort s);
561 void glMultiTexCoord1iv(GLenum target, const GLint *v);
562 void glMultiTexCoord1i(GLenum target, GLint s);
563 void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
564 void glMultiTexCoord1f(GLenum target, GLfloat s);
565 void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
566 void glMultiTexCoord1d(GLenum target, GLdouble s);
567 void glClientActiveTexture(GLenum texture);
568
569 // OpenGL 1.4 deprecated functions
570 void glWindowPos3sv(const GLshort *v);
571 void glWindowPos3s(GLshort x, GLshort y, GLshort z);
572 void glWindowPos3iv(const GLint *v);
573 void glWindowPos3i(GLint x, GLint y, GLint z);
574 void glWindowPos3fv(const GLfloat *v);
575 void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
576 void glWindowPos3dv(const GLdouble *v);
577 void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
578 void glWindowPos2sv(const GLshort *v);
579 void glWindowPos2s(GLshort x, GLshort y);
580 void glWindowPos2iv(const GLint *v);
581 void glWindowPos2i(GLint x, GLint y);
582 void glWindowPos2fv(const GLfloat *v);
583 void glWindowPos2f(GLfloat x, GLfloat y);
584 void glWindowPos2dv(const GLdouble *v);
585 void glWindowPos2d(GLdouble x, GLdouble y);
586 void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
587 void glSecondaryColor3usv(const GLushort *v);
588 void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
589 void glSecondaryColor3uiv(const GLuint *v);
590 void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
591 void glSecondaryColor3ubv(const GLubyte *v);
592 void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
593 void glSecondaryColor3sv(const GLshort *v);
594 void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
595 void glSecondaryColor3iv(const GLint *v);
596 void glSecondaryColor3i(GLint red, GLint green, GLint blue);
597 void glSecondaryColor3fv(const GLfloat *v);
598 void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
599 void glSecondaryColor3dv(const GLdouble *v);
600 void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
601 void glSecondaryColor3bv(const GLbyte *v);
602 void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
603 void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
604 void glFogCoorddv(const GLdouble *coord);
605 void glFogCoordd(GLdouble coord);
606 void glFogCoordfv(const GLfloat *coord);
607 void glFogCoordf(GLfloat coord);
608
609 // OpenGL 1.5 deprecated functions
610
611 // OpenGL 2.0 deprecated functions
612 void glVertexAttrib4usv(GLuint index, const GLushort *v);
613 void glVertexAttrib4uiv(GLuint index, const GLuint *v);
614 void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
615 void glVertexAttrib4sv(GLuint index, const GLshort *v);
616 void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
617 void glVertexAttrib4iv(GLuint index, const GLint *v);
618 void glVertexAttrib4fv(GLuint index, const GLfloat *v);
619 void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
620 void glVertexAttrib4dv(GLuint index, const GLdouble *v);
621 void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
622 void glVertexAttrib4bv(GLuint index, const GLbyte *v);
623 void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
624 void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
625 void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
626 void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
627 void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
628 void glVertexAttrib4Niv(GLuint index, const GLint *v);
629 void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
630 void glVertexAttrib3sv(GLuint index, const GLshort *v);
631 void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
632 void glVertexAttrib3fv(GLuint index, const GLfloat *v);
633 void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
634 void glVertexAttrib3dv(GLuint index, const GLdouble *v);
635 void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
636 void glVertexAttrib2sv(GLuint index, const GLshort *v);
637 void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
638 void glVertexAttrib2fv(GLuint index, const GLfloat *v);
639 void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
640 void glVertexAttrib2dv(GLuint index, const GLdouble *v);
641 void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
642 void glVertexAttrib1sv(GLuint index, const GLshort *v);
643 void glVertexAttrib1s(GLuint index, GLshort x);
644 void glVertexAttrib1fv(GLuint index, const GLfloat *v);
645 void glVertexAttrib1f(GLuint index, GLfloat x);
646 void glVertexAttrib1dv(GLuint index, const GLdouble *v);
647 void glVertexAttrib1d(GLuint index, GLdouble x);
648
649 // OpenGL 2.1 deprecated functions
650
651private:
653
654 static bool isContextCompatible(QOpenGLContext *context);
655 static QOpenGLVersionProfile versionProfile();
656
670 Q_DECL_UNUSED_MEMBER void *m_reserved_2_0_Deprecated = nullptr; // To maintain BC
671};
672
673// OpenGL 1.0 core functions
675{
676 d_1_0_Core->f.Viewport(x, y, width, height);
677}
678
680{
681 d_1_0_Core->f.DepthRange(nearVal, farVal);
682}
683
685{
686 return d_1_0_Core->f.IsEnabled(cap);
687}
688
690{
691 d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
692}
693
695{
696 d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
697}
698
700{
701 d_1_0_Core->f.GetTexParameteriv(target, pname, params);
702}
703
705{
706 d_1_0_Core->f.GetTexParameterfv(target, pname, params);
707}
708
710{
711 d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
712}
713
715{
716 return d_1_0_Core->f.GetString(name);
717}
718
720{
721 d_1_0_Core->f.GetIntegerv(pname, params);
722}
723
725{
726 d_1_0_Core->f.GetFloatv(pname, params);
727}
728
730{
731 return d_1_0_Core->f.GetError();
732}
733
735{
736 d_1_0_Core->f.GetDoublev(pname, params);
737}
738
740{
741 d_1_0_Core->f.GetBooleanv(pname, params);
742}
743
745{
746 d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
747}
748
750{
751 d_1_0_Core->f.ReadBuffer(mode);
752}
753
755{
756 d_1_0_Core->f.PixelStorei(pname, param);
757}
758
760{
761 d_1_0_Core->f.PixelStoref(pname, param);
762}
763
765{
766 d_1_0_Core->f.DepthFunc(func);
767}
768
770{
771 d_1_0_Core->f.StencilOp(fail, zfail, zpass);
772}
773
775{
776 d_1_0_Core->f.StencilFunc(func, ref, mask);
777}
778
780{
781 d_1_0_Core->f.LogicOp(opcode);
782}
783
785{
786 d_1_0_Core->f.BlendFunc(sfactor, dfactor);
787}
788
790{
791 d_1_0_Core->f.Flush();
792}
793
795{
796 d_1_0_Core->f.Finish();
797}
798
800{
801 d_1_0_Core->f.Enable(cap);
802}
803
805{
806 d_1_0_Core->f.Disable(cap);
807}
808
810{
811 d_1_0_Core->f.DepthMask(flag);
812}
813
815{
816 d_1_0_Core->f.ColorMask(red, green, blue, alpha);
817}
818
820{
821 d_1_0_Core->f.StencilMask(mask);
822}
823
825{
826 d_1_0_Core->f.ClearDepth(depth);
827}
828
830{
831 d_1_0_Core->f.ClearStencil(s);
832}
833
835{
836 d_1_0_Core->f.ClearColor(red, green, blue, alpha);
837}
838
840{
841 d_1_0_Core->f.Clear(mask);
842}
843
845{
846 d_1_0_Core->f.DrawBuffer(mode);
847}
848
853
858
860{
861 d_1_0_Core->f.TexParameteriv(target, pname, params);
862}
863
865{
866 d_1_0_Core->f.TexParameteri(target, pname, param);
867}
868
870{
871 d_1_0_Core->f.TexParameterfv(target, pname, params);
872}
873
875{
876 d_1_0_Core->f.TexParameterf(target, pname, param);
877}
878
880{
881 d_1_0_Core->f.Scissor(x, y, width, height);
882}
883
885{
886 d_1_0_Core->f.PolygonMode(face, mode);
887}
888
890{
891 d_1_0_Core->f.PointSize(size);
892}
893
895{
896 d_1_0_Core->f.LineWidth(width);
897}
898
900{
901 d_1_0_Core->f.Hint(target, mode);
902}
903
905{
906 d_1_0_Core->f.FrontFace(mode);
907}
908
910{
911 d_1_0_Core->f.CullFace(mode);
912}
913
914
915// OpenGL 1.1 core functions
916inline void QOpenGLFunctions_2_1::glIndexubv(const GLubyte *c)
917{
918 d_1_1_Deprecated->f.Indexubv(c);
919}
920
922{
923 d_1_1_Deprecated->f.Indexub(c);
924}
925
927{
928 return d_1_1_Core->f.IsTexture(texture);
929}
930
932{
933 d_1_1_Core->f.GenTextures(n, textures);
934}
935
937{
938 d_1_1_Core->f.DeleteTextures(n, textures);
939}
940
942{
943 d_1_1_Core->f.BindTexture(target, texture);
944}
945
950
952{
953 d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
954}
955
960
962{
963 d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
964}
965
970
975
977{
978 d_1_1_Core->f.PolygonOffset(factor, units);
979}
980
982{
983 d_1_1_Deprecated->f.GetPointerv(pname, params);
984}
985
987{
988 d_1_1_Core->f.DrawElements(mode, count, type, indices);
989}
990
992{
993 d_1_1_Core->f.DrawArrays(mode, first, count);
994}
995
996
997// OpenGL 1.2 core functions
1002
1007
1012
1014{
1015 d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
1016}
1017
1019{
1020 d_1_2_Core->f.BlendEquation(mode);
1021}
1022
1024{
1025 d_1_2_Core->f.BlendColor(red, green, blue, alpha);
1026}
1027
1028
1029// OpenGL 1.3 core functions
1031{
1032 d_1_3_Core->f.GetCompressedTexImage(target, level, img);
1033}
1034
1036{
1037 d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
1038}
1039
1044
1049
1054
1059
1064
1066{
1067 d_1_3_Core->f.SampleCoverage(value, invert);
1068}
1069
1071{
1072 d_1_3_Core->f.ActiveTexture(texture);
1073}
1074
1075
1076// OpenGL 1.4 core functions
1078{
1079 d_1_4_Core->f.PointParameteriv(pname, params);
1080}
1081
1083{
1084 d_1_4_Core->f.PointParameteri(pname, param);
1085}
1086
1088{
1089 d_1_4_Core->f.PointParameterfv(pname, params);
1090}
1091
1093{
1094 d_1_4_Core->f.PointParameterf(pname, param);
1095}
1096
1098{
1099 d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
1100}
1101
1103{
1104 d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
1105}
1106
1108{
1109 d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
1110}
1111
1112
1113// OpenGL 1.5 core functions
1115{
1116 d_1_5_Core->f.GetBufferPointerv(target, pname, params);
1117}
1118
1120{
1121 d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
1122}
1123
1125{
1126 return d_1_5_Core->f.UnmapBuffer(target);
1127}
1128
1130{
1131 return d_1_5_Core->f.MapBuffer(target, access);
1132}
1133
1135{
1136 d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
1137}
1138
1140{
1141 d_1_5_Core->f.BufferSubData(target, offset, size, data);
1142}
1143
1145{
1146 d_1_5_Core->f.BufferData(target, size, data, usage);
1147}
1148
1150{
1151 return d_1_5_Core->f.IsBuffer(buffer);
1152}
1153
1155{
1156 d_1_5_Core->f.GenBuffers(n, buffers);
1157}
1158
1160{
1161 d_1_5_Core->f.DeleteBuffers(n, buffers);
1162}
1163
1165{
1166 d_1_5_Core->f.BindBuffer(target, buffer);
1167}
1168
1170{
1171 d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
1172}
1173
1175{
1176 d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
1177}
1178
1180{
1181 d_1_5_Core->f.GetQueryiv(target, pname, params);
1182}
1183
1185{
1186 d_1_5_Core->f.EndQuery(target);
1187}
1188
1190{
1191 d_1_5_Core->f.BeginQuery(target, id);
1192}
1193
1195{
1196 return d_1_5_Core->f.IsQuery(id);
1197}
1198
1200{
1201 d_1_5_Core->f.DeleteQueries(n, ids);
1202}
1203
1205{
1206 d_1_5_Core->f.GenQueries(n, ids);
1207}
1208
1209
1210// OpenGL 2.0 core functions
1212{
1213 d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
1214}
1215
1217{
1218 d_2_0_Core->f.ValidateProgram(program);
1219}
1220
1222{
1223 d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
1224}
1225
1227{
1228 d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
1229}
1230
1232{
1233 d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
1234}
1235
1237{
1238 d_2_0_Core->f.Uniform4iv(location, count, value);
1239}
1240
1242{
1243 d_2_0_Core->f.Uniform3iv(location, count, value);
1244}
1245
1247{
1248 d_2_0_Core->f.Uniform2iv(location, count, value);
1249}
1250
1252{
1253 d_2_0_Core->f.Uniform1iv(location, count, value);
1254}
1255
1257{
1258 d_2_0_Core->f.Uniform4fv(location, count, value);
1259}
1260
1262{
1263 d_2_0_Core->f.Uniform3fv(location, count, value);
1264}
1265
1267{
1268 d_2_0_Core->f.Uniform2fv(location, count, value);
1269}
1270
1272{
1273 d_2_0_Core->f.Uniform1fv(location, count, value);
1274}
1275
1277{
1278 d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
1279}
1280
1282{
1283 d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
1284}
1285
1287{
1288 d_2_0_Core->f.Uniform2i(location, v0, v1);
1289}
1290
1292{
1293 d_2_0_Core->f.Uniform1i(location, v0);
1294}
1295
1297{
1298 d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
1299}
1300
1302{
1303 d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
1304}
1305
1307{
1308 d_2_0_Core->f.Uniform2f(location, v0, v1);
1309}
1310
1312{
1313 d_2_0_Core->f.Uniform1f(location, v0);
1314}
1315
1317{
1318 d_2_0_Core->f.UseProgram(program);
1319}
1320
1322{
1323 d_2_0_Core->f.ShaderSource(shader, count, string, length);
1324}
1325
1327{
1328 d_2_0_Core->f.LinkProgram(program);
1329}
1330
1332{
1333 return d_2_0_Core->f.IsShader(shader);
1334}
1335
1337{
1338 return d_2_0_Core->f.IsProgram(program);
1339}
1340
1342{
1343 d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
1344}
1345
1347{
1348 d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
1349}
1350
1352{
1353 d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
1354}
1355
1357{
1358 d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
1359}
1360
1362{
1363 d_2_0_Core->f.GetUniformiv(program, location, params);
1364}
1365
1367{
1368 d_2_0_Core->f.GetUniformfv(program, location, params);
1369}
1370
1372{
1373 return d_2_0_Core->f.GetUniformLocation(program, name);
1374}
1375
1377{
1378 d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
1379}
1380
1382{
1383 d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
1384}
1385
1387{
1388 d_2_0_Core->f.GetShaderiv(shader, pname, params);
1389}
1390
1392{
1393 d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
1394}
1395
1397{
1398 d_2_0_Core->f.GetProgramiv(program, pname, params);
1399}
1400
1402{
1403 return d_2_0_Core->f.GetAttribLocation(program, name);
1404}
1405
1407{
1408 d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
1409}
1410
1415
1420
1422{
1423 d_2_0_Core->f.EnableVertexAttribArray(index);
1424}
1425
1427{
1428 d_2_0_Core->f.DisableVertexAttribArray(index);
1429}
1430
1432{
1433 d_2_0_Core->f.DetachShader(program, shader);
1434}
1435
1437{
1438 d_2_0_Core->f.DeleteShader(shader);
1439}
1440
1442{
1443 d_2_0_Core->f.DeleteProgram(program);
1444}
1445
1447{
1448 return d_2_0_Core->f.CreateShader(type);
1449}
1450
1452{
1453 return d_2_0_Core->f.CreateProgram();
1454}
1455
1457{
1458 d_2_0_Core->f.CompileShader(shader);
1459}
1460
1462{
1463 d_2_0_Core->f.BindAttribLocation(program, index, name);
1464}
1465
1467{
1468 d_2_0_Core->f.AttachShader(program, shader);
1469}
1470
1472{
1473 d_2_0_Core->f.StencilMaskSeparate(face, mask);
1474}
1475
1477{
1478 d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
1479}
1480
1482{
1483 d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
1484}
1485
1487{
1488 d_2_0_Core->f.DrawBuffers(n, bufs);
1489}
1490
1492{
1493 d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
1494}
1495
1496
1497// OpenGL 2.1 core functions
1499{
1500 d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
1501}
1502
1504{
1505 d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
1506}
1507
1509{
1510 d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
1511}
1512
1514{
1515 d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
1516}
1517
1519{
1520 d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
1521}
1522
1524{
1525 d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
1526}
1527
1528
1529// OpenGL 1.0 deprecated functions
1531{
1532 d_1_0_Deprecated->f.Translatef(x, y, z);
1533}
1534
1536{
1537 d_1_0_Deprecated->f.Translated(x, y, z);
1538}
1539
1541{
1542 d_1_0_Deprecated->f.Scalef(x, y, z);
1543}
1544
1546{
1547 d_1_0_Deprecated->f.Scaled(x, y, z);
1548}
1549
1551{
1552 d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
1553}
1554
1556{
1557 d_1_0_Deprecated->f.Rotated(angle, x, y, z);
1558}
1559
1561{
1562 d_1_0_Deprecated->f.PushMatrix();
1563}
1564
1566{
1567 d_1_0_Deprecated->f.PopMatrix();
1568}
1569
1574
1576{
1577 d_1_0_Deprecated->f.MultMatrixd(m);
1578}
1579
1581{
1582 d_1_0_Deprecated->f.MultMatrixf(m);
1583}
1584
1586{
1587 d_1_0_Deprecated->f.MatrixMode(mode);
1588}
1589
1591{
1592 d_1_0_Deprecated->f.LoadMatrixd(m);
1593}
1594
1596{
1597 d_1_0_Deprecated->f.LoadMatrixf(m);
1598}
1599
1601{
1602 d_1_0_Deprecated->f.LoadIdentity();
1603}
1604
1609
1611{
1612 return d_1_0_Deprecated->f.IsList(list);
1613}
1614
1616{
1617 d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
1618}
1619
1621{
1622 d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
1623}
1624
1626{
1627 d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
1628}
1629
1631{
1632 d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
1633}
1634
1636{
1637 d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
1638}
1639
1641{
1642 d_1_0_Deprecated->f.GetPolygonStipple(mask);
1643}
1644
1646{
1647 d_1_0_Deprecated->f.GetPixelMapusv(map, values);
1648}
1649
1651{
1652 d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
1653}
1654
1656{
1657 d_1_0_Deprecated->f.GetPixelMapfv(map, values);
1658}
1659
1661{
1662 d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
1663}
1664
1666{
1667 d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
1668}
1669
1671{
1672 d_1_0_Deprecated->f.GetMapiv(target, query, v);
1673}
1674
1676{
1677 d_1_0_Deprecated->f.GetMapfv(target, query, v);
1678}
1679
1681{
1682 d_1_0_Deprecated->f.GetMapdv(target, query, v);
1683}
1684
1686{
1687 d_1_0_Deprecated->f.GetLightiv(light, pname, params);
1688}
1689
1691{
1692 d_1_0_Deprecated->f.GetLightfv(light, pname, params);
1693}
1694
1696{
1697 d_1_0_Deprecated->f.GetClipPlane(plane, equation);
1698}
1699
1701{
1702 d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
1703}
1704
1706{
1707 d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
1708}
1709
1711{
1712 d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
1713}
1714
1716{
1717 d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
1718}
1719
1721{
1722 d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
1723}
1724
1726{
1727 d_1_0_Deprecated->f.PixelTransferi(pname, param);
1728}
1729
1731{
1732 d_1_0_Deprecated->f.PixelTransferf(pname, param);
1733}
1734
1736{
1737 d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
1738}
1739
1741{
1742 d_1_0_Deprecated->f.AlphaFunc(func, ref);
1743}
1744
1746{
1747 d_1_0_Deprecated->f.EvalPoint2(i, j);
1748}
1749
1751{
1752 d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
1753}
1754
1756{
1757 d_1_0_Deprecated->f.EvalPoint1(i);
1758}
1759
1761{
1762 d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
1763}
1764
1766{
1767 d_1_0_Deprecated->f.EvalCoord2fv(u);
1768}
1769
1771{
1772 d_1_0_Deprecated->f.EvalCoord2f(u, v);
1773}
1774
1776{
1777 d_1_0_Deprecated->f.EvalCoord2dv(u);
1778}
1779
1781{
1782 d_1_0_Deprecated->f.EvalCoord2d(u, v);
1783}
1784
1786{
1787 d_1_0_Deprecated->f.EvalCoord1fv(u);
1788}
1789
1791{
1792 d_1_0_Deprecated->f.EvalCoord1f(u);
1793}
1794
1796{
1797 d_1_0_Deprecated->f.EvalCoord1dv(u);
1798}
1799
1801{
1802 d_1_0_Deprecated->f.EvalCoord1d(u);
1803}
1804
1806{
1807 d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
1808}
1809
1811{
1812 d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
1813}
1814
1816{
1817 d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
1818}
1819
1821{
1822 d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
1823}
1824
1829
1834
1836{
1837 d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
1838}
1839
1841{
1842 d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
1843}
1844
1846{
1847 d_1_0_Deprecated->f.PushAttrib(mask);
1848}
1849
1851{
1852 d_1_0_Deprecated->f.PopAttrib();
1853}
1854
1856{
1857 d_1_0_Deprecated->f.Accum(op, value);
1858}
1859
1861{
1862 d_1_0_Deprecated->f.IndexMask(mask);
1863}
1864
1866{
1867 d_1_0_Deprecated->f.ClearIndex(c);
1868}
1869
1871{
1872 d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
1873}
1874
1876{
1877 d_1_0_Deprecated->f.PushName(name);
1878}
1879
1881{
1882 d_1_0_Deprecated->f.PopName();
1883}
1884
1886{
1887 d_1_0_Deprecated->f.PassThrough(token);
1888}
1889
1891{
1892 d_1_0_Deprecated->f.LoadName(name);
1893}
1894
1896{
1897 d_1_0_Deprecated->f.InitNames();
1898}
1899
1901{
1902 return d_1_0_Deprecated->f.RenderMode(mode);
1903}
1904
1906{
1907 d_1_0_Deprecated->f.SelectBuffer(size, buffer);
1908}
1909
1911{
1912 d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
1913}
1914
1916{
1917 d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
1918}
1919
1921{
1922 d_1_0_Deprecated->f.TexGeni(coord, pname, param);
1923}
1924
1926{
1927 d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
1928}
1929
1931{
1932 d_1_0_Deprecated->f.TexGenf(coord, pname, param);
1933}
1934
1936{
1937 d_1_0_Deprecated->f.TexGendv(coord, pname, params);
1938}
1939
1941{
1942 d_1_0_Deprecated->f.TexGend(coord, pname, param);
1943}
1944
1946{
1947 d_1_0_Deprecated->f.TexEnviv(target, pname, params);
1948}
1949
1951{
1952 d_1_0_Deprecated->f.TexEnvi(target, pname, param);
1953}
1954
1956{
1957 d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
1958}
1959
1961{
1962 d_1_0_Deprecated->f.TexEnvf(target, pname, param);
1963}
1964
1966{
1967 d_1_0_Deprecated->f.ShadeModel(mode);
1968}
1969
1971{
1972 d_1_0_Deprecated->f.PolygonStipple(mask);
1973}
1974
1976{
1977 d_1_0_Deprecated->f.Materialiv(face, pname, params);
1978}
1979
1981{
1982 d_1_0_Deprecated->f.Materiali(face, pname, param);
1983}
1984
1986{
1987 d_1_0_Deprecated->f.Materialfv(face, pname, params);
1988}
1989
1991{
1992 d_1_0_Deprecated->f.Materialf(face, pname, param);
1993}
1994
1996{
1997 d_1_0_Deprecated->f.LineStipple(factor, pattern);
1998}
1999
2001{
2002 d_1_0_Deprecated->f.LightModeliv(pname, params);
2003}
2004
2006{
2007 d_1_0_Deprecated->f.LightModeli(pname, param);
2008}
2009
2011{
2012 d_1_0_Deprecated->f.LightModelfv(pname, params);
2013}
2014
2016{
2017 d_1_0_Deprecated->f.LightModelf(pname, param);
2018}
2019
2021{
2022 d_1_0_Deprecated->f.Lightiv(light, pname, params);
2023}
2024
2026{
2027 d_1_0_Deprecated->f.Lighti(light, pname, param);
2028}
2029
2031{
2032 d_1_0_Deprecated->f.Lightfv(light, pname, params);
2033}
2034
2036{
2037 d_1_0_Deprecated->f.Lightf(light, pname, param);
2038}
2039
2041{
2042 d_1_0_Deprecated->f.Fogiv(pname, params);
2043}
2044
2046{
2047 d_1_0_Deprecated->f.Fogi(pname, param);
2048}
2049
2051{
2052 d_1_0_Deprecated->f.Fogfv(pname, params);
2053}
2054
2056{
2057 d_1_0_Deprecated->f.Fogf(pname, param);
2058}
2059
2061{
2062 d_1_0_Deprecated->f.ColorMaterial(face, mode);
2063}
2064
2066{
2067 d_1_0_Deprecated->f.ClipPlane(plane, equation);
2068}
2069
2070inline void QOpenGLFunctions_2_1::glVertex4sv(const GLshort *v)
2071{
2072 d_1_0_Deprecated->f.Vertex4sv(v);
2073}
2074
2075inline void QOpenGLFunctions_2_1::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2076{
2077 d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
2078}
2079
2081{
2082 d_1_0_Deprecated->f.Vertex4iv(v);
2083}
2084
2086{
2087 d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
2088}
2089
2091{
2092 d_1_0_Deprecated->f.Vertex4fv(v);
2093}
2094
2096{
2097 d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
2098}
2099
2101{
2102 d_1_0_Deprecated->f.Vertex4dv(v);
2103}
2104
2106{
2107 d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
2108}
2109
2110inline void QOpenGLFunctions_2_1::glVertex3sv(const GLshort *v)
2111{
2112 d_1_0_Deprecated->f.Vertex3sv(v);
2113}
2114
2115inline void QOpenGLFunctions_2_1::glVertex3s(GLshort x, GLshort y, GLshort z)
2116{
2117 d_1_0_Deprecated->f.Vertex3s(x, y, z);
2118}
2119
2121{
2122 d_1_0_Deprecated->f.Vertex3iv(v);
2123}
2124
2126{
2127 d_1_0_Deprecated->f.Vertex3i(x, y, z);
2128}
2129
2131{
2132 d_1_0_Deprecated->f.Vertex3fv(v);
2133}
2134
2136{
2137 d_1_0_Deprecated->f.Vertex3f(x, y, z);
2138}
2139
2141{
2142 d_1_0_Deprecated->f.Vertex3dv(v);
2143}
2144
2146{
2147 d_1_0_Deprecated->f.Vertex3d(x, y, z);
2148}
2149
2150inline void QOpenGLFunctions_2_1::glVertex2sv(const GLshort *v)
2151{
2152 d_1_0_Deprecated->f.Vertex2sv(v);
2153}
2154
2155inline void QOpenGLFunctions_2_1::glVertex2s(GLshort x, GLshort y)
2156{
2157 d_1_0_Deprecated->f.Vertex2s(x, y);
2158}
2159
2161{
2162 d_1_0_Deprecated->f.Vertex2iv(v);
2163}
2164
2166{
2167 d_1_0_Deprecated->f.Vertex2i(x, y);
2168}
2169
2171{
2172 d_1_0_Deprecated->f.Vertex2fv(v);
2173}
2174
2176{
2177 d_1_0_Deprecated->f.Vertex2f(x, y);
2178}
2179
2181{
2182 d_1_0_Deprecated->f.Vertex2dv(v);
2183}
2184
2186{
2187 d_1_0_Deprecated->f.Vertex2d(x, y);
2188}
2189
2190inline void QOpenGLFunctions_2_1::glTexCoord4sv(const GLshort *v)
2191{
2192 d_1_0_Deprecated->f.TexCoord4sv(v);
2193}
2194
2195inline void QOpenGLFunctions_2_1::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
2196{
2197 d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
2198}
2199
2201{
2202 d_1_0_Deprecated->f.TexCoord4iv(v);
2203}
2204
2206{
2207 d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
2208}
2209
2211{
2212 d_1_0_Deprecated->f.TexCoord4fv(v);
2213}
2214
2216{
2217 d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
2218}
2219
2221{
2222 d_1_0_Deprecated->f.TexCoord4dv(v);
2223}
2224
2226{
2227 d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
2228}
2229
2230inline void QOpenGLFunctions_2_1::glTexCoord3sv(const GLshort *v)
2231{
2232 d_1_0_Deprecated->f.TexCoord3sv(v);
2233}
2234
2235inline void QOpenGLFunctions_2_1::glTexCoord3s(GLshort s, GLshort t, GLshort r)
2236{
2237 d_1_0_Deprecated->f.TexCoord3s(s, t, r);
2238}
2239
2241{
2242 d_1_0_Deprecated->f.TexCoord3iv(v);
2243}
2244
2246{
2247 d_1_0_Deprecated->f.TexCoord3i(s, t, r);
2248}
2249
2251{
2252 d_1_0_Deprecated->f.TexCoord3fv(v);
2253}
2254
2256{
2257 d_1_0_Deprecated->f.TexCoord3f(s, t, r);
2258}
2259
2261{
2262 d_1_0_Deprecated->f.TexCoord3dv(v);
2263}
2264
2266{
2267 d_1_0_Deprecated->f.TexCoord3d(s, t, r);
2268}
2269
2270inline void QOpenGLFunctions_2_1::glTexCoord2sv(const GLshort *v)
2271{
2272 d_1_0_Deprecated->f.TexCoord2sv(v);
2273}
2274
2275inline void QOpenGLFunctions_2_1::glTexCoord2s(GLshort s, GLshort t)
2276{
2277 d_1_0_Deprecated->f.TexCoord2s(s, t);
2278}
2279
2281{
2282 d_1_0_Deprecated->f.TexCoord2iv(v);
2283}
2284
2286{
2287 d_1_0_Deprecated->f.TexCoord2i(s, t);
2288}
2289
2291{
2292 d_1_0_Deprecated->f.TexCoord2fv(v);
2293}
2294
2296{
2297 d_1_0_Deprecated->f.TexCoord2f(s, t);
2298}
2299
2301{
2302 d_1_0_Deprecated->f.TexCoord2dv(v);
2303}
2304
2306{
2307 d_1_0_Deprecated->f.TexCoord2d(s, t);
2308}
2309
2310inline void QOpenGLFunctions_2_1::glTexCoord1sv(const GLshort *v)
2311{
2312 d_1_0_Deprecated->f.TexCoord1sv(v);
2313}
2314
2316{
2317 d_1_0_Deprecated->f.TexCoord1s(s);
2318}
2319
2321{
2322 d_1_0_Deprecated->f.TexCoord1iv(v);
2323}
2324
2326{
2327 d_1_0_Deprecated->f.TexCoord1i(s);
2328}
2329
2331{
2332 d_1_0_Deprecated->f.TexCoord1fv(v);
2333}
2334
2336{
2337 d_1_0_Deprecated->f.TexCoord1f(s);
2338}
2339
2341{
2342 d_1_0_Deprecated->f.TexCoord1dv(v);
2343}
2344
2346{
2347 d_1_0_Deprecated->f.TexCoord1d(s);
2348}
2349
2350inline void QOpenGLFunctions_2_1::glRectsv(const GLshort *v1, const GLshort *v2)
2351{
2352 d_1_0_Deprecated->f.Rectsv(v1, v2);
2353}
2354
2355inline void QOpenGLFunctions_2_1::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
2356{
2357 d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
2358}
2359
2361{
2362 d_1_0_Deprecated->f.Rectiv(v1, v2);
2363}
2364
2366{
2367 d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
2368}
2369
2371{
2372 d_1_0_Deprecated->f.Rectfv(v1, v2);
2373}
2374
2376{
2377 d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
2378}
2379
2381{
2382 d_1_0_Deprecated->f.Rectdv(v1, v2);
2383}
2384
2386{
2387 d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
2388}
2389
2390inline void QOpenGLFunctions_2_1::glRasterPos4sv(const GLshort *v)
2391{
2392 d_1_0_Deprecated->f.RasterPos4sv(v);
2393}
2394
2395inline void QOpenGLFunctions_2_1::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
2396{
2397 d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
2398}
2399
2401{
2402 d_1_0_Deprecated->f.RasterPos4iv(v);
2403}
2404
2406{
2407 d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
2408}
2409
2411{
2412 d_1_0_Deprecated->f.RasterPos4fv(v);
2413}
2414
2416{
2417 d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
2418}
2419
2421{
2422 d_1_0_Deprecated->f.RasterPos4dv(v);
2423}
2424
2426{
2427 d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
2428}
2429
2430inline void QOpenGLFunctions_2_1::glRasterPos3sv(const GLshort *v)
2431{
2432 d_1_0_Deprecated->f.RasterPos3sv(v);
2433}
2434
2435inline void QOpenGLFunctions_2_1::glRasterPos3s(GLshort x, GLshort y, GLshort z)
2436{
2437 d_1_0_Deprecated->f.RasterPos3s(x, y, z);
2438}
2439
2441{
2442 d_1_0_Deprecated->f.RasterPos3iv(v);
2443}
2444
2446{
2447 d_1_0_Deprecated->f.RasterPos3i(x, y, z);
2448}
2449
2451{
2452 d_1_0_Deprecated->f.RasterPos3fv(v);
2453}
2454
2456{
2457 d_1_0_Deprecated->f.RasterPos3f(x, y, z);
2458}
2459
2461{
2462 d_1_0_Deprecated->f.RasterPos3dv(v);
2463}
2464
2466{
2467 d_1_0_Deprecated->f.RasterPos3d(x, y, z);
2468}
2469
2470inline void QOpenGLFunctions_2_1::glRasterPos2sv(const GLshort *v)
2471{
2472 d_1_0_Deprecated->f.RasterPos2sv(v);
2473}
2474
2475inline void QOpenGLFunctions_2_1::glRasterPos2s(GLshort x, GLshort y)
2476{
2477 d_1_0_Deprecated->f.RasterPos2s(x, y);
2478}
2479
2481{
2482 d_1_0_Deprecated->f.RasterPos2iv(v);
2483}
2484
2486{
2487 d_1_0_Deprecated->f.RasterPos2i(x, y);
2488}
2489
2491{
2492 d_1_0_Deprecated->f.RasterPos2fv(v);
2493}
2494
2496{
2497 d_1_0_Deprecated->f.RasterPos2f(x, y);
2498}
2499
2501{
2502 d_1_0_Deprecated->f.RasterPos2dv(v);
2503}
2504
2506{
2507 d_1_0_Deprecated->f.RasterPos2d(x, y);
2508}
2509
2510inline void QOpenGLFunctions_2_1::glNormal3sv(const GLshort *v)
2511{
2512 d_1_0_Deprecated->f.Normal3sv(v);
2513}
2514
2515inline void QOpenGLFunctions_2_1::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
2516{
2517 d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
2518}
2519
2521{
2522 d_1_0_Deprecated->f.Normal3iv(v);
2523}
2524
2526{
2527 d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
2528}
2529
2531{
2532 d_1_0_Deprecated->f.Normal3fv(v);
2533}
2534
2536{
2537 d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
2538}
2539
2541{
2542 d_1_0_Deprecated->f.Normal3dv(v);
2543}
2544
2546{
2547 d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
2548}
2549
2550inline void QOpenGLFunctions_2_1::glNormal3bv(const GLbyte *v)
2551{
2552 d_1_0_Deprecated->f.Normal3bv(v);
2553}
2554
2555inline void QOpenGLFunctions_2_1::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
2556{
2557 d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
2558}
2559
2560inline void QOpenGLFunctions_2_1::glIndexsv(const GLshort *c)
2561{
2562 d_1_0_Deprecated->f.Indexsv(c);
2563}
2564
2566{
2567 d_1_0_Deprecated->f.Indexs(c);
2568}
2569
2571{
2572 d_1_0_Deprecated->f.Indexiv(c);
2573}
2574
2576{
2577 d_1_0_Deprecated->f.Indexi(c);
2578}
2579
2581{
2582 d_1_0_Deprecated->f.Indexfv(c);
2583}
2584
2586{
2587 d_1_0_Deprecated->f.Indexf(c);
2588}
2589
2591{
2592 d_1_0_Deprecated->f.Indexdv(c);
2593}
2594
2596{
2597 d_1_0_Deprecated->f.Indexd(c);
2598}
2599
2601{
2602 d_1_0_Deprecated->f.End();
2603}
2604
2606{
2607 d_1_0_Deprecated->f.EdgeFlagv(flag);
2608}
2609
2611{
2612 d_1_0_Deprecated->f.EdgeFlag(flag);
2613}
2614
2616{
2617 d_1_0_Deprecated->f.Color4usv(v);
2618}
2619
2621{
2622 d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
2623}
2624
2626{
2627 d_1_0_Deprecated->f.Color4uiv(v);
2628}
2629
2631{
2632 d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
2633}
2634
2635inline void QOpenGLFunctions_2_1::glColor4ubv(const GLubyte *v)
2636{
2637 d_1_0_Deprecated->f.Color4ubv(v);
2638}
2639
2640inline void QOpenGLFunctions_2_1::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
2641{
2642 d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
2643}
2644
2645inline void QOpenGLFunctions_2_1::glColor4sv(const GLshort *v)
2646{
2647 d_1_0_Deprecated->f.Color4sv(v);
2648}
2649
2650inline void QOpenGLFunctions_2_1::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
2651{
2652 d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
2653}
2654
2656{
2657 d_1_0_Deprecated->f.Color4iv(v);
2658}
2659
2661{
2662 d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
2663}
2664
2666{
2667 d_1_0_Deprecated->f.Color4fv(v);
2668}
2669
2671{
2672 d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
2673}
2674
2676{
2677 d_1_0_Deprecated->f.Color4dv(v);
2678}
2679
2681{
2682 d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
2683}
2684
2685inline void QOpenGLFunctions_2_1::glColor4bv(const GLbyte *v)
2686{
2687 d_1_0_Deprecated->f.Color4bv(v);
2688}
2689
2690inline void QOpenGLFunctions_2_1::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
2691{
2692 d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
2693}
2694
2696{
2697 d_1_0_Deprecated->f.Color3usv(v);
2698}
2699
2701{
2702 d_1_0_Deprecated->f.Color3us(red, green, blue);
2703}
2704
2706{
2707 d_1_0_Deprecated->f.Color3uiv(v);
2708}
2709
2711{
2712 d_1_0_Deprecated->f.Color3ui(red, green, blue);
2713}
2714
2715inline void QOpenGLFunctions_2_1::glColor3ubv(const GLubyte *v)
2716{
2717 d_1_0_Deprecated->f.Color3ubv(v);
2718}
2719
2720inline void QOpenGLFunctions_2_1::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
2721{
2722 d_1_0_Deprecated->f.Color3ub(red, green, blue);
2723}
2724
2725inline void QOpenGLFunctions_2_1::glColor3sv(const GLshort *v)
2726{
2727 d_1_0_Deprecated->f.Color3sv(v);
2728}
2729
2730inline void QOpenGLFunctions_2_1::glColor3s(GLshort red, GLshort green, GLshort blue)
2731{
2732 d_1_0_Deprecated->f.Color3s(red, green, blue);
2733}
2734
2736{
2737 d_1_0_Deprecated->f.Color3iv(v);
2738}
2739
2741{
2742 d_1_0_Deprecated->f.Color3i(red, green, blue);
2743}
2744
2746{
2747 d_1_0_Deprecated->f.Color3fv(v);
2748}
2749
2751{
2752 d_1_0_Deprecated->f.Color3f(red, green, blue);
2753}
2754
2756{
2757 d_1_0_Deprecated->f.Color3dv(v);
2758}
2759
2761{
2762 d_1_0_Deprecated->f.Color3d(red, green, blue);
2763}
2764
2765inline void QOpenGLFunctions_2_1::glColor3bv(const GLbyte *v)
2766{
2767 d_1_0_Deprecated->f.Color3bv(v);
2768}
2769
2770inline void QOpenGLFunctions_2_1::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
2771{
2772 d_1_0_Deprecated->f.Color3b(red, green, blue);
2773}
2774
2776{
2777 d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
2778}
2779
2781{
2782 d_1_0_Deprecated->f.Begin(mode);
2783}
2784
2786{
2787 d_1_0_Deprecated->f.ListBase(base);
2788}
2789
2791{
2792 return d_1_0_Deprecated->f.GenLists(range);
2793}
2794
2796{
2797 d_1_0_Deprecated->f.DeleteLists(list, range);
2798}
2799
2801{
2802 d_1_0_Deprecated->f.CallLists(n, type, lists);
2803}
2804
2806{
2807 d_1_0_Deprecated->f.CallList(list);
2808}
2809
2811{
2812 d_1_0_Deprecated->f.EndList();
2813}
2814
2816{
2817 d_1_0_Deprecated->f.NewList(list, mode);
2818}
2819
2820
2821// OpenGL 1.1 deprecated functions
2823{
2824 d_1_1_Deprecated->f.PushClientAttrib(mask);
2825}
2826
2828{
2829 d_1_1_Deprecated->f.PopClientAttrib();
2830}
2831
2833{
2834 d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
2835}
2836
2838{
2839 return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
2840}
2841
2843{
2844 d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
2845}
2846
2848{
2849 d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
2850}
2851
2853{
2854 d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
2855}
2856
2858{
2859 d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
2860}
2861
2863{
2864 d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
2865}
2866
2868{
2869 d_1_1_Deprecated->f.EnableClientState(array);
2870}
2871
2873{
2874 d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
2875}
2876
2878{
2879 d_1_1_Deprecated->f.DisableClientState(array);
2880}
2881
2883{
2884 d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
2885}
2886
2888{
2889 d_1_1_Deprecated->f.ArrayElement(i);
2890}
2891
2892
2893// OpenGL 1.2 deprecated functions
2895{
2896 d_1_2_Deprecated->f.ResetMinmax(target);
2897}
2898
2900{
2901 d_1_2_Deprecated->f.ResetHistogram(target);
2902}
2903
2905{
2906 d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
2907}
2908
2913
2915{
2916 d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
2917}
2918
2920{
2921 d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
2922}
2923
2925{
2926 d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
2927}
2928
2930{
2931 d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
2932}
2933
2935{
2936 d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
2937}
2938
2940{
2941 d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
2942}
2943
2945{
2946 d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
2947}
2948
2950{
2951 d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
2952}
2953
2955{
2956 d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
2957}
2958
2960{
2961 d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
2962}
2963
2965{
2966 d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
2967}
2968
2970{
2971 d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
2972}
2973
2975{
2976 d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
2977}
2978
2980{
2981 d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
2982}
2983
2985{
2986 d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
2987}
2988
2990{
2991 d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
2992}
2993
2995{
2996 d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
2997}
2998
3000{
3001 d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
3002}
3003
3005{
3006 d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
3007}
3008
3010{
3011 d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
3012}
3013
3015{
3016 d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
3017}
3018
3020{
3021 d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
3022}
3023
3025{
3026 d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
3027}
3028
3030{
3031 d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
3032}
3033
3035{
3036 d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
3037}
3038
3040{
3041 d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
3042}
3043
3045{
3046 d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
3047}
3048
3050{
3051 d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
3052}
3053
3054
3055// OpenGL 1.3 deprecated functions
3057{
3058 d_1_3_Deprecated->f.MultTransposeMatrixd(m);
3059}
3060
3062{
3063 d_1_3_Deprecated->f.MultTransposeMatrixf(m);
3064}
3065
3067{
3068 d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
3069}
3070
3072{
3073 d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
3074}
3075
3077{
3078 d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
3079}
3080
3081inline void QOpenGLFunctions_2_1::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
3082{
3083 d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
3084}
3085
3087{
3088 d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
3089}
3090
3092{
3093 d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
3094}
3095
3097{
3098 d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
3099}
3100
3102{
3103 d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
3104}
3105
3107{
3108 d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
3109}
3110
3112{
3113 d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
3114}
3115
3117{
3118 d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
3119}
3120
3121inline void QOpenGLFunctions_2_1::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
3122{
3123 d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
3124}
3125
3127{
3128 d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
3129}
3130
3132{
3133 d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
3134}
3135
3137{
3138 d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
3139}
3140
3142{
3143 d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
3144}
3145
3147{
3148 d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
3149}
3150
3152{
3153 d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
3154}
3155
3157{
3158 d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
3159}
3160
3162{
3163 d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
3164}
3165
3167{
3168 d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
3169}
3170
3172{
3173 d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
3174}
3175
3177{
3178 d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
3179}
3180
3182{
3183 d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
3184}
3185
3187{
3188 d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
3189}
3190
3192{
3193 d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
3194}
3195
3197{
3198 d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
3199}
3200
3202{
3203 d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
3204}
3205
3207{
3208 d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
3209}
3210
3212{
3213 d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
3214}
3215
3217{
3218 d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
3219}
3220
3222{
3223 d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
3224}
3225
3227{
3228 d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
3229}
3230
3232{
3233 d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
3234}
3235
3237{
3238 d_1_3_Deprecated->f.ClientActiveTexture(texture);
3239}
3240
3241
3242// OpenGL 1.4 deprecated functions
3243inline void QOpenGLFunctions_2_1::glWindowPos3sv(const GLshort *v)
3244{
3245 d_1_4_Deprecated->f.WindowPos3sv(v);
3246}
3247
3248inline void QOpenGLFunctions_2_1::glWindowPos3s(GLshort x, GLshort y, GLshort z)
3249{
3250 d_1_4_Deprecated->f.WindowPos3s(x, y, z);
3251}
3252
3254{
3255 d_1_4_Deprecated->f.WindowPos3iv(v);
3256}
3257
3259{
3260 d_1_4_Deprecated->f.WindowPos3i(x, y, z);
3261}
3262
3264{
3265 d_1_4_Deprecated->f.WindowPos3fv(v);
3266}
3267
3269{
3270 d_1_4_Deprecated->f.WindowPos3f(x, y, z);
3271}
3272
3274{
3275 d_1_4_Deprecated->f.WindowPos3dv(v);
3276}
3277
3279{
3280 d_1_4_Deprecated->f.WindowPos3d(x, y, z);
3281}
3282
3283inline void QOpenGLFunctions_2_1::glWindowPos2sv(const GLshort *v)
3284{
3285 d_1_4_Deprecated->f.WindowPos2sv(v);
3286}
3287
3288inline void QOpenGLFunctions_2_1::glWindowPos2s(GLshort x, GLshort y)
3289{
3290 d_1_4_Deprecated->f.WindowPos2s(x, y);
3291}
3292
3294{
3295 d_1_4_Deprecated->f.WindowPos2iv(v);
3296}
3297
3299{
3300 d_1_4_Deprecated->f.WindowPos2i(x, y);
3301}
3302
3304{
3305 d_1_4_Deprecated->f.WindowPos2fv(v);
3306}
3307
3309{
3310 d_1_4_Deprecated->f.WindowPos2f(x, y);
3311}
3312
3314{
3315 d_1_4_Deprecated->f.WindowPos2dv(v);
3316}
3317
3319{
3320 d_1_4_Deprecated->f.WindowPos2d(x, y);
3321}
3322
3324{
3325 d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
3326}
3327
3329{
3330 d_1_4_Deprecated->f.SecondaryColor3usv(v);
3331}
3332
3334{
3335 d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
3336}
3337
3339{
3340 d_1_4_Deprecated->f.SecondaryColor3uiv(v);
3341}
3342
3344{
3345 d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
3346}
3347
3349{
3350 d_1_4_Deprecated->f.SecondaryColor3ubv(v);
3351}
3352
3353inline void QOpenGLFunctions_2_1::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
3354{
3355 d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
3356}
3357
3359{
3360 d_1_4_Deprecated->f.SecondaryColor3sv(v);
3361}
3362
3363inline void QOpenGLFunctions_2_1::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
3364{
3365 d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
3366}
3367
3369{
3370 d_1_4_Deprecated->f.SecondaryColor3iv(v);
3371}
3372
3374{
3375 d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
3376}
3377
3379{
3380 d_1_4_Deprecated->f.SecondaryColor3fv(v);
3381}
3382
3384{
3385 d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
3386}
3387
3389{
3390 d_1_4_Deprecated->f.SecondaryColor3dv(v);
3391}
3392
3394{
3395 d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
3396}
3397
3399{
3400 d_1_4_Deprecated->f.SecondaryColor3bv(v);
3401}
3402
3403inline void QOpenGLFunctions_2_1::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
3404{
3405 d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
3406}
3407
3409{
3410 d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
3411}
3412
3414{
3415 d_1_4_Deprecated->f.FogCoorddv(coord);
3416}
3417
3419{
3420 d_1_4_Deprecated->f.FogCoordd(coord);
3421}
3422
3424{
3425 d_1_4_Deprecated->f.FogCoordfv(coord);
3426}
3427
3429{
3430 d_1_4_Deprecated->f.FogCoordf(coord);
3431}
3432
3433
3434// OpenGL 1.5 deprecated functions
3435
3436// OpenGL 2.0 deprecated functions
3438{
3439 d_2_0_Core->f.VertexAttrib4usv(index, v);
3440}
3441
3443{
3444 d_2_0_Core->f.VertexAttrib4uiv(index, v);
3445}
3446
3448{
3449 d_2_0_Core->f.VertexAttrib4ubv(index, v);
3450}
3451
3453{
3454 d_2_0_Core->f.VertexAttrib4sv(index, v);
3455}
3456
3457inline void QOpenGLFunctions_2_1::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
3458{
3459 d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
3460}
3461
3463{
3464 d_2_0_Core->f.VertexAttrib4iv(index, v);
3465}
3466
3468{
3469 d_2_0_Core->f.VertexAttrib4fv(index, v);
3470}
3471
3473{
3474 d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
3475}
3476
3478{
3479 d_2_0_Core->f.VertexAttrib4dv(index, v);
3480}
3481
3483{
3484 d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
3485}
3486
3488{
3489 d_2_0_Core->f.VertexAttrib4bv(index, v);
3490}
3491
3493{
3494 d_2_0_Core->f.VertexAttrib4Nusv(index, v);
3495}
3496
3498{
3499 d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
3500}
3501
3503{
3504 d_2_0_Core->f.VertexAttrib4Nubv(index, v);
3505}
3506
3507inline void QOpenGLFunctions_2_1::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
3508{
3509 d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
3510}
3511
3513{
3514 d_2_0_Core->f.VertexAttrib4Nsv(index, v);
3515}
3516
3518{
3519 d_2_0_Core->f.VertexAttrib4Niv(index, v);
3520}
3521
3523{
3524 d_2_0_Core->f.VertexAttrib4Nbv(index, v);
3525}
3526
3528{
3529 d_2_0_Core->f.VertexAttrib3sv(index, v);
3530}
3531
3532inline void QOpenGLFunctions_2_1::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
3533{
3534 d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
3535}
3536
3538{
3539 d_2_0_Core->f.VertexAttrib3fv(index, v);
3540}
3541
3543{
3544 d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
3545}
3546
3548{
3549 d_2_0_Core->f.VertexAttrib3dv(index, v);
3550}
3551
3553{
3554 d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
3555}
3556
3558{
3559 d_2_0_Core->f.VertexAttrib2sv(index, v);
3560}
3561
3563{
3564 d_2_0_Core->f.VertexAttrib2s(index, x, y);
3565}
3566
3568{
3569 d_2_0_Core->f.VertexAttrib2fv(index, v);
3570}
3571
3573{
3574 d_2_0_Core->f.VertexAttrib2f(index, x, y);
3575}
3576
3578{
3579 d_2_0_Core->f.VertexAttrib2dv(index, v);
3580}
3581
3583{
3584 d_2_0_Core->f.VertexAttrib2d(index, x, y);
3585}
3586
3588{
3589 d_2_0_Core->f.VertexAttrib1sv(index, v);
3590}
3591
3593{
3594 d_2_0_Core->f.VertexAttrib1s(index, x);
3595}
3596
3598{
3599 d_2_0_Core->f.VertexAttrib1fv(index, v);
3600}
3601
3603{
3604 d_2_0_Core->f.VertexAttrib1f(index, x);
3605}
3606
3608{
3609 d_2_0_Core->f.VertexAttrib1dv(index, v);
3610}
3611
3613{
3614 d_2_0_Core->f.VertexAttrib1d(index, x);
3615}
3616
3617
3618// OpenGL 2.1 deprecated functions
3619
3620
3622
3623#endif // QT_NO_OPENGL && !QT_CONFIG(opengles2)
3624
3625#endif
quint16 opcode
Definition bluez_data_p.h:1
\inmodule QtGui
void glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
void glRasterPos4iv(const GLint *v)
void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
void glMultiTexCoord3fv(GLenum target, const GLfloat *v)
void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
void glMultTransposeMatrixf(const GLfloat *m)
void glVertex2fv(const GLfloat *v)
void glVertexAttrib3dv(GLuint index, const GLdouble *v)
void glSecondaryColor3uiv(const GLuint *v)
void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
void glVertexAttrib3sv(GLuint index, const GLshort *v)
void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
void glVertexAttrib1s(GLuint index, GLshort x)
void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
void glTexCoord2fv(const GLfloat *v)
void glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
void glRectfv(const GLfloat *v1, const GLfloat *v2)
void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
void glAlphaFunc(GLenum func, GLfloat ref)
void glPointParameteriv(GLenum pname, const GLint *params)
void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
void glColor3bv(const GLbyte *v)
void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
void glPointParameterf(GLenum pname, GLfloat param)
void glSampleCoverage(GLfloat value, GLboolean invert)
void glIndexdv(const GLdouble *c)
void glRasterPos4dv(const GLdouble *v)
void glResetHistogram(GLenum target)
void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
void glLoadMatrixd(const GLdouble *m)
void glGetBooleanv(GLenum pname, GLboolean *params)
void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
void glColor4uiv(const GLuint *v)
void glWindowPos3sv(const GLshort *v)
void glTexCoord4iv(const GLint *v)
void glWindowPos2s(GLshort x, GLshort y)
void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
void glPixelTransferi(GLenum pname, GLint param)
void glMultMatrixd(const GLdouble *m)
void glUniform2iv(GLint location, GLsizei count, const GLint *value)
void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
void glMultiTexCoord1i(GLenum target, GLint s)
void glWindowPos2d(GLdouble x, GLdouble y)
void glVertexAttrib4Nusv(GLuint index, const GLushort *v)
void glGetPolygonStipple(GLubyte *mask)
void glGetMapfv(GLenum target, GLenum query, GLfloat *v)
void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glRasterPos2iv(const GLint *v)
void glVertex4dv(const GLdouble *v)
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
void glMultiTexCoord2dv(GLenum target, const GLdouble *v)
void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
void glMultiTexCoord1sv(GLenum target, const GLshort *v)
void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
void glNormal3sv(const GLshort *v)
void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
void glDepthMask(GLboolean flag)
void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
void glSecondaryColor3i(GLint red, GLint green, GLint blue)
void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
void glColor4sv(const GLshort *v)
void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
void glCompileShader(GLuint shader)
void glTexCoord2s(GLshort s, GLshort t)
void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
void glColor4dv(const GLdouble *v)
void glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
void glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
void glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
void glFogCoordd(GLdouble coord)
void glDeleteProgram(GLuint program)
void glActiveTexture(GLenum texture)
void glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
void glMultiTexCoord4dv(GLenum target, const GLdouble *v)
GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
void glSecondaryColor3iv(const GLint *v)
void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
void glWindowPos3dv(const GLdouble *v)
void glSecondaryColor3dv(const GLdouble *v)
void glMaterialiv(GLenum face, GLenum pname, const GLint *params)
void glVertexAttrib1d(GLuint index, GLdouble x)
void glTexCoord2d(GLdouble s, GLdouble t)
void glColor3dv(const GLdouble *v)
void glEvalMesh1(GLenum mode, GLint i1, GLint i2)
void glColor3sv(const GLshort *v)
void glGetFloatv(GLenum pname, GLfloat *params)
void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
void glPixelStoref(GLenum pname, GLfloat param)
void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid *const *indices, GLsizei drawcount)
void glTexCoord2iv(const GLint *v)
void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
void glWindowPos3iv(const GLint *v)
void glAccum(GLenum op, GLfloat value)
void glColorMaterial(GLenum face, GLenum mode)
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
void glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
void glEdgeFlag(GLboolean flag)
void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
void glMultiTexCoord2fv(GLenum target, const GLfloat *v)
void glSecondaryColor3sv(const GLshort *v)
void glNormal3fv(const GLfloat *v)
void glTexCoord3fv(const GLfloat *v)
void glColor3iv(const GLint *v)
void glVertexAttrib4bv(GLuint index, const GLbyte *v)
void glScaled(GLdouble x, GLdouble y, GLdouble z)
void glNormal3bv(const GLbyte *v)
void glFogf(GLenum pname, GLfloat param)
void glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
void glPassThrough(GLfloat token)
void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
void glVertex3iv(const GLint *v)
void glUniform1f(GLint location, GLfloat v0)
GLuint glCreateShader(GLenum type)
void glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
void glReadBuffer(GLenum mode)
void glVertexAttrib2dv(GLuint index, const GLdouble *v)
void glVertexAttrib4Nsv(GLuint index, const GLshort *v)
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
void glTexGend(GLenum coord, GLenum pname, GLdouble param)
void glWindowPos3s(GLshort x, GLshort y, GLshort z)
void glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
void glLoadTransposeMatrixf(const GLfloat *m)
void glUniform3iv(GLint location, GLsizei count, const GLint *value)
void glColor3ui(GLuint red, GLuint green, GLuint blue)
void glVertexAttrib1sv(GLuint index, const GLshort *v)
void glTexCoord3dv(const GLdouble *v)
void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
void glVertexAttrib3fv(GLuint index, const GLfloat *v)
void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
void glDisableClientState(GLenum array)
void glStencilMaskSeparate(GLenum face, GLuint mask)
void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
void glMultiTexCoord2iv(GLenum target, const GLint *v)
void glUniform1iv(GLint location, GLsizei count, const GLint *value)
void glTexCoord3i(GLint s, GLint t, GLint r)
void glRasterPos2f(GLfloat x, GLfloat y)
void glEvalCoord1dv(const GLdouble *u)
void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
void glEnableVertexAttribArray(GLuint index)
void glRasterPos2dv(const GLdouble *v)
void glTexCoord1fv(const GLfloat *v)
void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
void glRasterPos3iv(const GLint *v)
void glVertexAttrib1f(GLuint index, GLfloat x)
GLboolean glIsShader(GLuint shader)
void glPointSize(GLfloat size)
void glDeleteLists(GLuint list, GLsizei range)
void glLightModelf(GLenum pname, GLfloat param)
void glVertexAttrib4sv(GLuint index, const GLshort *v)
void glTexGenf(GLenum coord, GLenum pname, GLfloat param)
void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
void glWindowPos2fv(const GLfloat *v)
void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
void glTexCoord1sv(const GLshort *v)
void glSecondaryColor3usv(const GLushort *v)
void glTexCoord2i(GLint s, GLint t)
void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
void glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
void glVertexAttrib4iv(GLuint index, const GLint *v)
void glPolygonMode(GLenum face, GLenum mode)
void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
void glPixelZoom(GLfloat xfactor, GLfloat yfactor)
void glMultiTexCoord2sv(GLenum target, const GLshort *v)
void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
void glGetClipPlane(GLenum plane, GLdouble *equation)
void glColor3b(GLbyte red, GLbyte green, GLbyte blue)
void glRasterPos2sv(const GLshort *v)
void glVertexAttrib2fv(GLuint index, const GLfloat *v)
const GLubyte * glGetString(GLenum name)
void glLightiv(GLenum light, GLenum pname, const GLint *params)
void glDrawBuffers(GLsizei n, const GLenum *bufs)
void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
void glGetPointerv(GLenum pname, GLvoid **params)
void glStencilFunc(GLenum func, GLint ref, GLuint mask)
void glAttachShader(GLuint program, GLuint shader)
void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
void glRasterPos2d(GLdouble x, GLdouble y)
void glTexCoord3s(GLshort s, GLshort t, GLshort r)
void glMultiTexCoord1fv(GLenum target, const GLfloat *v)
void glWindowPos2dv(const GLdouble *v)
void glLighti(GLenum light, GLenum pname, GLint param)
void glRectiv(const GLint *v1, const GLint *v2)
void glColor4usv(const GLushort *v)
void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
void glClearDepth(GLdouble depth)
void glUniform1i(GLint location, GLint v0)
void glColor3fv(const GLfloat *v)
void glColor4bv(const GLbyte *v)
void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
void glIndexMask(GLuint mask)
void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
void glVertexAttrib4fv(GLuint index, const GLfloat *v)
GLuint glGenLists(GLsizei range)
void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
void glPushClientAttrib(GLbitfield mask)
void glEdgeFlagv(const GLboolean *flag)
void glBindTexture(GLenum target, GLuint texture)
GLboolean glIsProgram(GLuint program)
void glNormal3s(GLshort nx, GLshort ny, GLshort nz)
void glIndexfv(const GLfloat *c)
void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
void glShadeModel(GLenum mode)
void glEnableClientState(GLenum array)
void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glColor4fv(const GLfloat *v)
void glVertex2iv(const GLint *v)
void glColor3uiv(const GLuint *v)
GLboolean glIsList(GLuint list)
void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
void glEvalCoord2d(GLdouble u, GLdouble v)
void glDeleteQueries(GLsizei n, const GLuint *ids)
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
void glFogi(GLenum pname, GLint param)
void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
GLboolean glIsEnabled(GLenum cap)
void glSecondaryColor3fv(const GLfloat *v)
void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
void glGetUniformfv(GLuint program, GLint location, GLfloat *params)
void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
void glTexEnviv(GLenum target, GLenum pname, const GLint *params)
void glRasterPos3i(GLint x, GLint y, GLint z)
void glTexCoord4fv(const GLfloat *v)
void glGetIntegerv(GLenum pname, GLint *params)
void glColor3ubv(const GLubyte *v)
void glPixelTransferf(GLenum pname, GLfloat param)
void glNormal3iv(const GLint *v)
void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
void glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
void glRasterPos3fv(const GLfloat *v)
void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
void glVertexAttrib4usv(GLuint index, const GLushort *v)
void glMultiTexCoord3iv(GLenum target, const GLint *v)
void glVertex4i(GLint x, GLint y, GLint z, GLint w)
void glPushAttrib(GLbitfield mask)
void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
void glIndexubv(const GLubyte *c)
void glBeginQuery(GLenum target, GLuint id)
void glVertex3d(GLdouble x, GLdouble y, GLdouble z)
void glGetUniformiv(GLuint program, GLint location, GLint *params)
void glWindowPos2i(GLint x, GLint y)
void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
void glVertexAttrib4uiv(GLuint index, const GLuint *v)
void glRasterPos2fv(const GLfloat *v)
void glBlendEquation(GLenum mode)
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
void glClear(GLbitfield mask)
void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
void glRasterPos3s(GLshort x, GLshort y, GLshort z)
void glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
void glGetLightiv(GLenum light, GLenum pname, GLint *params)
void glNewList(GLuint list, GLenum mode)
void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
void glHint(GLenum target, GLenum mode)
void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
void glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
void glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
void glGetMapiv(GLenum target, GLenum query, GLint *v)
void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glFogCoordfv(const GLfloat *coord)
void glVertexAttrib4ubv(GLuint index, const GLubyte *v)
void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glTexCoord2f(GLfloat s, GLfloat t)
void glBindBuffer(GLenum target, GLuint buffer)
void glFogfv(GLenum pname, const GLfloat *params)
void glVertex3fv(const GLfloat *v)
void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
void glFrontFace(GLenum mode)
void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
void glTexEnvi(GLenum target, GLenum pname, GLint param)
void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
void glVertex2f(GLfloat x, GLfloat y)
void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
void glPolygonStipple(const GLubyte *mask)
void glMultiTexCoord4sv(GLenum target, const GLshort *v)
void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
void glLinkProgram(GLuint program)
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
void glRasterPos2s(GLshort x, GLshort y)
void glMultMatrixf(const GLfloat *m)
void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
void glMultTransposeMatrixd(const GLdouble *m)
void glColor4ubv(const GLubyte *v)
void glTexGeni(GLenum coord, GLenum pname, GLint param)
void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
void glDepthRange(GLdouble nearVal, GLdouble farVal)
void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glGetPixelMapfv(GLenum map, GLfloat *values)
void glRectdv(const GLdouble *v1, const GLdouble *v2)
void glFogiv(GLenum pname, const GLint *params)
void glVertex3dv(const GLdouble *v)
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
void glVertexAttrib1dv(GLuint index, const GLdouble *v)
void glColor3f(GLfloat red, GLfloat green, GLfloat blue)
void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
GLboolean glIsTexture(GLuint texture)
GLboolean glIsQuery(GLuint id)
void glVertexAttrib4dv(GLuint index, const GLdouble *v)
void glTexCoord2dv(const GLdouble *v)
void glVertex3sv(const GLshort *v)
void glGenBuffers(GLsizei n, GLuint *buffers)
void glVertex3s(GLshort x, GLshort y, GLshort z)
void glEvalCoord2f(GLfloat u, GLfloat v)
void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
void glVertex4iv(const GLint *v)
void glEvalPoint2(GLint i, GLint j)
void glDeleteTextures(GLsizei n, const GLuint *textures)
void glColor3i(GLint red, GLint green, GLint blue)
void glMateriali(GLenum face, GLenum pname, GLint param)
void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
void glTexCoord1iv(const GLint *v)
void glVertex2d(GLdouble x, GLdouble y)
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
void glMultiTexCoord1dv(GLenum target, const GLdouble *v)
void glGetQueryiv(GLenum target, GLenum pname, GLint *params)
void glLightModelfv(GLenum pname, const GLfloat *params)
void glIndexiv(const GLint *c)
void glFogCoorddv(const GLdouble *coord)
void glVertexAttrib2sv(GLuint index, const GLshort *v)
void glTexCoord4sv(const GLshort *v)
void glGetPixelMapusv(GLenum map, GLushort *values)
void glVertex2dv(const GLdouble *v)
void glLoadMatrixf(const GLfloat *m)
void glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
void glVertexAttrib1fv(GLuint index, const GLfloat *v)
void glValidateProgram(GLuint program)
void glIndexsv(const GLshort *c)
void glVertex2i(GLint x, GLint y)
void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
void glLightModeli(GLenum pname, GLint param)
void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
void glVertex2sv(const GLshort *v)
void glClientActiveTexture(GLenum texture)
void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glGetProgramiv(GLuint program, GLenum pname, GLint *params)
void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
void glDeleteBuffers(GLsizei n, const GLuint *buffers)
void glRasterPos2i(GLint x, GLint y)
GLint glRenderMode(GLenum mode)
void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
GLvoid * glMapBuffer(GLenum target, GLenum access)
void glLogicOp(GLenum opcode)
void glMultiTexCoord2i(GLenum target, GLint s, GLint t)
void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
void glVertexAttrib4Niv(GLuint index, const GLint *v)
void glNormal3i(GLint nx, GLint ny, GLint nz)
void glTexCoord1dv(const GLdouble *v)
void glGetDoublev(GLenum pname, GLdouble *params)
void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer)
GLint glGetAttribLocation(GLuint program, const GLchar *name)
void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
void glResetMinmax(GLenum target)
void glMultiTexCoord3dv(GLenum target, const GLdouble *v)
void glMultiTexCoord1s(GLenum target, GLshort s)
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
void glStencilMask(GLuint mask)
void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
GLint glGetUniformLocation(GLuint program, const GLchar *name)
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
void glWindowPos2iv(const GLint *v)
void glDeleteShader(GLuint shader)
void glColor3us(GLushort red, GLushort green, GLushort blue)
void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glTexCoord4dv(const GLdouble *v)
void glColor3usv(const GLushort *v)
void glPolygonOffset(GLfloat factor, GLfloat units)
void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
void glRasterPos3dv(const GLdouble *v)
void glDetachShader(GLuint program, GLuint shader)
void glEvalCoord2fv(const GLfloat *u)
void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glTexCoord2sv(const GLshort *v)
void glRasterPos4sv(const GLshort *v)
void glLightf(GLenum light, GLenum pname, GLfloat param)
void glWindowPos2f(GLfloat x, GLfloat y)
void glDrawBuffer(GLenum mode)
void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
void glEndQuery(GLenum target)
void glPointParameteri(GLenum pname, GLint param)
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
void glMultiTexCoord1iv(GLenum target, const GLint *v)
void glVertex3i(GLint x, GLint y, GLint z)
void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
GLboolean glUnmapBuffer(GLenum target)
void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glVertex4fv(const GLfloat *v)
void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glRasterPos4fv(const GLfloat *v)
void glNormal3dv(const GLdouble *v)
void glLineStipple(GLint factor, GLushort pattern)
void glColor3d(GLdouble red, GLdouble green, GLdouble blue)
void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
void glGetPixelMapuiv(GLenum map, GLuint *values)
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
void glLightfv(GLenum light, GLenum pname, const GLfloat *params)
void glMatrixMode(GLenum mode)
void glUseProgram(GLuint program)
void glTranslated(GLdouble x, GLdouble y, GLdouble z)
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
void glWindowPos2sv(const GLshort *v)
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
void glVertex4sv(const GLshort *v)
void glBlendFunc(GLenum sfactor, GLenum dfactor)
void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
void glColor3s(GLshort red, GLshort green, GLshort blue)
void glRectsv(const GLshort *v1, const GLshort *v2)
void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
void glCullFace(GLenum mode)
void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glVertex3f(GLfloat x, GLfloat y, GLfloat z)
void glPointParameterfv(GLenum pname, const GLfloat *params)
void glEvalCoord1fv(const GLfloat *u)
void glGetMapdv(GLenum target, GLenum query, GLdouble *v)
void glVertex2s(GLshort x, GLshort y)
void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
void glSelectBuffer(GLsizei size, GLuint *buffer)
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
void glWindowPos3fv(const GLfloat *v)
void glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
void glColor4iv(const GLint *v)
GLboolean glIsBuffer(GLuint buffer)
void glLoadTransposeMatrixd(const GLdouble *m)
void glUniform4iv(GLint location, GLsizei count, const GLint *value)
void glEvalCoord2dv(const GLdouble *u)
void glMultiTexCoord4fv(GLenum target, const GLfloat *v)
void glSecondaryColor3ubv(const GLubyte *v)
void glMultiTexCoord4iv(GLenum target, const GLint *v)
void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
void glTexParameteri(GLenum target, GLenum pname, GLint param)
void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glPixelStorei(GLenum pname, GLint param)
void glTexCoord3iv(const GLint *v)
void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
void glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
void glUniform2i(GLint location, GLint v0, GLint v1)
void glTexCoord3sv(const GLshort *v)
void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
void glClipPlane(GLenum plane, const GLdouble *equation)
void glFogCoordf(GLfloat coord)
void glMultiTexCoord1f(GLenum target, GLfloat s)
void glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
void glSecondaryColor3bv(const GLbyte *v)
void glUniform2f(GLint location, GLfloat v0, GLfloat v1)
void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glLightModeliv(GLenum pname, const GLint *params)
void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
void glDisableVertexAttribArray(GLuint index)
void glLineWidth(GLfloat width)
void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
void glRasterPos3sv(const GLshort *v)
void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glWindowPos3i(GLint x, GLint y, GLint z)
void glGenQueries(GLsizei n, GLuint *ids)
void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glScalef(GLfloat x, GLfloat y, GLfloat z)
void glDrawArrays(GLenum mode, GLint first, GLsizei count)
void glDepthFunc(GLenum func)
void glGenTextures(GLsizei n, GLuint *textures)
void glMultiTexCoord1d(GLenum target, GLdouble s)
void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
void glMaterialf(GLenum face, GLenum pname, GLfloat param)
void glMultiTexCoord3sv(GLenum target, const GLshort *v)
void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
QMap< QString, QString > map
[6]
Token token
Definition keywords.cpp:444
Combined button and popup list for selecting options.
Definition image.cpp:4
static void * context
#define Q_DECL_UNUSED_MEMBER
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
ptrdiff_t GLintptr
Definition qopengl.h:163
ptrdiff_t GLsizeiptr
Definition qopengl.h:164
char GLchar
Definition qopengl.h:158
GLenum modeRGB
GLint location
GLenum GLenum modeAlpha
GLint GLfloat GLfloat GLfloat v2
GLenum GLsizei GLsizei GLint * values
[15]
typedef GLint(GL_APIENTRYP PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC)(GLuint program
GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar
GLsizei const GLfloat * v
[13]
GLdouble GLdouble GLdouble GLdouble GLdouble zNear
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat z
GLint GLint GLint GLint GLint x
[0]
GLuint const GLuint * buffers
GLint GLenum GLsizei GLsizei GLsizei depth
typedef GLfloat(GL_APIENTRYP PFNGLGETPATHLENGTHNVPROC)(GLuint path
GLenum mode
const GLfloat * m
GLenum GLuint GLint level
GLfloat GLfloat GLfloat w
[0]
GLint GLsizei GLsizei height
GLuint GLfloat GLfloat GLfloat GLfloat y1
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLuint index
[2]
GLboolean r
[2]
GLuint GLuint end
GLenum GLenum GLsizei const GLuint * ids
GLuint const GLuint GLuint const GLuint * textures
GLuint GLfloat GLfloat GLfloat x1
double GLdouble
GLenum GLuint GLenum GLsizei length
GLdouble GLdouble GLdouble GLdouble top
GLenum GLenum GLsizei count
const GLenum * bufs
GLenum pname
GLdouble GLdouble right
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
GLint GLenum GLsizei GLsizei GLsizei GLint border
GLsizei GLsizei GLchar * infoLog
GLenum face
GLsizei range
const void GLsizei GLsizei stride
GLenum GLuint buffer
GLint GLint GLint yoffset
GLint GLsizei width
GLint GLint GLint GLint zoffset
GLint GLsizei GLboolean transpose
GLint left
typedef GLsizei(GL_APIENTRYP PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)(GLuint target)
GLenum type
GLint GLint bottom
GLfloat angle
typedef GLenum(GL_APIENTRYP PFNGLGETGRAPHICSRESETSTATUSKHRPROC)(void)
GLenum access
GLint GLfloat v0
GLenum target
GLint GLfloat GLfloat v1
GLenum GLuint texture
GLuint program
GLint GLenum internalformat
GLfloat units
GLint GLint xoffset
typedef GLboolean(GL_APIENTRYP PFNGLISENABLEDIOESPROC)(GLenum target
GLuint start
GLenum const GLint * param
GLenum GLuint GLintptr offset
GLint GLfloat GLfloat GLfloat GLfloat v3
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum const void * pixels
GLint ref
GLuint name
GLint first
GLsizei bufSize
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
GLfloat n
GLint GLsizei GLsizei GLenum format
const void GLsizei drawcount
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei imageSize
GLsizei GLenum const void * indices
GLint y
GLsizei GLsizei GLchar * source
void ** params
GLenum GLenum GLsizei void GLsizei void * column
GLenum GLenum GLenum dfactorAlpha
Definition qopenglext.h:373
GLfixed GLfixed GLint GLint GLfixed points
GLhandleARB obj
[2]
GLdouble s
[6]
Definition qopenglext.h:235
GLboolean reset
GLenum query
GLenum GLenum sfactorAlpha
Definition qopenglext.h:373
GLfixed GLfixed nz
GLbyte GLbyte blue
Definition qopenglext.h:385
GLenum func
Definition qopenglext.h:663
const GLuint GLboolean * residences
GLfixed GLfixed u2
GLbyte nx
const GLubyte * c
GLfixed GLfixed GLfixed y2
GLfixed GLfixed GLint ustride
GLint void * img
Definition qopenglext.h:233
const GLfixed * equation
const GLuint const GLfixed * priorities
GLuint coord
GLfixed ny
GLenum array
GLuint shader
Definition qopenglext.h:665
GLfixed GLfixed GLint GLint GLfixed GLfixed GLint vstride
GLsizei GLfixed GLfixed GLfixed GLfixed const GLubyte * bitmap
GLenum sfail
Definition qopenglext.h:662
GLsizei GLfixed GLfixed yorig
typedef GLbitfield(APIENTRYP PFNGLQUERYMATRIXXOESPROC)(GLfixed *mantissa
GLsizei maxCount
Definition qopenglext.h:677
GLfixed GLfixed x2
GLdouble GLdouble t
Definition qopenglext.h:243
GLfixed yfactor
GLsizei GLfixed xorig
GLsizei GLfixed GLfixed GLfixed xmove
GLsizei GLfixed GLfixed GLfixed GLfixed ymove
GLfixed GLfixed GLint GLint GLfixed GLfixed GLint GLint vorder
GLsizei const void * pointer
Definition qopenglext.h:384
GLdouble GLdouble GLdouble GLdouble q
Definition qopenglext.h:259
GLenum GLenum GLsizei void * row
GLenum GLenum GLsizei void GLsizei void void * span
GLsizei GLenum GLboolean sink
GLint GLenum GLboolean normalized
Definition qopenglext.h:752
GLfixed u1
GLfixed GLfixed GLint GLint uorder
GLfloat GLfloat GLfloat alpha
Definition qopenglext.h:418
GLbyte green
Definition qopenglext.h:385
GLenum GLenum GLenum dppass
Definition qopenglext.h:662
GLfixed GLfixed GLint GLint order
GLenum dfactorRGB
Definition qopenglext.h:373
GLubyte * pattern
typedef GLushort(APIENTRYP PFNGLGETSTAGEINDEXNVPROC)(GLenum shadertype)
GLenum cap
GLenum GLenum GLsizei void * table
GLuint * lists
GLenum GLenum dpfail
Definition qopenglext.h:662
GLsizeiptr const void GLenum usage
Definition qopenglext.h:543
GLboolean invert
Definition qopenglext.h:226
#define GLuint
static const uint base
Definition qurlidna.cpp:20
QList< int > list
[14]
QGraphicsSvgItem * red