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_0.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_0_H
16#define QOPENGLVERSIONFUNCTIONS_2_0_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_0 : 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 1.0 deprecated functions
213 void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
214 void glTranslated(GLdouble x, GLdouble y, GLdouble z);
215 void glScalef(GLfloat x, GLfloat y, GLfloat z);
216 void glScaled(GLdouble x, GLdouble y, GLdouble z);
217 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
218 void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
219 void glPushMatrix();
220 void glPopMatrix();
222 void glMultMatrixd(const GLdouble *m);
223 void glMultMatrixf(const GLfloat *m);
224 void glMatrixMode(GLenum mode);
225 void glLoadMatrixd(const GLdouble *m);
226 void glLoadMatrixf(const GLfloat *m);
227 void glLoadIdentity();
229 GLboolean glIsList(GLuint list);
230 void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
231 void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
232 void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
233 void glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
234 void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
235 void glGetPolygonStipple(GLubyte *mask);
236 void glGetPixelMapusv(GLenum map, GLushort *values);
237 void glGetPixelMapuiv(GLenum map, GLuint *values);
238 void glGetPixelMapfv(GLenum map, GLfloat *values);
239 void glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
240 void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
241 void glGetMapiv(GLenum target, GLenum query, GLint *v);
242 void glGetMapfv(GLenum target, GLenum query, GLfloat *v);
243 void glGetMapdv(GLenum target, GLenum query, GLdouble *v);
244 void glGetLightiv(GLenum light, GLenum pname, GLint *params);
245 void glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
246 void glGetClipPlane(GLenum plane, GLdouble *equation);
247 void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
248 void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
249 void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
250 void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
251 void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
252 void glPixelTransferi(GLenum pname, GLint param);
253 void glPixelTransferf(GLenum pname, GLfloat param);
254 void glPixelZoom(GLfloat xfactor, GLfloat yfactor);
255 void glAlphaFunc(GLenum func, GLfloat ref);
256 void glEvalPoint2(GLint i, GLint j);
257 void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
258 void glEvalPoint1(GLint i);
259 void glEvalMesh1(GLenum mode, GLint i1, GLint i2);
260 void glEvalCoord2fv(const GLfloat *u);
261 void glEvalCoord2f(GLfloat u, GLfloat v);
262 void glEvalCoord2dv(const GLdouble *u);
263 void glEvalCoord2d(GLdouble u, GLdouble v);
264 void glEvalCoord1fv(const GLfloat *u);
265 void glEvalCoord1f(GLfloat u);
266 void glEvalCoord1dv(const GLdouble *u);
267 void glEvalCoord1d(GLdouble u);
268 void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
269 void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
270 void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
271 void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
274 void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
276 void glPushAttrib(GLbitfield mask);
277 void glPopAttrib();
278 void glAccum(GLenum op, GLfloat value);
279 void glIndexMask(GLuint mask);
280 void glClearIndex(GLfloat c);
281 void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
282 void glPushName(GLuint name);
283 void glPopName();
284 void glPassThrough(GLfloat token);
285 void glLoadName(GLuint name);
286 void glInitNames();
287 GLint glRenderMode(GLenum mode);
288 void glSelectBuffer(GLsizei size, GLuint *buffer);
289 void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
290 void glTexGeniv(GLenum coord, GLenum pname, const GLint *params);
291 void glTexGeni(GLenum coord, GLenum pname, GLint param);
292 void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
293 void glTexGenf(GLenum coord, GLenum pname, GLfloat param);
294 void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
295 void glTexGend(GLenum coord, GLenum pname, GLdouble param);
296 void glTexEnviv(GLenum target, GLenum pname, const GLint *params);
297 void glTexEnvi(GLenum target, GLenum pname, GLint param);
298 void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
299 void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
300 void glShadeModel(GLenum mode);
301 void glPolygonStipple(const GLubyte *mask);
302 void glMaterialiv(GLenum face, GLenum pname, const GLint *params);
303 void glMateriali(GLenum face, GLenum pname, GLint param);
304 void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
305 void glMaterialf(GLenum face, GLenum pname, GLfloat param);
306 void glLineStipple(GLint factor, GLushort pattern);
307 void glLightModeliv(GLenum pname, const GLint *params);
308 void glLightModeli(GLenum pname, GLint param);
309 void glLightModelfv(GLenum pname, const GLfloat *params);
310 void glLightModelf(GLenum pname, GLfloat param);
311 void glLightiv(GLenum light, GLenum pname, const GLint *params);
312 void glLighti(GLenum light, GLenum pname, GLint param);
313 void glLightfv(GLenum light, GLenum pname, const GLfloat *params);
314 void glLightf(GLenum light, GLenum pname, GLfloat param);
315 void glFogiv(GLenum pname, const GLint *params);
316 void glFogi(GLenum pname, GLint param);
317 void glFogfv(GLenum pname, const GLfloat *params);
318 void glFogf(GLenum pname, GLfloat param);
319 void glColorMaterial(GLenum face, GLenum mode);
320 void glClipPlane(GLenum plane, const GLdouble *equation);
321 void glVertex4sv(const GLshort *v);
322 void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
323 void glVertex4iv(const GLint *v);
324 void glVertex4i(GLint x, GLint y, GLint z, GLint w);
325 void glVertex4fv(const GLfloat *v);
326 void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
327 void glVertex4dv(const GLdouble *v);
328 void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
329 void glVertex3sv(const GLshort *v);
330 void glVertex3s(GLshort x, GLshort y, GLshort z);
331 void glVertex3iv(const GLint *v);
332 void glVertex3i(GLint x, GLint y, GLint z);
333 void glVertex3fv(const GLfloat *v);
334 void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
335 void glVertex3dv(const GLdouble *v);
336 void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
337 void glVertex2sv(const GLshort *v);
338 void glVertex2s(GLshort x, GLshort y);
339 void glVertex2iv(const GLint *v);
340 void glVertex2i(GLint x, GLint y);
341 void glVertex2fv(const GLfloat *v);
342 void glVertex2f(GLfloat x, GLfloat y);
343 void glVertex2dv(const GLdouble *v);
344 void glVertex2d(GLdouble x, GLdouble y);
345 void glTexCoord4sv(const GLshort *v);
346 void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
347 void glTexCoord4iv(const GLint *v);
348 void glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
349 void glTexCoord4fv(const GLfloat *v);
350 void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
351 void glTexCoord4dv(const GLdouble *v);
352 void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
353 void glTexCoord3sv(const GLshort *v);
354 void glTexCoord3s(GLshort s, GLshort t, GLshort r);
355 void glTexCoord3iv(const GLint *v);
356 void glTexCoord3i(GLint s, GLint t, GLint r);
357 void glTexCoord3fv(const GLfloat *v);
358 void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
359 void glTexCoord3dv(const GLdouble *v);
360 void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
361 void glTexCoord2sv(const GLshort *v);
362 void glTexCoord2s(GLshort s, GLshort t);
363 void glTexCoord2iv(const GLint *v);
364 void glTexCoord2i(GLint s, GLint t);
365 void glTexCoord2fv(const GLfloat *v);
366 void glTexCoord2f(GLfloat s, GLfloat t);
367 void glTexCoord2dv(const GLdouble *v);
368 void glTexCoord2d(GLdouble s, GLdouble t);
369 void glTexCoord1sv(const GLshort *v);
370 void glTexCoord1s(GLshort s);
371 void glTexCoord1iv(const GLint *v);
372 void glTexCoord1i(GLint s);
373 void glTexCoord1fv(const GLfloat *v);
374 void glTexCoord1f(GLfloat s);
375 void glTexCoord1dv(const GLdouble *v);
376 void glTexCoord1d(GLdouble s);
377 void glRectsv(const GLshort *v1, const GLshort *v2);
378 void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
379 void glRectiv(const GLint *v1, const GLint *v2);
380 void glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
381 void glRectfv(const GLfloat *v1, const GLfloat *v2);
382 void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
383 void glRectdv(const GLdouble *v1, const GLdouble *v2);
384 void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
385 void glRasterPos4sv(const GLshort *v);
386 void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
387 void glRasterPos4iv(const GLint *v);
388 void glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
389 void glRasterPos4fv(const GLfloat *v);
390 void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
391 void glRasterPos4dv(const GLdouble *v);
392 void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
393 void glRasterPos3sv(const GLshort *v);
394 void glRasterPos3s(GLshort x, GLshort y, GLshort z);
395 void glRasterPos3iv(const GLint *v);
396 void glRasterPos3i(GLint x, GLint y, GLint z);
397 void glRasterPos3fv(const GLfloat *v);
398 void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
399 void glRasterPos3dv(const GLdouble *v);
400 void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
401 void glRasterPos2sv(const GLshort *v);
402 void glRasterPos2s(GLshort x, GLshort y);
403 void glRasterPos2iv(const GLint *v);
404 void glRasterPos2i(GLint x, GLint y);
405 void glRasterPos2fv(const GLfloat *v);
406 void glRasterPos2f(GLfloat x, GLfloat y);
407 void glRasterPos2dv(const GLdouble *v);
408 void glRasterPos2d(GLdouble x, GLdouble y);
409 void glNormal3sv(const GLshort *v);
410 void glNormal3s(GLshort nx, GLshort ny, GLshort nz);
411 void glNormal3iv(const GLint *v);
412 void glNormal3i(GLint nx, GLint ny, GLint nz);
413 void glNormal3fv(const GLfloat *v);
414 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
415 void glNormal3dv(const GLdouble *v);
416 void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
417 void glNormal3bv(const GLbyte *v);
418 void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
419 void glIndexsv(const GLshort *c);
420 void glIndexs(GLshort c);
421 void glIndexiv(const GLint *c);
422 void glIndexi(GLint c);
423 void glIndexfv(const GLfloat *c);
424 void glIndexf(GLfloat c);
425 void glIndexdv(const GLdouble *c);
426 void glIndexd(GLdouble c);
427 void glEnd();
428 void glEdgeFlagv(const GLboolean *flag);
429 void glEdgeFlag(GLboolean flag);
430 void glColor4usv(const GLushort *v);
431 void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
432 void glColor4uiv(const GLuint *v);
433 void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
434 void glColor4ubv(const GLubyte *v);
435 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
436 void glColor4sv(const GLshort *v);
437 void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
438 void glColor4iv(const GLint *v);
439 void glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
440 void glColor4fv(const GLfloat *v);
441 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
442 void glColor4dv(const GLdouble *v);
444 void glColor4bv(const GLbyte *v);
445 void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
446 void glColor3usv(const GLushort *v);
447 void glColor3us(GLushort red, GLushort green, GLushort blue);
448 void glColor3uiv(const GLuint *v);
449 void glColor3ui(GLuint red, GLuint green, GLuint blue);
450 void glColor3ubv(const GLubyte *v);
451 void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
452 void glColor3sv(const GLshort *v);
453 void glColor3s(GLshort red, GLshort green, GLshort blue);
454 void glColor3iv(const GLint *v);
455 void glColor3i(GLint red, GLint green, GLint blue);
456 void glColor3fv(const GLfloat *v);
457 void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
458 void glColor3dv(const GLdouble *v);
459 void glColor3d(GLdouble red, GLdouble green, GLdouble blue);
460 void glColor3bv(const GLbyte *v);
461 void glColor3b(GLbyte red, GLbyte green, GLbyte blue);
462 void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
463 void glBegin(GLenum mode);
464 void glListBase(GLuint base);
465 GLuint glGenLists(GLsizei range);
466 void glDeleteLists(GLuint list, GLsizei range);
467 void glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
468 void glCallList(GLuint list);
469 void glEndList();
470 void glNewList(GLuint list, GLenum mode);
471
472 // OpenGL 1.1 deprecated functions
473 void glPushClientAttrib(GLbitfield mask);
474 void glPopClientAttrib();
475 void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities);
476 GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
477 void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
478 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
479 void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
480 void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
481 void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
482 void glEnableClientState(GLenum array);
483 void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
484 void glDisableClientState(GLenum array);
485 void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
486 void glArrayElement(GLint i);
487
488 // OpenGL 1.2 deprecated functions
489 void glResetMinmax(GLenum target);
490 void glResetHistogram(GLenum target);
493 void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
494 void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
495 void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
496 void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
497 void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
498 void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
499 void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
500 void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
501 void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
502 void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
503 void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
504 void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
505 void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
506 void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
507 void glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
508 void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
509 void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
510 void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
511 void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
512 void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
513 void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
514 void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
515 void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
516 void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
517 void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
518 void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);
519 void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);
520 void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
521
522 // OpenGL 1.3 deprecated functions
523 void glMultTransposeMatrixd(const GLdouble *m);
524 void glMultTransposeMatrixf(const GLfloat *m);
525 void glLoadTransposeMatrixd(const GLdouble *m);
526 void glLoadTransposeMatrixf(const GLfloat *m);
527 void glMultiTexCoord4sv(GLenum target, const GLshort *v);
528 void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
529 void glMultiTexCoord4iv(GLenum target, const GLint *v);
530 void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q);
531 void glMultiTexCoord4fv(GLenum target, const GLfloat *v);
532 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
533 void glMultiTexCoord4dv(GLenum target, const GLdouble *v);
534 void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
535 void glMultiTexCoord3sv(GLenum target, const GLshort *v);
536 void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);
537 void glMultiTexCoord3iv(GLenum target, const GLint *v);
538 void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);
539 void glMultiTexCoord3fv(GLenum target, const GLfloat *v);
540 void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);
541 void glMultiTexCoord3dv(GLenum target, const GLdouble *v);
542 void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);
543 void glMultiTexCoord2sv(GLenum target, const GLshort *v);
544 void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);
545 void glMultiTexCoord2iv(GLenum target, const GLint *v);
546 void glMultiTexCoord2i(GLenum target, GLint s, GLint t);
547 void glMultiTexCoord2fv(GLenum target, const GLfloat *v);
548 void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
549 void glMultiTexCoord2dv(GLenum target, const GLdouble *v);
550 void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);
551 void glMultiTexCoord1sv(GLenum target, const GLshort *v);
552 void glMultiTexCoord1s(GLenum target, GLshort s);
553 void glMultiTexCoord1iv(GLenum target, const GLint *v);
554 void glMultiTexCoord1i(GLenum target, GLint s);
555 void glMultiTexCoord1fv(GLenum target, const GLfloat *v);
556 void glMultiTexCoord1f(GLenum target, GLfloat s);
557 void glMultiTexCoord1dv(GLenum target, const GLdouble *v);
558 void glMultiTexCoord1d(GLenum target, GLdouble s);
559 void glClientActiveTexture(GLenum texture);
560
561 // OpenGL 1.4 deprecated functions
562 void glWindowPos3sv(const GLshort *v);
563 void glWindowPos3s(GLshort x, GLshort y, GLshort z);
564 void glWindowPos3iv(const GLint *v);
565 void glWindowPos3i(GLint x, GLint y, GLint z);
566 void glWindowPos3fv(const GLfloat *v);
567 void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);
568 void glWindowPos3dv(const GLdouble *v);
569 void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);
570 void glWindowPos2sv(const GLshort *v);
571 void glWindowPos2s(GLshort x, GLshort y);
572 void glWindowPos2iv(const GLint *v);
573 void glWindowPos2i(GLint x, GLint y);
574 void glWindowPos2fv(const GLfloat *v);
575 void glWindowPos2f(GLfloat x, GLfloat y);
576 void glWindowPos2dv(const GLdouble *v);
577 void glWindowPos2d(GLdouble x, GLdouble y);
578 void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
579 void glSecondaryColor3usv(const GLushort *v);
580 void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
581 void glSecondaryColor3uiv(const GLuint *v);
582 void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
583 void glSecondaryColor3ubv(const GLubyte *v);
584 void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
585 void glSecondaryColor3sv(const GLshort *v);
586 void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
587 void glSecondaryColor3iv(const GLint *v);
588 void glSecondaryColor3i(GLint red, GLint green, GLint blue);
589 void glSecondaryColor3fv(const GLfloat *v);
590 void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
591 void glSecondaryColor3dv(const GLdouble *v);
592 void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
593 void glSecondaryColor3bv(const GLbyte *v);
594 void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
595 void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
596 void glFogCoorddv(const GLdouble *coord);
597 void glFogCoordd(GLdouble coord);
598 void glFogCoordfv(const GLfloat *coord);
599 void glFogCoordf(GLfloat coord);
600
601 // OpenGL 1.5 deprecated functions
602
603 // OpenGL 2.0 deprecated functions
604 void glVertexAttrib4usv(GLuint index, const GLushort *v);
605 void glVertexAttrib4uiv(GLuint index, const GLuint *v);
606 void glVertexAttrib4ubv(GLuint index, const GLubyte *v);
607 void glVertexAttrib4sv(GLuint index, const GLshort *v);
608 void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
609 void glVertexAttrib4iv(GLuint index, const GLint *v);
610 void glVertexAttrib4fv(GLuint index, const GLfloat *v);
611 void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
612 void glVertexAttrib4dv(GLuint index, const GLdouble *v);
613 void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
614 void glVertexAttrib4bv(GLuint index, const GLbyte *v);
615 void glVertexAttrib4Nusv(GLuint index, const GLushort *v);
616 void glVertexAttrib4Nuiv(GLuint index, const GLuint *v);
617 void glVertexAttrib4Nubv(GLuint index, const GLubyte *v);
618 void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
619 void glVertexAttrib4Nsv(GLuint index, const GLshort *v);
620 void glVertexAttrib4Niv(GLuint index, const GLint *v);
621 void glVertexAttrib4Nbv(GLuint index, const GLbyte *v);
622 void glVertexAttrib3sv(GLuint index, const GLshort *v);
623 void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
624 void glVertexAttrib3fv(GLuint index, const GLfloat *v);
625 void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
626 void glVertexAttrib3dv(GLuint index, const GLdouble *v);
627 void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
628 void glVertexAttrib2sv(GLuint index, const GLshort *v);
629 void glVertexAttrib2s(GLuint index, GLshort x, GLshort y);
630 void glVertexAttrib2fv(GLuint index, const GLfloat *v);
631 void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
632 void glVertexAttrib2dv(GLuint index, const GLdouble *v);
633 void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
634 void glVertexAttrib1sv(GLuint index, const GLshort *v);
635 void glVertexAttrib1s(GLuint index, GLshort x);
636 void glVertexAttrib1fv(GLuint index, const GLfloat *v);
637 void glVertexAttrib1f(GLuint index, GLfloat x);
638 void glVertexAttrib1dv(GLuint index, const GLdouble *v);
639 void glVertexAttrib1d(GLuint index, GLdouble x);
640
641private:
643
644 static bool isContextCompatible(QOpenGLContext *context);
645 static QOpenGLVersionProfile versionProfile();
646
659 Q_DECL_UNUSED_MEMBER void *m_reserved_2_0_Deprecated = nullptr; // To maintain BC
660};
661
662// OpenGL 1.0 core functions
664{
665 d_1_0_Core->f.Viewport(x, y, width, height);
666}
667
669{
670 d_1_0_Core->f.DepthRange(nearVal, farVal);
671}
672
674{
675 return d_1_0_Core->f.IsEnabled(cap);
676}
677
679{
680 d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
681}
682
684{
685 d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
686}
687
689{
690 d_1_0_Core->f.GetTexParameteriv(target, pname, params);
691}
692
694{
695 d_1_0_Core->f.GetTexParameterfv(target, pname, params);
696}
697
699{
700 d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
701}
702
704{
705 return d_1_0_Core->f.GetString(name);
706}
707
709{
710 d_1_0_Core->f.GetIntegerv(pname, params);
711}
712
714{
715 d_1_0_Core->f.GetFloatv(pname, params);
716}
717
719{
720 return d_1_0_Core->f.GetError();
721}
722
724{
725 d_1_0_Core->f.GetDoublev(pname, params);
726}
727
729{
730 d_1_0_Core->f.GetBooleanv(pname, params);
731}
732
734{
735 d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
736}
737
739{
740 d_1_0_Core->f.ReadBuffer(mode);
741}
742
744{
745 d_1_0_Core->f.PixelStorei(pname, param);
746}
747
749{
750 d_1_0_Core->f.PixelStoref(pname, param);
751}
752
754{
755 d_1_0_Core->f.DepthFunc(func);
756}
757
759{
760 d_1_0_Core->f.StencilOp(fail, zfail, zpass);
761}
762
764{
765 d_1_0_Core->f.StencilFunc(func, ref, mask);
766}
767
769{
770 d_1_0_Core->f.LogicOp(opcode);
771}
772
774{
775 d_1_0_Core->f.BlendFunc(sfactor, dfactor);
776}
777
779{
780 d_1_0_Core->f.Flush();
781}
782
784{
785 d_1_0_Core->f.Finish();
786}
787
789{
790 d_1_0_Core->f.Enable(cap);
791}
792
794{
795 d_1_0_Core->f.Disable(cap);
796}
797
799{
800 d_1_0_Core->f.DepthMask(flag);
801}
802
804{
805 d_1_0_Core->f.ColorMask(red, green, blue, alpha);
806}
807
809{
810 d_1_0_Core->f.StencilMask(mask);
811}
812
814{
815 d_1_0_Core->f.ClearDepth(depth);
816}
817
819{
820 d_1_0_Core->f.ClearStencil(s);
821}
822
824{
825 d_1_0_Core->f.ClearColor(red, green, blue, alpha);
826}
827
829{
830 d_1_0_Core->f.Clear(mask);
831}
832
834{
835 d_1_0_Core->f.DrawBuffer(mode);
836}
837
842
847
849{
850 d_1_0_Core->f.TexParameteriv(target, pname, params);
851}
852
854{
855 d_1_0_Core->f.TexParameteri(target, pname, param);
856}
857
859{
860 d_1_0_Core->f.TexParameterfv(target, pname, params);
861}
862
864{
865 d_1_0_Core->f.TexParameterf(target, pname, param);
866}
867
869{
870 d_1_0_Core->f.Scissor(x, y, width, height);
871}
872
874{
875 d_1_0_Core->f.PolygonMode(face, mode);
876}
877
879{
880 d_1_0_Core->f.PointSize(size);
881}
882
884{
885 d_1_0_Core->f.LineWidth(width);
886}
887
889{
890 d_1_0_Core->f.Hint(target, mode);
891}
892
894{
895 d_1_0_Core->f.FrontFace(mode);
896}
897
899{
900 d_1_0_Core->f.CullFace(mode);
901}
902
903
904// OpenGL 1.1 core functions
905inline void QOpenGLFunctions_2_0::glIndexubv(const GLubyte *c)
906{
907 d_1_1_Deprecated->f.Indexubv(c);
908}
909
911{
912 d_1_1_Deprecated->f.Indexub(c);
913}
914
916{
917 return d_1_1_Core->f.IsTexture(texture);
918}
919
921{
922 d_1_1_Core->f.GenTextures(n, textures);
923}
924
926{
927 d_1_1_Core->f.DeleteTextures(n, textures);
928}
929
931{
932 d_1_1_Core->f.BindTexture(target, texture);
933}
934
939
941{
942 d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
943}
944
949
951{
952 d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
953}
954
959
964
966{
967 d_1_1_Core->f.PolygonOffset(factor, units);
968}
969
971{
972 d_1_1_Deprecated->f.GetPointerv(pname, params);
973}
974
976{
977 d_1_1_Core->f.DrawElements(mode, count, type, indices);
978}
979
981{
982 d_1_1_Core->f.DrawArrays(mode, first, count);
983}
984
985
986// OpenGL 1.2 core functions
991
996
1001
1003{
1004 d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
1005}
1006
1008{
1009 d_1_2_Core->f.BlendEquation(mode);
1010}
1011
1013{
1014 d_1_2_Core->f.BlendColor(red, green, blue, alpha);
1015}
1016
1017
1018// OpenGL 1.3 core functions
1020{
1021 d_1_3_Core->f.GetCompressedTexImage(target, level, img);
1022}
1023
1025{
1026 d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
1027}
1028
1033
1038
1043
1048
1053
1055{
1056 d_1_3_Core->f.SampleCoverage(value, invert);
1057}
1058
1060{
1061 d_1_3_Core->f.ActiveTexture(texture);
1062}
1063
1064
1065// OpenGL 1.4 core functions
1067{
1068 d_1_4_Core->f.PointParameteriv(pname, params);
1069}
1070
1072{
1073 d_1_4_Core->f.PointParameteri(pname, param);
1074}
1075
1077{
1078 d_1_4_Core->f.PointParameterfv(pname, params);
1079}
1080
1082{
1083 d_1_4_Core->f.PointParameterf(pname, param);
1084}
1085
1087{
1088 d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
1089}
1090
1092{
1093 d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
1094}
1095
1097{
1098 d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
1099}
1100
1101
1102// OpenGL 1.5 core functions
1104{
1105 d_1_5_Core->f.GetBufferPointerv(target, pname, params);
1106}
1107
1109{
1110 d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
1111}
1112
1114{
1115 return d_1_5_Core->f.UnmapBuffer(target);
1116}
1117
1119{
1120 return d_1_5_Core->f.MapBuffer(target, access);
1121}
1122
1124{
1125 d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
1126}
1127
1129{
1130 d_1_5_Core->f.BufferSubData(target, offset, size, data);
1131}
1132
1134{
1135 d_1_5_Core->f.BufferData(target, size, data, usage);
1136}
1137
1139{
1140 return d_1_5_Core->f.IsBuffer(buffer);
1141}
1142
1144{
1145 d_1_5_Core->f.GenBuffers(n, buffers);
1146}
1147
1149{
1150 d_1_5_Core->f.DeleteBuffers(n, buffers);
1151}
1152
1154{
1155 d_1_5_Core->f.BindBuffer(target, buffer);
1156}
1157
1159{
1160 d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
1161}
1162
1164{
1165 d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
1166}
1167
1169{
1170 d_1_5_Core->f.GetQueryiv(target, pname, params);
1171}
1172
1174{
1175 d_1_5_Core->f.EndQuery(target);
1176}
1177
1179{
1180 d_1_5_Core->f.BeginQuery(target, id);
1181}
1182
1184{
1185 return d_1_5_Core->f.IsQuery(id);
1186}
1187
1189{
1190 d_1_5_Core->f.DeleteQueries(n, ids);
1191}
1192
1194{
1195 d_1_5_Core->f.GenQueries(n, ids);
1196}
1197
1198
1199// OpenGL 2.0 core functions
1201{
1202 d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
1203}
1204
1206{
1207 d_2_0_Core->f.ValidateProgram(program);
1208}
1209
1211{
1212 d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
1213}
1214
1216{
1217 d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
1218}
1219
1221{
1222 d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
1223}
1224
1226{
1227 d_2_0_Core->f.Uniform4iv(location, count, value);
1228}
1229
1231{
1232 d_2_0_Core->f.Uniform3iv(location, count, value);
1233}
1234
1236{
1237 d_2_0_Core->f.Uniform2iv(location, count, value);
1238}
1239
1241{
1242 d_2_0_Core->f.Uniform1iv(location, count, value);
1243}
1244
1246{
1247 d_2_0_Core->f.Uniform4fv(location, count, value);
1248}
1249
1251{
1252 d_2_0_Core->f.Uniform3fv(location, count, value);
1253}
1254
1256{
1257 d_2_0_Core->f.Uniform2fv(location, count, value);
1258}
1259
1261{
1262 d_2_0_Core->f.Uniform1fv(location, count, value);
1263}
1264
1266{
1267 d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
1268}
1269
1271{
1272 d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
1273}
1274
1276{
1277 d_2_0_Core->f.Uniform2i(location, v0, v1);
1278}
1279
1281{
1282 d_2_0_Core->f.Uniform1i(location, v0);
1283}
1284
1286{
1287 d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
1288}
1289
1291{
1292 d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
1293}
1294
1296{
1297 d_2_0_Core->f.Uniform2f(location, v0, v1);
1298}
1299
1301{
1302 d_2_0_Core->f.Uniform1f(location, v0);
1303}
1304
1306{
1307 d_2_0_Core->f.UseProgram(program);
1308}
1309
1311{
1312 d_2_0_Core->f.ShaderSource(shader, count, string, length);
1313}
1314
1316{
1317 d_2_0_Core->f.LinkProgram(program);
1318}
1319
1321{
1322 return d_2_0_Core->f.IsShader(shader);
1323}
1324
1326{
1327 return d_2_0_Core->f.IsProgram(program);
1328}
1329
1331{
1332 d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
1333}
1334
1336{
1337 d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
1338}
1339
1341{
1342 d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
1343}
1344
1346{
1347 d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
1348}
1349
1351{
1352 d_2_0_Core->f.GetUniformiv(program, location, params);
1353}
1354
1356{
1357 d_2_0_Core->f.GetUniformfv(program, location, params);
1358}
1359
1361{
1362 return d_2_0_Core->f.GetUniformLocation(program, name);
1363}
1364
1366{
1367 d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
1368}
1369
1371{
1372 d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
1373}
1374
1376{
1377 d_2_0_Core->f.GetShaderiv(shader, pname, params);
1378}
1379
1381{
1382 d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
1383}
1384
1386{
1387 d_2_0_Core->f.GetProgramiv(program, pname, params);
1388}
1389
1391{
1392 return d_2_0_Core->f.GetAttribLocation(program, name);
1393}
1394
1396{
1397 d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
1398}
1399
1404
1409
1411{
1412 d_2_0_Core->f.EnableVertexAttribArray(index);
1413}
1414
1416{
1417 d_2_0_Core->f.DisableVertexAttribArray(index);
1418}
1419
1421{
1422 d_2_0_Core->f.DetachShader(program, shader);
1423}
1424
1426{
1427 d_2_0_Core->f.DeleteShader(shader);
1428}
1429
1431{
1432 d_2_0_Core->f.DeleteProgram(program);
1433}
1434
1436{
1437 return d_2_0_Core->f.CreateShader(type);
1438}
1439
1441{
1442 return d_2_0_Core->f.CreateProgram();
1443}
1444
1446{
1447 d_2_0_Core->f.CompileShader(shader);
1448}
1449
1451{
1452 d_2_0_Core->f.BindAttribLocation(program, index, name);
1453}
1454
1456{
1457 d_2_0_Core->f.AttachShader(program, shader);
1458}
1459
1461{
1462 d_2_0_Core->f.StencilMaskSeparate(face, mask);
1463}
1464
1466{
1467 d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
1468}
1469
1471{
1472 d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
1473}
1474
1476{
1477 d_2_0_Core->f.DrawBuffers(n, bufs);
1478}
1479
1481{
1482 d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
1483}
1484
1485
1486// OpenGL 1.0 deprecated functions
1488{
1489 d_1_0_Deprecated->f.Translatef(x, y, z);
1490}
1491
1493{
1494 d_1_0_Deprecated->f.Translated(x, y, z);
1495}
1496
1498{
1499 d_1_0_Deprecated->f.Scalef(x, y, z);
1500}
1501
1503{
1504 d_1_0_Deprecated->f.Scaled(x, y, z);
1505}
1506
1508{
1509 d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
1510}
1511
1513{
1514 d_1_0_Deprecated->f.Rotated(angle, x, y, z);
1515}
1516
1518{
1519 d_1_0_Deprecated->f.PushMatrix();
1520}
1521
1523{
1524 d_1_0_Deprecated->f.PopMatrix();
1525}
1526
1531
1533{
1534 d_1_0_Deprecated->f.MultMatrixd(m);
1535}
1536
1538{
1539 d_1_0_Deprecated->f.MultMatrixf(m);
1540}
1541
1543{
1544 d_1_0_Deprecated->f.MatrixMode(mode);
1545}
1546
1548{
1549 d_1_0_Deprecated->f.LoadMatrixd(m);
1550}
1551
1553{
1554 d_1_0_Deprecated->f.LoadMatrixf(m);
1555}
1556
1558{
1559 d_1_0_Deprecated->f.LoadIdentity();
1560}
1561
1566
1568{
1569 return d_1_0_Deprecated->f.IsList(list);
1570}
1571
1573{
1574 d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
1575}
1576
1578{
1579 d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
1580}
1581
1583{
1584 d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
1585}
1586
1588{
1589 d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
1590}
1591
1593{
1594 d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
1595}
1596
1598{
1599 d_1_0_Deprecated->f.GetPolygonStipple(mask);
1600}
1601
1603{
1604 d_1_0_Deprecated->f.GetPixelMapusv(map, values);
1605}
1606
1608{
1609 d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
1610}
1611
1613{
1614 d_1_0_Deprecated->f.GetPixelMapfv(map, values);
1615}
1616
1618{
1619 d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
1620}
1621
1623{
1624 d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
1625}
1626
1628{
1629 d_1_0_Deprecated->f.GetMapiv(target, query, v);
1630}
1631
1633{
1634 d_1_0_Deprecated->f.GetMapfv(target, query, v);
1635}
1636
1638{
1639 d_1_0_Deprecated->f.GetMapdv(target, query, v);
1640}
1641
1643{
1644 d_1_0_Deprecated->f.GetLightiv(light, pname, params);
1645}
1646
1648{
1649 d_1_0_Deprecated->f.GetLightfv(light, pname, params);
1650}
1651
1653{
1654 d_1_0_Deprecated->f.GetClipPlane(plane, equation);
1655}
1656
1658{
1659 d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
1660}
1661
1663{
1664 d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
1665}
1666
1668{
1669 d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
1670}
1671
1673{
1674 d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
1675}
1676
1678{
1679 d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
1680}
1681
1683{
1684 d_1_0_Deprecated->f.PixelTransferi(pname, param);
1685}
1686
1688{
1689 d_1_0_Deprecated->f.PixelTransferf(pname, param);
1690}
1691
1693{
1694 d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
1695}
1696
1698{
1699 d_1_0_Deprecated->f.AlphaFunc(func, ref);
1700}
1701
1703{
1704 d_1_0_Deprecated->f.EvalPoint2(i, j);
1705}
1706
1708{
1709 d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
1710}
1711
1713{
1714 d_1_0_Deprecated->f.EvalPoint1(i);
1715}
1716
1718{
1719 d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
1720}
1721
1723{
1724 d_1_0_Deprecated->f.EvalCoord2fv(u);
1725}
1726
1728{
1729 d_1_0_Deprecated->f.EvalCoord2f(u, v);
1730}
1731
1733{
1734 d_1_0_Deprecated->f.EvalCoord2dv(u);
1735}
1736
1738{
1739 d_1_0_Deprecated->f.EvalCoord2d(u, v);
1740}
1741
1743{
1744 d_1_0_Deprecated->f.EvalCoord1fv(u);
1745}
1746
1748{
1749 d_1_0_Deprecated->f.EvalCoord1f(u);
1750}
1751
1753{
1754 d_1_0_Deprecated->f.EvalCoord1dv(u);
1755}
1756
1758{
1759 d_1_0_Deprecated->f.EvalCoord1d(u);
1760}
1761
1763{
1764 d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
1765}
1766
1768{
1769 d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
1770}
1771
1773{
1774 d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
1775}
1776
1778{
1779 d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
1780}
1781
1786
1791
1793{
1794 d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
1795}
1796
1798{
1799 d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
1800}
1801
1803{
1804 d_1_0_Deprecated->f.PushAttrib(mask);
1805}
1806
1808{
1809 d_1_0_Deprecated->f.PopAttrib();
1810}
1811
1813{
1814 d_1_0_Deprecated->f.Accum(op, value);
1815}
1816
1818{
1819 d_1_0_Deprecated->f.IndexMask(mask);
1820}
1821
1823{
1824 d_1_0_Deprecated->f.ClearIndex(c);
1825}
1826
1828{
1829 d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
1830}
1831
1833{
1834 d_1_0_Deprecated->f.PushName(name);
1835}
1836
1838{
1839 d_1_0_Deprecated->f.PopName();
1840}
1841
1843{
1844 d_1_0_Deprecated->f.PassThrough(token);
1845}
1846
1848{
1849 d_1_0_Deprecated->f.LoadName(name);
1850}
1851
1853{
1854 d_1_0_Deprecated->f.InitNames();
1855}
1856
1858{
1859 return d_1_0_Deprecated->f.RenderMode(mode);
1860}
1861
1863{
1864 d_1_0_Deprecated->f.SelectBuffer(size, buffer);
1865}
1866
1868{
1869 d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
1870}
1871
1873{
1874 d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
1875}
1876
1878{
1879 d_1_0_Deprecated->f.TexGeni(coord, pname, param);
1880}
1881
1883{
1884 d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
1885}
1886
1888{
1889 d_1_0_Deprecated->f.TexGenf(coord, pname, param);
1890}
1891
1893{
1894 d_1_0_Deprecated->f.TexGendv(coord, pname, params);
1895}
1896
1898{
1899 d_1_0_Deprecated->f.TexGend(coord, pname, param);
1900}
1901
1903{
1904 d_1_0_Deprecated->f.TexEnviv(target, pname, params);
1905}
1906
1908{
1909 d_1_0_Deprecated->f.TexEnvi(target, pname, param);
1910}
1911
1913{
1914 d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
1915}
1916
1918{
1919 d_1_0_Deprecated->f.TexEnvf(target, pname, param);
1920}
1921
1923{
1924 d_1_0_Deprecated->f.ShadeModel(mode);
1925}
1926
1928{
1929 d_1_0_Deprecated->f.PolygonStipple(mask);
1930}
1931
1933{
1934 d_1_0_Deprecated->f.Materialiv(face, pname, params);
1935}
1936
1938{
1939 d_1_0_Deprecated->f.Materiali(face, pname, param);
1940}
1941
1943{
1944 d_1_0_Deprecated->f.Materialfv(face, pname, params);
1945}
1946
1948{
1949 d_1_0_Deprecated->f.Materialf(face, pname, param);
1950}
1951
1953{
1954 d_1_0_Deprecated->f.LineStipple(factor, pattern);
1955}
1956
1958{
1959 d_1_0_Deprecated->f.LightModeliv(pname, params);
1960}
1961
1963{
1964 d_1_0_Deprecated->f.LightModeli(pname, param);
1965}
1966
1968{
1969 d_1_0_Deprecated->f.LightModelfv(pname, params);
1970}
1971
1973{
1974 d_1_0_Deprecated->f.LightModelf(pname, param);
1975}
1976
1978{
1979 d_1_0_Deprecated->f.Lightiv(light, pname, params);
1980}
1981
1983{
1984 d_1_0_Deprecated->f.Lighti(light, pname, param);
1985}
1986
1988{
1989 d_1_0_Deprecated->f.Lightfv(light, pname, params);
1990}
1991
1993{
1994 d_1_0_Deprecated->f.Lightf(light, pname, param);
1995}
1996
1998{
1999 d_1_0_Deprecated->f.Fogiv(pname, params);
2000}
2001
2003{
2004 d_1_0_Deprecated->f.Fogi(pname, param);
2005}
2006
2008{
2009 d_1_0_Deprecated->f.Fogfv(pname, params);
2010}
2011
2013{
2014 d_1_0_Deprecated->f.Fogf(pname, param);
2015}
2016
2018{
2019 d_1_0_Deprecated->f.ColorMaterial(face, mode);
2020}
2021
2023{
2024 d_1_0_Deprecated->f.ClipPlane(plane, equation);
2025}
2026
2027inline void QOpenGLFunctions_2_0::glVertex4sv(const GLshort *v)
2028{
2029 d_1_0_Deprecated->f.Vertex4sv(v);
2030}
2031
2032inline void QOpenGLFunctions_2_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2033{
2034 d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
2035}
2036
2038{
2039 d_1_0_Deprecated->f.Vertex4iv(v);
2040}
2041
2043{
2044 d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
2045}
2046
2048{
2049 d_1_0_Deprecated->f.Vertex4fv(v);
2050}
2051
2053{
2054 d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
2055}
2056
2058{
2059 d_1_0_Deprecated->f.Vertex4dv(v);
2060}
2061
2063{
2064 d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
2065}
2066
2067inline void QOpenGLFunctions_2_0::glVertex3sv(const GLshort *v)
2068{
2069 d_1_0_Deprecated->f.Vertex3sv(v);
2070}
2071
2072inline void QOpenGLFunctions_2_0::glVertex3s(GLshort x, GLshort y, GLshort z)
2073{
2074 d_1_0_Deprecated->f.Vertex3s(x, y, z);
2075}
2076
2078{
2079 d_1_0_Deprecated->f.Vertex3iv(v);
2080}
2081
2083{
2084 d_1_0_Deprecated->f.Vertex3i(x, y, z);
2085}
2086
2088{
2089 d_1_0_Deprecated->f.Vertex3fv(v);
2090}
2091
2093{
2094 d_1_0_Deprecated->f.Vertex3f(x, y, z);
2095}
2096
2098{
2099 d_1_0_Deprecated->f.Vertex3dv(v);
2100}
2101
2103{
2104 d_1_0_Deprecated->f.Vertex3d(x, y, z);
2105}
2106
2107inline void QOpenGLFunctions_2_0::glVertex2sv(const GLshort *v)
2108{
2109 d_1_0_Deprecated->f.Vertex2sv(v);
2110}
2111
2112inline void QOpenGLFunctions_2_0::glVertex2s(GLshort x, GLshort y)
2113{
2114 d_1_0_Deprecated->f.Vertex2s(x, y);
2115}
2116
2118{
2119 d_1_0_Deprecated->f.Vertex2iv(v);
2120}
2121
2123{
2124 d_1_0_Deprecated->f.Vertex2i(x, y);
2125}
2126
2128{
2129 d_1_0_Deprecated->f.Vertex2fv(v);
2130}
2131
2133{
2134 d_1_0_Deprecated->f.Vertex2f(x, y);
2135}
2136
2138{
2139 d_1_0_Deprecated->f.Vertex2dv(v);
2140}
2141
2143{
2144 d_1_0_Deprecated->f.Vertex2d(x, y);
2145}
2146
2147inline void QOpenGLFunctions_2_0::glTexCoord4sv(const GLshort *v)
2148{
2149 d_1_0_Deprecated->f.TexCoord4sv(v);
2150}
2151
2152inline void QOpenGLFunctions_2_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
2153{
2154 d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
2155}
2156
2158{
2159 d_1_0_Deprecated->f.TexCoord4iv(v);
2160}
2161
2163{
2164 d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
2165}
2166
2168{
2169 d_1_0_Deprecated->f.TexCoord4fv(v);
2170}
2171
2173{
2174 d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
2175}
2176
2178{
2179 d_1_0_Deprecated->f.TexCoord4dv(v);
2180}
2181
2183{
2184 d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
2185}
2186
2187inline void QOpenGLFunctions_2_0::glTexCoord3sv(const GLshort *v)
2188{
2189 d_1_0_Deprecated->f.TexCoord3sv(v);
2190}
2191
2192inline void QOpenGLFunctions_2_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
2193{
2194 d_1_0_Deprecated->f.TexCoord3s(s, t, r);
2195}
2196
2198{
2199 d_1_0_Deprecated->f.TexCoord3iv(v);
2200}
2201
2203{
2204 d_1_0_Deprecated->f.TexCoord3i(s, t, r);
2205}
2206
2208{
2209 d_1_0_Deprecated->f.TexCoord3fv(v);
2210}
2211
2213{
2214 d_1_0_Deprecated->f.TexCoord3f(s, t, r);
2215}
2216
2218{
2219 d_1_0_Deprecated->f.TexCoord3dv(v);
2220}
2221
2223{
2224 d_1_0_Deprecated->f.TexCoord3d(s, t, r);
2225}
2226
2227inline void QOpenGLFunctions_2_0::glTexCoord2sv(const GLshort *v)
2228{
2229 d_1_0_Deprecated->f.TexCoord2sv(v);
2230}
2231
2232inline void QOpenGLFunctions_2_0::glTexCoord2s(GLshort s, GLshort t)
2233{
2234 d_1_0_Deprecated->f.TexCoord2s(s, t);
2235}
2236
2238{
2239 d_1_0_Deprecated->f.TexCoord2iv(v);
2240}
2241
2243{
2244 d_1_0_Deprecated->f.TexCoord2i(s, t);
2245}
2246
2248{
2249 d_1_0_Deprecated->f.TexCoord2fv(v);
2250}
2251
2253{
2254 d_1_0_Deprecated->f.TexCoord2f(s, t);
2255}
2256
2258{
2259 d_1_0_Deprecated->f.TexCoord2dv(v);
2260}
2261
2263{
2264 d_1_0_Deprecated->f.TexCoord2d(s, t);
2265}
2266
2267inline void QOpenGLFunctions_2_0::glTexCoord1sv(const GLshort *v)
2268{
2269 d_1_0_Deprecated->f.TexCoord1sv(v);
2270}
2271
2273{
2274 d_1_0_Deprecated->f.TexCoord1s(s);
2275}
2276
2278{
2279 d_1_0_Deprecated->f.TexCoord1iv(v);
2280}
2281
2283{
2284 d_1_0_Deprecated->f.TexCoord1i(s);
2285}
2286
2288{
2289 d_1_0_Deprecated->f.TexCoord1fv(v);
2290}
2291
2293{
2294 d_1_0_Deprecated->f.TexCoord1f(s);
2295}
2296
2298{
2299 d_1_0_Deprecated->f.TexCoord1dv(v);
2300}
2301
2303{
2304 d_1_0_Deprecated->f.TexCoord1d(s);
2305}
2306
2307inline void QOpenGLFunctions_2_0::glRectsv(const GLshort *v1, const GLshort *v2)
2308{
2309 d_1_0_Deprecated->f.Rectsv(v1, v2);
2310}
2311
2312inline void QOpenGLFunctions_2_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
2313{
2314 d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
2315}
2316
2318{
2319 d_1_0_Deprecated->f.Rectiv(v1, v2);
2320}
2321
2323{
2324 d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
2325}
2326
2328{
2329 d_1_0_Deprecated->f.Rectfv(v1, v2);
2330}
2331
2333{
2334 d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
2335}
2336
2338{
2339 d_1_0_Deprecated->f.Rectdv(v1, v2);
2340}
2341
2343{
2344 d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
2345}
2346
2347inline void QOpenGLFunctions_2_0::glRasterPos4sv(const GLshort *v)
2348{
2349 d_1_0_Deprecated->f.RasterPos4sv(v);
2350}
2351
2352inline void QOpenGLFunctions_2_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
2353{
2354 d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
2355}
2356
2358{
2359 d_1_0_Deprecated->f.RasterPos4iv(v);
2360}
2361
2363{
2364 d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
2365}
2366
2368{
2369 d_1_0_Deprecated->f.RasterPos4fv(v);
2370}
2371
2373{
2374 d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
2375}
2376
2378{
2379 d_1_0_Deprecated->f.RasterPos4dv(v);
2380}
2381
2383{
2384 d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
2385}
2386
2387inline void QOpenGLFunctions_2_0::glRasterPos3sv(const GLshort *v)
2388{
2389 d_1_0_Deprecated->f.RasterPos3sv(v);
2390}
2391
2392inline void QOpenGLFunctions_2_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
2393{
2394 d_1_0_Deprecated->f.RasterPos3s(x, y, z);
2395}
2396
2398{
2399 d_1_0_Deprecated->f.RasterPos3iv(v);
2400}
2401
2403{
2404 d_1_0_Deprecated->f.RasterPos3i(x, y, z);
2405}
2406
2408{
2409 d_1_0_Deprecated->f.RasterPos3fv(v);
2410}
2411
2413{
2414 d_1_0_Deprecated->f.RasterPos3f(x, y, z);
2415}
2416
2418{
2419 d_1_0_Deprecated->f.RasterPos3dv(v);
2420}
2421
2423{
2424 d_1_0_Deprecated->f.RasterPos3d(x, y, z);
2425}
2426
2427inline void QOpenGLFunctions_2_0::glRasterPos2sv(const GLshort *v)
2428{
2429 d_1_0_Deprecated->f.RasterPos2sv(v);
2430}
2431
2432inline void QOpenGLFunctions_2_0::glRasterPos2s(GLshort x, GLshort y)
2433{
2434 d_1_0_Deprecated->f.RasterPos2s(x, y);
2435}
2436
2438{
2439 d_1_0_Deprecated->f.RasterPos2iv(v);
2440}
2441
2443{
2444 d_1_0_Deprecated->f.RasterPos2i(x, y);
2445}
2446
2448{
2449 d_1_0_Deprecated->f.RasterPos2fv(v);
2450}
2451
2453{
2454 d_1_0_Deprecated->f.RasterPos2f(x, y);
2455}
2456
2458{
2459 d_1_0_Deprecated->f.RasterPos2dv(v);
2460}
2461
2463{
2464 d_1_0_Deprecated->f.RasterPos2d(x, y);
2465}
2466
2467inline void QOpenGLFunctions_2_0::glNormal3sv(const GLshort *v)
2468{
2469 d_1_0_Deprecated->f.Normal3sv(v);
2470}
2471
2472inline void QOpenGLFunctions_2_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
2473{
2474 d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
2475}
2476
2478{
2479 d_1_0_Deprecated->f.Normal3iv(v);
2480}
2481
2483{
2484 d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
2485}
2486
2488{
2489 d_1_0_Deprecated->f.Normal3fv(v);
2490}
2491
2493{
2494 d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
2495}
2496
2498{
2499 d_1_0_Deprecated->f.Normal3dv(v);
2500}
2501
2503{
2504 d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
2505}
2506
2507inline void QOpenGLFunctions_2_0::glNormal3bv(const GLbyte *v)
2508{
2509 d_1_0_Deprecated->f.Normal3bv(v);
2510}
2511
2512inline void QOpenGLFunctions_2_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
2513{
2514 d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
2515}
2516
2517inline void QOpenGLFunctions_2_0::glIndexsv(const GLshort *c)
2518{
2519 d_1_0_Deprecated->f.Indexsv(c);
2520}
2521
2523{
2524 d_1_0_Deprecated->f.Indexs(c);
2525}
2526
2528{
2529 d_1_0_Deprecated->f.Indexiv(c);
2530}
2531
2533{
2534 d_1_0_Deprecated->f.Indexi(c);
2535}
2536
2538{
2539 d_1_0_Deprecated->f.Indexfv(c);
2540}
2541
2543{
2544 d_1_0_Deprecated->f.Indexf(c);
2545}
2546
2548{
2549 d_1_0_Deprecated->f.Indexdv(c);
2550}
2551
2553{
2554 d_1_0_Deprecated->f.Indexd(c);
2555}
2556
2558{
2559 d_1_0_Deprecated->f.End();
2560}
2561
2563{
2564 d_1_0_Deprecated->f.EdgeFlagv(flag);
2565}
2566
2568{
2569 d_1_0_Deprecated->f.EdgeFlag(flag);
2570}
2571
2573{
2574 d_1_0_Deprecated->f.Color4usv(v);
2575}
2576
2578{
2579 d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
2580}
2581
2583{
2584 d_1_0_Deprecated->f.Color4uiv(v);
2585}
2586
2588{
2589 d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
2590}
2591
2592inline void QOpenGLFunctions_2_0::glColor4ubv(const GLubyte *v)
2593{
2594 d_1_0_Deprecated->f.Color4ubv(v);
2595}
2596
2597inline void QOpenGLFunctions_2_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
2598{
2599 d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
2600}
2601
2602inline void QOpenGLFunctions_2_0::glColor4sv(const GLshort *v)
2603{
2604 d_1_0_Deprecated->f.Color4sv(v);
2605}
2606
2607inline void QOpenGLFunctions_2_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
2608{
2609 d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
2610}
2611
2613{
2614 d_1_0_Deprecated->f.Color4iv(v);
2615}
2616
2618{
2619 d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
2620}
2621
2623{
2624 d_1_0_Deprecated->f.Color4fv(v);
2625}
2626
2628{
2629 d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
2630}
2631
2633{
2634 d_1_0_Deprecated->f.Color4dv(v);
2635}
2636
2638{
2639 d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
2640}
2641
2642inline void QOpenGLFunctions_2_0::glColor4bv(const GLbyte *v)
2643{
2644 d_1_0_Deprecated->f.Color4bv(v);
2645}
2646
2647inline void QOpenGLFunctions_2_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
2648{
2649 d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
2650}
2651
2653{
2654 d_1_0_Deprecated->f.Color3usv(v);
2655}
2656
2658{
2659 d_1_0_Deprecated->f.Color3us(red, green, blue);
2660}
2661
2663{
2664 d_1_0_Deprecated->f.Color3uiv(v);
2665}
2666
2668{
2669 d_1_0_Deprecated->f.Color3ui(red, green, blue);
2670}
2671
2672inline void QOpenGLFunctions_2_0::glColor3ubv(const GLubyte *v)
2673{
2674 d_1_0_Deprecated->f.Color3ubv(v);
2675}
2676
2677inline void QOpenGLFunctions_2_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
2678{
2679 d_1_0_Deprecated->f.Color3ub(red, green, blue);
2680}
2681
2682inline void QOpenGLFunctions_2_0::glColor3sv(const GLshort *v)
2683{
2684 d_1_0_Deprecated->f.Color3sv(v);
2685}
2686
2687inline void QOpenGLFunctions_2_0::glColor3s(GLshort red, GLshort green, GLshort blue)
2688{
2689 d_1_0_Deprecated->f.Color3s(red, green, blue);
2690}
2691
2693{
2694 d_1_0_Deprecated->f.Color3iv(v);
2695}
2696
2698{
2699 d_1_0_Deprecated->f.Color3i(red, green, blue);
2700}
2701
2703{
2704 d_1_0_Deprecated->f.Color3fv(v);
2705}
2706
2708{
2709 d_1_0_Deprecated->f.Color3f(red, green, blue);
2710}
2711
2713{
2714 d_1_0_Deprecated->f.Color3dv(v);
2715}
2716
2718{
2719 d_1_0_Deprecated->f.Color3d(red, green, blue);
2720}
2721
2722inline void QOpenGLFunctions_2_0::glColor3bv(const GLbyte *v)
2723{
2724 d_1_0_Deprecated->f.Color3bv(v);
2725}
2726
2727inline void QOpenGLFunctions_2_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
2728{
2729 d_1_0_Deprecated->f.Color3b(red, green, blue);
2730}
2731
2733{
2734 d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
2735}
2736
2738{
2739 d_1_0_Deprecated->f.Begin(mode);
2740}
2741
2743{
2744 d_1_0_Deprecated->f.ListBase(base);
2745}
2746
2748{
2749 return d_1_0_Deprecated->f.GenLists(range);
2750}
2751
2753{
2754 d_1_0_Deprecated->f.DeleteLists(list, range);
2755}
2756
2758{
2759 d_1_0_Deprecated->f.CallLists(n, type, lists);
2760}
2761
2763{
2764 d_1_0_Deprecated->f.CallList(list);
2765}
2766
2768{
2769 d_1_0_Deprecated->f.EndList();
2770}
2771
2773{
2774 d_1_0_Deprecated->f.NewList(list, mode);
2775}
2776
2777
2778// OpenGL 1.1 deprecated functions
2780{
2781 d_1_1_Deprecated->f.PushClientAttrib(mask);
2782}
2783
2785{
2786 d_1_1_Deprecated->f.PopClientAttrib();
2787}
2788
2790{
2791 d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
2792}
2793
2795{
2796 return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
2797}
2798
2800{
2801 d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
2802}
2803
2805{
2806 d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
2807}
2808
2810{
2811 d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
2812}
2813
2815{
2816 d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
2817}
2818
2820{
2821 d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
2822}
2823
2825{
2826 d_1_1_Deprecated->f.EnableClientState(array);
2827}
2828
2830{
2831 d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
2832}
2833
2835{
2836 d_1_1_Deprecated->f.DisableClientState(array);
2837}
2838
2840{
2841 d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
2842}
2843
2845{
2846 d_1_1_Deprecated->f.ArrayElement(i);
2847}
2848
2849
2850// OpenGL 1.2 deprecated functions
2852{
2853 d_1_2_Deprecated->f.ResetMinmax(target);
2854}
2855
2857{
2858 d_1_2_Deprecated->f.ResetHistogram(target);
2859}
2860
2862{
2863 d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
2864}
2865
2870
2872{
2873 d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
2874}
2875
2877{
2878 d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
2879}
2880
2882{
2883 d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
2884}
2885
2887{
2888 d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
2889}
2890
2892{
2893 d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
2894}
2895
2897{
2898 d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
2899}
2900
2902{
2903 d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
2904}
2905
2907{
2908 d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
2909}
2910
2912{
2913 d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
2914}
2915
2917{
2918 d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
2919}
2920
2922{
2923 d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
2924}
2925
2927{
2928 d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
2929}
2930
2932{
2933 d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
2934}
2935
2937{
2938 d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
2939}
2940
2942{
2943 d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
2944}
2945
2947{
2948 d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
2949}
2950
2952{
2953 d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
2954}
2955
2957{
2958 d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
2959}
2960
2962{
2963 d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
2964}
2965
2967{
2968 d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
2969}
2970
2972{
2973 d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
2974}
2975
2977{
2978 d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
2979}
2980
2982{
2983 d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
2984}
2985
2987{
2988 d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
2989}
2990
2992{
2993 d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
2994}
2995
2997{
2998 d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
2999}
3000
3002{
3003 d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
3004}
3005
3007{
3008 d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
3009}
3010
3011
3012// OpenGL 1.3 deprecated functions
3014{
3015 d_1_3_Deprecated->f.MultTransposeMatrixd(m);
3016}
3017
3019{
3020 d_1_3_Deprecated->f.MultTransposeMatrixf(m);
3021}
3022
3024{
3025 d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
3026}
3027
3029{
3030 d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
3031}
3032
3034{
3035 d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
3036}
3037
3038inline void QOpenGLFunctions_2_0::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
3039{
3040 d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
3041}
3042
3044{
3045 d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
3046}
3047
3049{
3050 d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
3051}
3052
3054{
3055 d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
3056}
3057
3059{
3060 d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
3061}
3062
3064{
3065 d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
3066}
3067
3069{
3070 d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
3071}
3072
3074{
3075 d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
3076}
3077
3078inline void QOpenGLFunctions_2_0::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
3079{
3080 d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
3081}
3082
3084{
3085 d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
3086}
3087
3089{
3090 d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
3091}
3092
3094{
3095 d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
3096}
3097
3099{
3100 d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
3101}
3102
3104{
3105 d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
3106}
3107
3109{
3110 d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
3111}
3112
3114{
3115 d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
3116}
3117
3119{
3120 d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
3121}
3122
3124{
3125 d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
3126}
3127
3129{
3130 d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
3131}
3132
3134{
3135 d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
3136}
3137
3139{
3140 d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
3141}
3142
3144{
3145 d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
3146}
3147
3149{
3150 d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
3151}
3152
3154{
3155 d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
3156}
3157
3159{
3160 d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
3161}
3162
3164{
3165 d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
3166}
3167
3169{
3170 d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
3171}
3172
3174{
3175 d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
3176}
3177
3179{
3180 d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
3181}
3182
3184{
3185 d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
3186}
3187
3189{
3190 d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
3191}
3192
3194{
3195 d_1_3_Deprecated->f.ClientActiveTexture(texture);
3196}
3197
3198
3199// OpenGL 1.4 deprecated functions
3200inline void QOpenGLFunctions_2_0::glWindowPos3sv(const GLshort *v)
3201{
3202 d_1_4_Deprecated->f.WindowPos3sv(v);
3203}
3204
3205inline void QOpenGLFunctions_2_0::glWindowPos3s(GLshort x, GLshort y, GLshort z)
3206{
3207 d_1_4_Deprecated->f.WindowPos3s(x, y, z);
3208}
3209
3211{
3212 d_1_4_Deprecated->f.WindowPos3iv(v);
3213}
3214
3216{
3217 d_1_4_Deprecated->f.WindowPos3i(x, y, z);
3218}
3219
3221{
3222 d_1_4_Deprecated->f.WindowPos3fv(v);
3223}
3224
3226{
3227 d_1_4_Deprecated->f.WindowPos3f(x, y, z);
3228}
3229
3231{
3232 d_1_4_Deprecated->f.WindowPos3dv(v);
3233}
3234
3236{
3237 d_1_4_Deprecated->f.WindowPos3d(x, y, z);
3238}
3239
3240inline void QOpenGLFunctions_2_0::glWindowPos2sv(const GLshort *v)
3241{
3242 d_1_4_Deprecated->f.WindowPos2sv(v);
3243}
3244
3245inline void QOpenGLFunctions_2_0::glWindowPos2s(GLshort x, GLshort y)
3246{
3247 d_1_4_Deprecated->f.WindowPos2s(x, y);
3248}
3249
3251{
3252 d_1_4_Deprecated->f.WindowPos2iv(v);
3253}
3254
3256{
3257 d_1_4_Deprecated->f.WindowPos2i(x, y);
3258}
3259
3261{
3262 d_1_4_Deprecated->f.WindowPos2fv(v);
3263}
3264
3266{
3267 d_1_4_Deprecated->f.WindowPos2f(x, y);
3268}
3269
3271{
3272 d_1_4_Deprecated->f.WindowPos2dv(v);
3273}
3274
3276{
3277 d_1_4_Deprecated->f.WindowPos2d(x, y);
3278}
3279
3281{
3282 d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
3283}
3284
3286{
3287 d_1_4_Deprecated->f.SecondaryColor3usv(v);
3288}
3289
3291{
3292 d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
3293}
3294
3296{
3297 d_1_4_Deprecated->f.SecondaryColor3uiv(v);
3298}
3299
3301{
3302 d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
3303}
3304
3306{
3307 d_1_4_Deprecated->f.SecondaryColor3ubv(v);
3308}
3309
3310inline void QOpenGLFunctions_2_0::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
3311{
3312 d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
3313}
3314
3316{
3317 d_1_4_Deprecated->f.SecondaryColor3sv(v);
3318}
3319
3320inline void QOpenGLFunctions_2_0::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
3321{
3322 d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
3323}
3324
3326{
3327 d_1_4_Deprecated->f.SecondaryColor3iv(v);
3328}
3329
3331{
3332 d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
3333}
3334
3336{
3337 d_1_4_Deprecated->f.SecondaryColor3fv(v);
3338}
3339
3341{
3342 d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
3343}
3344
3346{
3347 d_1_4_Deprecated->f.SecondaryColor3dv(v);
3348}
3349
3351{
3352 d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
3353}
3354
3356{
3357 d_1_4_Deprecated->f.SecondaryColor3bv(v);
3358}
3359
3360inline void QOpenGLFunctions_2_0::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
3361{
3362 d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
3363}
3364
3366{
3367 d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
3368}
3369
3371{
3372 d_1_4_Deprecated->f.FogCoorddv(coord);
3373}
3374
3376{
3377 d_1_4_Deprecated->f.FogCoordd(coord);
3378}
3379
3381{
3382 d_1_4_Deprecated->f.FogCoordfv(coord);
3383}
3384
3386{
3387 d_1_4_Deprecated->f.FogCoordf(coord);
3388}
3389
3390
3391// OpenGL 1.5 deprecated functions
3392
3393// OpenGL 2.0 deprecated functions
3395{
3396 d_2_0_Core->f.VertexAttrib4usv(index, v);
3397}
3398
3400{
3401 d_2_0_Core->f.VertexAttrib4uiv(index, v);
3402}
3403
3405{
3406 d_2_0_Core->f.VertexAttrib4ubv(index, v);
3407}
3408
3410{
3411 d_2_0_Core->f.VertexAttrib4sv(index, v);
3412}
3413
3414inline void QOpenGLFunctions_2_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
3415{
3416 d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
3417}
3418
3420{
3421 d_2_0_Core->f.VertexAttrib4iv(index, v);
3422}
3423
3425{
3426 d_2_0_Core->f.VertexAttrib4fv(index, v);
3427}
3428
3430{
3431 d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
3432}
3433
3435{
3436 d_2_0_Core->f.VertexAttrib4dv(index, v);
3437}
3438
3440{
3441 d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
3442}
3443
3445{
3446 d_2_0_Core->f.VertexAttrib4bv(index, v);
3447}
3448
3450{
3451 d_2_0_Core->f.VertexAttrib4Nusv(index, v);
3452}
3453
3455{
3456 d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
3457}
3458
3460{
3461 d_2_0_Core->f.VertexAttrib4Nubv(index, v);
3462}
3463
3464inline void QOpenGLFunctions_2_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
3465{
3466 d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
3467}
3468
3470{
3471 d_2_0_Core->f.VertexAttrib4Nsv(index, v);
3472}
3473
3475{
3476 d_2_0_Core->f.VertexAttrib4Niv(index, v);
3477}
3478
3480{
3481 d_2_0_Core->f.VertexAttrib4Nbv(index, v);
3482}
3483
3485{
3486 d_2_0_Core->f.VertexAttrib3sv(index, v);
3487}
3488
3489inline void QOpenGLFunctions_2_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
3490{
3491 d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
3492}
3493
3495{
3496 d_2_0_Core->f.VertexAttrib3fv(index, v);
3497}
3498
3500{
3501 d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
3502}
3503
3505{
3506 d_2_0_Core->f.VertexAttrib3dv(index, v);
3507}
3508
3510{
3511 d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
3512}
3513
3515{
3516 d_2_0_Core->f.VertexAttrib2sv(index, v);
3517}
3518
3520{
3521 d_2_0_Core->f.VertexAttrib2s(index, x, y);
3522}
3523
3525{
3526 d_2_0_Core->f.VertexAttrib2fv(index, v);
3527}
3528
3530{
3531 d_2_0_Core->f.VertexAttrib2f(index, x, y);
3532}
3533
3535{
3536 d_2_0_Core->f.VertexAttrib2dv(index, v);
3537}
3538
3540{
3541 d_2_0_Core->f.VertexAttrib2d(index, x, y);
3542}
3543
3545{
3546 d_2_0_Core->f.VertexAttrib1sv(index, v);
3547}
3548
3550{
3551 d_2_0_Core->f.VertexAttrib1s(index, x);
3552}
3553
3555{
3556 d_2_0_Core->f.VertexAttrib1fv(index, v);
3557}
3558
3560{
3561 d_2_0_Core->f.VertexAttrib1f(index, x);
3562}
3563
3565{
3566 d_2_0_Core->f.VertexAttrib1dv(index, v);
3567}
3568
3570{
3571 d_2_0_Core->f.VertexAttrib1d(index, x);
3572}
3573
3574
3575
3577
3578#endif // QT_NO_OPENGL && !QT_CONFIG(opengles2)
3579
3580#endif
quint16 opcode
Definition bluez_data_p.h:1
\inmodule QtGui
void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
void glVertex2iv(const GLint *v)
void glEvalCoord2f(GLfloat u, GLfloat v)
void glUniform2f(GLint location, GLfloat v0, GLfloat v1)
GLboolean glIsQuery(GLuint id)
void glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
void glGenBuffers(GLsizei n, GLuint *buffers)
void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
void glIndexubv(const GLubyte *c)
void glGetBooleanv(GLenum pname, GLboolean *params)
void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
void glGetPixelMapfv(GLenum map, GLfloat *values)
void glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
void glResetHistogram(GLenum target)
void glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
void glMultMatrixd(const GLdouble *m)
void glRasterPos2d(GLdouble x, GLdouble y)
void glColor4sv(const GLshort *v)
void glVertexAttrib1s(GLuint index, GLshort x)
void glNormal3s(GLshort nx, GLshort ny, GLshort nz)
void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
void glTexCoord2i(GLint s, GLint t)
GLboolean glIsList(GLuint list)
void glColor4iv(const GLint *v)
void glWindowPos3i(GLint x, GLint y, GLint z)
void glVertex3fv(const GLfloat *v)
void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
void glClearDepth(GLdouble depth)
void glPointParameteriv(GLenum pname, const GLint *params)
void glTranslated(GLdouble x, GLdouble y, GLdouble z)
void glBindBuffer(GLenum target, GLuint buffer)
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
void glWindowPos3iv(const GLint *v)
void glNormal3sv(const GLshort *v)
void glTexCoord4iv(const GLint *v)
void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
void glTexCoord3s(GLshort s, GLshort t, GLshort r)
void glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
const GLubyte * glGetString(GLenum name)
void glTexCoord4sv(const GLshort *v)
void glMultiTexCoord1sv(GLenum target, const GLshort *v)
void glNewList(GLuint list, GLenum mode)
GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
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 glColor3uiv(const GLuint *v)
void glVertexAttrib4Nsv(GLuint index, const GLshort *v)
void glPushClientAttrib(GLbitfield mask)
void glVertex2fv(const GLfloat *v)
void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glRasterPos2dv(const GLdouble *v)
void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
void glVertex2d(GLdouble x, GLdouble y)
void glGetMapfv(GLenum target, GLenum query, GLfloat *v)
void glGetIntegerv(GLenum pname, GLint *params)
void glTexCoord1dv(const GLdouble *v)
void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glEnableVertexAttribArray(GLuint index)
void glVertexAttrib4usv(GLuint index, const GLushort *v)
void glLightModelf(GLenum pname, GLfloat param)
void glTexCoord3dv(const GLdouble *v)
void glTexCoord3sv(const GLshort *v)
void glVertexAttrib3fv(GLuint index, const GLfloat *v)
void glVertex4dv(const GLdouble *v)
void glLightfv(GLenum light, GLenum pname, const GLfloat *params)
void glVertex3f(GLfloat x, GLfloat y, GLfloat z)
void glVertexAttrib4Nusv(GLuint index, const GLushort *v)
void glUniform3iv(GLint location, GLsizei count, const GLint *value)
void glWindowPos2d(GLdouble x, GLdouble y)
void glResetMinmax(GLenum target)
void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
void glReadBuffer(GLenum mode)
void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
void glVertex2sv(const GLshort *v)
void glClipPlane(GLenum plane, const GLdouble *equation)
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
void glStencilMaskSeparate(GLenum face, GLuint mask)
void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
void glEnableClientState(GLenum array)
void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
void glWindowPos2dv(const GLdouble *v)
void glTexCoord1fv(const GLfloat *v)
void glTexCoord1sv(const GLshort *v)
void glUniform1i(GLint location, GLint v0)
void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glBlendFunc(GLenum sfactor, GLenum dfactor)
void glGetUniformfv(GLuint program, GLint location, GLfloat *params)
void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
void glColor4uiv(const GLuint *v)
void glFogiv(GLenum pname, const GLint *params)
void glGetProgramiv(GLuint program, GLenum pname, GLint *params)
void glWindowPos2i(GLint x, GLint y)
void glGetLightiv(GLenum light, GLenum pname, GLint *params)
void glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
void glRectsv(const GLshort *v1, const GLshort *v2)
void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glWindowPos2sv(const GLshort *v)
void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
GLboolean glIsTexture(GLuint texture)
void glVertexAttrib3dv(GLuint index, const GLdouble *v)
void glMultiTexCoord1d(GLenum target, GLdouble s)
void glVertex4fv(const GLfloat *v)
void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
void glGetUniformiv(GLuint program, GLint location, GLint *params)
void glFogi(GLenum pname, GLint param)
void glWindowPos2f(GLfloat x, GLfloat y)
void glRasterPos4sv(const GLshort *v)
void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
void glEvalCoord2d(GLdouble u, GLdouble v)
void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
void glPolygonOffset(GLfloat factor, GLfloat units)
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
void glLogicOp(GLenum opcode)
void glEvalCoord1dv(const GLdouble *u)
void glTexCoord4dv(const GLdouble *v)
void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
void glUniform2i(GLint location, GLint v0, GLint v1)
void glRasterPos3s(GLshort x, GLshort y, GLshort z)
void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glLineStipple(GLint factor, GLushort pattern)
void glEvalCoord2dv(const GLdouble *u)
void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
void glVertex3d(GLdouble x, GLdouble y, GLdouble z)
void glMultiTexCoord2dv(GLenum target, const GLdouble *v)
void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
void glColor3sv(const GLshort *v)
void glColor3bv(const GLbyte *v)
void glGetPointerv(GLenum pname, GLvoid **params)
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glDisableClientState(GLenum array)
void glGetPixelMapusv(GLenum map, GLushort *values)
void glMultiTexCoord3dv(GLenum target, const GLdouble *v)
void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
void glRasterPos2f(GLfloat x, GLfloat y)
void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
void glTexCoord2sv(const GLshort *v)
void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
void glMultiTexCoord2sv(GLenum target, const GLshort *v)
void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
void glVertex3s(GLshort x, GLshort y, GLshort z)
void glPixelZoom(GLfloat xfactor, GLfloat yfactor)
void glSecondaryColor3dv(const GLdouble *v)
void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
void glMultiTexCoord1i(GLenum target, GLint s)
void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
void glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
void glRasterPos2iv(const GLint *v)
void glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
void glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
void glUniform2iv(GLint location, GLsizei count, const GLint *value)
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 glIndexMask(GLuint mask)
void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glMultiTexCoord4iv(GLenum target, const GLint *v)
void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
void glDeleteQueries(GLsizei n, const GLuint *ids)
void glEvalMesh1(GLenum mode, GLint i1, GLint i2)
void glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
void glEdgeFlag(GLboolean flag)
void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
void glColor4ubv(const GLubyte *v)
void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
void glEndQuery(GLenum target)
void glLightModelfv(GLenum pname, const GLfloat *params)
void glMultiTexCoord3fv(GLenum target, const GLfloat *v)
void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
void glVertex3sv(const GLshort *v)
void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
void glLineWidth(GLfloat width)
void glRasterPos3sv(const GLshort *v)
void glSecondaryColor3ubv(const GLubyte *v)
void glRectdv(const GLdouble *v1, const GLdouble *v2)
void glVertex3i(GLint x, GLint y, GLint z)
void glColor3fv(const GLfloat *v)
void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
void glDepthMask(GLboolean flag)
void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
void glAccum(GLenum op, GLfloat value)
void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
void glPointParameterf(GLenum pname, GLfloat param)
void glWindowPos3dv(const GLdouble *v)
void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
void glGetFloatv(GLenum pname, GLfloat *params)
void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer)
void glGetPolygonStipple(GLubyte *mask)
void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid *const *indices, GLsizei drawcount)
void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
GLvoid * glMapBuffer(GLenum target, GLenum access)
void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
void glTexCoord2iv(const GLint *v)
void glTexCoord2s(GLshort s, GLshort t)
void glLinkProgram(GLuint program)
GLint glRenderMode(GLenum mode)
void glMatrixMode(GLenum mode)
void glVertexAttrib4ubv(GLuint index, const GLubyte *v)
void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
void glVertex3dv(const GLdouble *v)
void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
void glLoadTransposeMatrixf(const GLfloat *m)
void glPointSize(GLfloat size)
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
void glColor3d(GLdouble red, GLdouble green, GLdouble blue)
void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
void glRasterPos2s(GLshort x, GLshort y)
void glVertex2i(GLint x, GLint y)
void glVertexAttrib1fv(GLuint index, const GLfloat *v)
void glWindowPos3sv(const GLshort *v)
void glPixelStoref(GLenum pname, GLfloat param)
void glSecondaryColor3fv(const GLfloat *v)
void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glNormal3i(GLint nx, GLint ny, GLint nz)
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
void glEvalCoord1fv(const GLfloat *u)
GLint glGetUniformLocation(GLuint program, const GLchar *name)
void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
void glBeginQuery(GLenum target, GLuint id)
GLboolean glIsProgram(GLuint program)
void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
void glMultTransposeMatrixd(const GLdouble *m)
void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
void glVertexAttrib1d(GLuint index, GLdouble x)
void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
void glVertex4iv(const GLint *v)
void glFogCoordf(GLfloat coord)
void glSecondaryColor3sv(const GLshort *v)
void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
void glGenTextures(GLsizei n, GLuint *textures)
void glNormal3fv(const GLfloat *v)
void glIndexsv(const GLshort *c)
void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
void glMultiTexCoord4dv(GLenum target, const GLdouble *v)
void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
void glVertex2dv(const GLdouble *v)
void glDetachShader(GLuint program, GLuint shader)
void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
void glLoadMatrixf(const GLfloat *m)
void glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
void glLightiv(GLenum light, GLenum pname, const GLint *params)
void glValidateProgram(GLuint program)
void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
void glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
void glPolygonStipple(const GLubyte *mask)
void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
void glDeleteTextures(GLsizei n, const GLuint *textures)
void glMultiTexCoord2iv(GLenum target, const GLint *v)
void glDeleteProgram(GLuint program)
void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
void glMultTransposeMatrixf(const GLfloat *m)
void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glGetQueryiv(GLenum target, GLenum pname, GLint *params)
void glWindowPos3fv(const GLfloat *v)
void glMultiTexCoord1iv(GLenum target, const GLint *v)
void glVertex4sv(const GLshort *v)
void glClientActiveTexture(GLenum texture)
void glPixelStorei(GLenum pname, GLint param)
void glVertexAttrib4uiv(GLuint index, const GLuint *v)
void glBindTexture(GLenum target, GLuint texture)
void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
void glBlendEquation(GLenum mode)
void glColor4usv(const GLushort *v)
void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
void glColor3iv(const GLint *v)
void glMultiTexCoord4sv(GLenum target, const GLshort *v)
void glLightModeliv(GLenum pname, const GLint *params)
void glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
void glMultMatrixf(const GLfloat *m)
void glCompileShader(GLuint shader)
void glGetClipPlane(GLenum plane, GLdouble *equation)
void glVertexAttrib2dv(GLuint index, const GLdouble *v)
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
void glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
void glPassThrough(GLfloat token)
void glVertex2s(GLshort x, GLshort y)
void glActiveTexture(GLenum texture)
void glNormal3bv(const GLbyte *v)
void glUniform4iv(GLint location, GLsizei count, const GLint *value)
GLuint glGenLists(GLsizei range)
void glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
void glTexGenf(GLenum coord, GLenum pname, GLfloat param)
void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glVertex3iv(const GLint *v)
void glTexCoord2dv(const GLdouble *v)
void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
void glGetMapdv(GLenum target, GLenum query, GLdouble *v)
void glColor3i(GLint red, GLint green, GLint blue)
void glGetDoublev(GLenum pname, GLdouble *params)
void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
void glGetPixelMapuiv(GLenum map, GLuint *values)
void glEdgeFlagv(const GLboolean *flag)
void glSelectBuffer(GLsizei size, GLuint *buffer)
void glColor4fv(const GLfloat *v)
void glColor3s(GLshort red, GLshort green, GLshort blue)
void glScaled(GLdouble x, GLdouble y, GLdouble z)
void glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
void glFogf(GLenum pname, GLfloat param)
void glSecondaryColor3i(GLint red, GLint green, GLint blue)
void glRasterPos3fv(const GLfloat *v)
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
void glVertexAttrib1dv(GLuint index, const GLdouble *v)
void glRasterPos2fv(const GLfloat *v)
void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
void glMateriali(GLenum face, GLenum pname, GLint param)
void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
void glColor3us(GLushort red, GLushort green, GLushort blue)
void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
void glVertexAttrib4bv(GLuint index, const GLbyte *v)
void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
void glEvalCoord2fv(const GLfloat *u)
void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
void glNormal3iv(const GLint *v)
void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
void glMultiTexCoord4fv(GLenum target, const GLfloat *v)
void glRasterPos4iv(const GLint *v)
void glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
void glWindowPos3s(GLshort x, GLshort y, GLshort z)
void glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
void glEvalPoint2(GLint i, GLint j)
void glHint(GLenum target, GLenum mode)
void glSecondaryColor3uiv(const GLuint *v)
void glIndexfv(const GLfloat *c)
void glCullFace(GLenum mode)
void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void glLightModeli(GLenum pname, GLint param)
void glIndexiv(const GLint *c)
void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
void glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
void glFogfv(GLenum pname, const GLfloat *params)
void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
void glFogCoorddv(const GLdouble *coord)
void glRasterPos2sv(const GLshort *v)
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
void glVertexAttrib1f(GLuint index, GLfloat x)
void glShadeModel(GLenum mode)
void glTexEnviv(GLenum target, GLenum pname, const GLint *params)
void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
void glColorMaterial(GLenum face, GLenum mode)
void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
void glPolygonMode(GLenum face, GLenum mode)
void glMultiTexCoord1fv(GLenum target, const GLfloat *v)
void glVertexAttrib2sv(GLuint index, const GLshort *v)
void glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
void glWindowPos2s(GLshort x, GLshort y)
void glRasterPos2i(GLint x, GLint y)
void glColor3f(GLfloat red, GLfloat green, GLfloat blue)
void glTexCoord3iv(const GLint *v)
void glScalef(GLfloat x, GLfloat y, GLfloat z)
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
void glDeleteShader(GLuint shader)
void glVertexAttrib4iv(GLuint index, const GLint *v)
void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
void glVertex4i(GLint x, GLint y, GLint z, GLint w)
void glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
void glRasterPos3i(GLint x, GLint y, GLint z)
void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
void glSampleCoverage(GLfloat value, GLboolean invert)
void glRasterPos3dv(const GLdouble *v)
void glColor3usv(const GLushort *v)
void glDisableVertexAttribArray(GLuint index)
void glGenQueries(GLsizei n, GLuint *ids)
void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glMultiTexCoord3iv(GLenum target, const GLint *v)
void glDrawBuffer(GLenum mode)
void glMaterialiv(GLenum face, GLenum pname, const GLint *params)
void glMaterialf(GLenum face, GLenum pname, GLfloat param)
void glDrawArrays(GLenum mode, GLint first, GLsizei count)
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
void glVertexAttrib2fv(GLuint index, const GLfloat *v)
void glStencilFunc(GLenum func, GLint ref, GLuint mask)
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
void glFogCoordd(GLdouble coord)
void glMultiTexCoord1s(GLenum target, GLshort s)
void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
void glColor3ui(GLuint red, GLuint green, GLuint blue)
void glDrawBuffers(GLsizei n, const GLenum *bufs)
void glVertexAttrib4fv(GLuint index, const GLfloat *v)
void glPointParameteri(GLenum pname, GLint param)
void glFrontFace(GLenum mode)
void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
void glColor4dv(const GLdouble *v)
void glVertexAttrib4sv(GLuint index, const GLshort *v)
void glTexCoord3fv(const GLfloat *v)
void glDeleteLists(GLuint list, GLsizei range)
void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
void glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
GLboolean glIsBuffer(GLuint buffer)
void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
void glMultiTexCoord2i(GLenum target, GLint s, GLint t)
void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
void glTexCoord2fv(const GLfloat *v)
void glVertex2f(GLfloat x, GLfloat y)
void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
GLboolean glIsShader(GLuint shader)
void glDepthRange(GLdouble nearVal, GLdouble farVal)
void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
void glUniform1f(GLint location, GLfloat v0)
void glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
void glStencilMask(GLuint mask)
GLboolean glIsEnabled(GLenum cap)
void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
void glGetMapiv(GLenum target, GLenum query, GLint *v)
void glAlphaFunc(GLenum func, GLfloat ref)
void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
void glMultiTexCoord2fv(GLenum target, const GLfloat *v)
void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
void glDepthFunc(GLenum func)
void glMultiTexCoord3sv(GLenum target, const GLshort *v)
void glSecondaryColor3bv(const GLbyte *v)
void glPointParameterfv(GLenum pname, const GLfloat *params)
void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
void glColor4bv(const GLbyte *v)
void glTexCoord3i(GLint s, GLint t, GLint r)
void glLoadMatrixd(const GLdouble *m)
void glTexCoord2d(GLdouble s, GLdouble t)
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
void glLighti(GLenum light, GLenum pname, GLint param)
void glVertexAttrib3sv(GLuint index, const GLshort *v)
void glUniform1iv(GLint location, GLsizei count, const GLint *value)
void glDeleteBuffers(GLsizei n, const GLuint *buffers)
void glMultiTexCoord1dv(GLenum target, const GLdouble *v)
void glRasterPos3iv(const GLint *v)
void glPixelTransferi(GLenum pname, GLint param)
void glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
void glTexCoord1iv(const GLint *v)
void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
void glRectfv(const GLfloat *v1, const GLfloat *v2)
void glUseProgram(GLuint program)
void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
GLuint glCreateShader(GLenum type)
void glSecondaryColor3iv(const GLint *v)
void glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
void glTexCoord2f(GLfloat s, GLfloat t)
void glTexGeni(GLenum coord, GLenum pname, GLint param)
void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
void glWindowPos2iv(const GLint *v)
void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
void glRasterPos4fv(const GLfloat *v)
void glPixelTransferf(GLenum pname, GLfloat param)
void glVertexAttrib4Niv(GLuint index, const GLint *v)
void glTexCoord4fv(const GLfloat *v)
void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
void glLoadTransposeMatrixd(const GLdouble *m)
void glTexEnvi(GLenum target, GLenum pname, GLint param)
void glMultiTexCoord1f(GLenum target, GLfloat s)
void glVertexAttrib1sv(GLuint index, const GLshort *v)
void glColor3ubv(const GLubyte *v)
void glIndexdv(const GLdouble *c)
void glRasterPos4dv(const GLdouble *v)
void glRectiv(const GLint *v1, const GLint *v2)
void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
void glWindowPos2fv(const GLfloat *v)
void glColor3dv(const GLdouble *v)
void glPushAttrib(GLbitfield mask)
void glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
void glSecondaryColor3usv(const GLushort *v)
void glColor3b(GLbyte red, GLbyte green, GLbyte blue)
void glClear(GLbitfield mask)
GLboolean glUnmapBuffer(GLenum target)
void glAttachShader(GLuint program, GLuint shader)
void glNormal3dv(const GLdouble *v)
void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
void glTexGend(GLenum coord, GLenum pname, GLdouble param)
void glFogCoordfv(const GLfloat *coord)
void glTexParameteri(GLenum target, GLenum pname, GLint param)
GLint glGetAttribLocation(GLuint program, const GLchar *name)
void glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
void glLightf(GLenum light, GLenum pname, GLfloat param)
void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
void glVertexAttrib4dv(GLuint index, const GLdouble *v)
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