1// qopenglfunctions_es2.sip generated by MetaSIP
2//
3// This file is part of the _QOpenGLFunctions_ES2 Python extension module.
4//
5// Copyright (c) 2021 Riverbank Computing Limited <info@riverbankcomputing.com>
6//
7// This file is part of PyQt5.
8//
9// This file may be used under the terms of the GNU General Public License
10// version 3.0 as published by the Free Software Foundation and appearing in
11// the file LICENSE included in the packaging of this file.  Please review the
12// following information to ensure the GNU General Public License version 3.0
13// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
14//
15// If you do not wish to use this file under the terms of the GPL version 3.0
16// then you may purchase a commercial license.  For more information contact
17// info@riverbankcomputing.com.
18//
19// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
20// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21
22
23%If (Qt_5_1_0 -)
24
25class QOpenGLFunctions_ES2 : QAbstractOpenGLFunctions
26{
27%TypeHeaderCode
28#include <qopenglfunctions_es2.h>
29%End
30
31public:
32    QOpenGLFunctions_ES2();
33    bool initializeOpenGLFunctions();
34    void glActiveTexture(GLenum texture);
35    void glAttachShader(GLuint program, GLuint shader);
36    void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);
37    void glBindBuffer(GLenum target, GLuint buffer);
38    void glBindFramebuffer(GLenum target, GLuint framebuffer);
39    void glBindRenderbuffer(GLenum target, GLuint renderbuffer);
40    void glBindTexture(GLenum target, GLuint texture);
41    void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
42    void glBlendEquation(GLenum mode);
43    void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
44    void glBlendFunc(GLenum sfactor, GLenum dfactor);
45    void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
46    void glBufferData(GLenum target, GLsizeiptr size, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/, GLenum usage);
47%MethodCode
48        const GLvoid *array;
49
50        if (a2 == Py_None)
51            array = 0;
52        else
53            array = qpyopengl_value_array(&sipError, a2, GL_UNSIGNED_BYTE, sipSelf);
54
55        if (sipError == sipErrorNone)
56            sipCpp->glBufferData(a0, a1, array, a3);
57%End
58
59    void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/);
60%MethodCode
61        const GLvoid *array;
62
63        if (a3 == Py_None)
64            array = 0;
65        else
66            array = qpyopengl_value_array(&sipError, a3, GL_UNSIGNED_BYTE, sipSelf);
67
68        if (sipError == sipErrorNone)
69            sipCpp->glBufferSubData(a0, a1, a2, array);
70%End
71
72    GLenum glCheckFramebufferStatus(GLenum target);
73    void glClear(GLbitfield mask);
74    void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
75    void glClearDepthf(GLclampf depth);
76    void glClearStencil(GLint s);
77    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
78    void glCompileShader(GLuint shader);
79    void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/);
80%MethodCode
81        const GLvoid *array = qpyopengl_value_array(&sipError, a7, GL_UNSIGNED_BYTE,
82                sipSelf);
83
84        if (sipError == sipErrorNone)
85            sipCpp->glCompressedTexImage2D(a0, a1, a2, a3, a4, a5, a6, array);
86%End
87
88    void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/);
89%MethodCode
90        const GLvoid *array = qpyopengl_value_array(&sipError, a8, GL_UNSIGNED_BYTE,
91                sipSelf);
92
93        if (sipError == sipErrorNone)
94            sipCpp->glCompressedTexSubImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array);
95%End
96
97    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
98    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
99    GLuint glCreateProgram();
100    GLuint glCreateShader(GLenum type);
101    void glCullFace(GLenum mode);
102    void glDeleteBuffers(GLsizei n, SIP_PYOBJECT buffers /TypeHint="PYQT_OPENGL_ARRAY"/);
103%MethodCode
104        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
105                sipSelf);
106
107        if (sipError == sipErrorNone)
108            sipCpp->glDeleteBuffers(a0, reinterpret_cast<const GLuint *>(array));
109%End
110
111    void glDeleteFramebuffers(GLsizei n, SIP_PYOBJECT framebuffers);
112%MethodCode
113        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
114                sipSelf);
115
116        if (sipError == sipErrorNone)
117            sipCpp->glDeleteFramebuffers(a0, reinterpret_cast<const GLuint *>(array));
118%End
119
120    void glDeleteProgram(GLuint program);
121    void glDeleteRenderbuffers(GLsizei n, SIP_PYOBJECT renderbuffers);
122%MethodCode
123        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
124                sipSelf);
125
126        if (sipError == sipErrorNone)
127            sipCpp->glDeleteRenderbuffers(a0, reinterpret_cast<const GLuint *>(array));
128%End
129
130    void glDeleteShader(GLuint shader);
131    void glDeleteTextures(GLsizei n, SIP_PYOBJECT textures /TypeHint="PYQT_OPENGL_ARRAY"/);
132%MethodCode
133        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
134                sipSelf);
135
136        if (sipError == sipErrorNone)
137            sipCpp->glDeleteTextures(a0, reinterpret_cast<const GLuint *>(array));
138%End
139
140    void glDepthFunc(GLenum func);
141    void glDepthMask(GLboolean flag);
142    void glDepthRangef(GLclampf zNear, GLclampf zFar);
143    void glDetachShader(GLuint program, GLuint shader);
144    void glDisable(GLenum cap);
145    void glDisableVertexAttribArray(GLuint index);
146    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
147    void glDrawElements(GLenum mode, GLsizei count, GLenum type, SIP_PYOBJECT indices /TypeHint="PYQT_OPENGL_ARRAY"/);
148%MethodCode
149        const GLvoid *array = qpyopengl_value_array(&sipError, a3, a2, sipSelf);
150
151        if (sipError == sipErrorNone)
152            sipCpp->glDrawElements(a0, a1, a2, array);
153%End
154
155    void glEnable(GLenum cap);
156    void glEnableVertexAttribArray(GLuint index);
157    void glFinish();
158    void glFlush();
159    void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
160    void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
161    void glFrontFace(GLenum mode);
162    void glGenBuffers(GLsizei n, SIP_PYOBJECT *buffers /TypeHint="Union[int, Tuple[int, ...]]"/);
163%MethodCode
164        GLuint *params = new GLuint[a0];
165
166        sipCpp->glGenBuffers(a0, params);
167
168        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
169
170        delete[] params;
171%End
172
173    void glGenerateMipmap(GLenum target);
174    void glGenFramebuffers(GLsizei n, SIP_PYOBJECT framebuffers /TypeHint="Union[int, Tuple[int, ...]]"/);
175%MethodCode
176        GLuint *params = new GLuint[a0];
177
178        sipCpp->glGenFramebuffers(a0, params);
179
180        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
181
182        delete[] params;
183%End
184
185    void glGenRenderbuffers(GLsizei n, SIP_PYOBJECT *renderbuffers /TypeHint="Union[int, Tuple[int, ...]]"/);
186%MethodCode
187        GLuint *params = new GLuint[a0];
188
189        sipCpp->glGenRenderbuffers(a0, params);
190
191        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
192
193        delete[] params;
194%End
195
196    void glGenTextures(GLsizei n, SIP_PYOBJECT textures /TypeHint="Union[int, Tuple[int, ...]]"/);
197%MethodCode
198        GLuint *params = new GLuint[a0];
199
200        sipCpp->glGenTextures(a0, params);
201
202        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
203
204        delete[] params;
205%End
206
207    SIP_PYOBJECT glGetActiveAttrib(GLuint program, GLuint index) /TypeHint="Tuple[str, int, int]"/;
208%MethodCode
209        GLint bufsize;
210
211        sipCpp->glGetProgramiv(a0, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &bufsize);
212
213        GLchar *name = new GLchar[bufsize];
214        GLint size;
215        GLenum type;
216
217        sipCpp->glGetActiveAttrib(a0, a1, bufsize, 0, &size, &type, name);
218
219        sipRes = Py_BuildValue("siI", name, size, type);
220
221        if (!sipRes)
222            sipIsErr = 1;
223
224        delete[] name;
225%End
226
227    SIP_PYOBJECT glGetActiveUniform(GLuint program, GLuint index) /TypeHint="Tuple[str, int, int]"/;
228%MethodCode
229        GLint bufsize;
230
231        sipCpp->glGetProgramiv(a0, GL_ACTIVE_UNIFORM_MAX_LENGTH, &bufsize);
232
233        GLchar *name = new GLchar[bufsize];
234        GLint size;
235        GLenum type;
236
237        sipCpp->glGetActiveUniform(a0, a1, bufsize, 0, &size, &type, name);
238
239        sipRes = Py_BuildValue("siI", name, size, type);
240
241        if (!sipRes)
242            sipIsErr = 1;
243
244        delete[] name;
245%End
246
247    SIP_PYOBJECT glGetAttachedShaders(GLuint program) /TypeHint="Tuple[int, ...]"/;
248%MethodCode
249        GLint nr_shaders;
250
251        sipCpp->glGetProgramiv(a0, GL_ATTACHED_SHADERS, &nr_shaders);
252
253        if (nr_shaders < 1)
254        {
255            sipRes = PyTuple_New(0);
256        }
257        else
258        {
259            GLuint *shaders = new GLuint[nr_shaders];
260
261            sipCpp->glGetAttachedShaders(a0, nr_shaders, 0, shaders);
262
263            sipRes = PyTuple_New(nr_shaders);
264
265            if (sipRes)
266            {
267                for (GLint i = 0; i < nr_shaders; ++i)
268                {
269                    PyObject *itm = SIPLong_FromLong(shaders[i]);
270
271                    if (!itm)
272                    {
273                        Py_DECREF(sipRes);
274                        sipRes = 0;
275                        break;
276                    }
277
278                    PyTuple_SetItem(sipRes, i, itm);
279                }
280            }
281
282            delete[] shaders;
283        }
284
285        if (!sipRes)
286            sipIsErr = 1;
287%End
288
289    int glGetAttribLocation(GLuint program, const GLchar *name);
290    void glGetBooleanv(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[bool, Tuple[bool, ...]]"/);
291%MethodCode
292        GLboolean fixed_params[16], *params;
293        GLint nr_params;
294        GLenum query;
295
296        nr_params = qpyopengl_get(a0, &query);
297
298        if (nr_params == 0)
299        {
300            sipCpp->glGetIntegerv(query, &nr_params);
301            params = new GLboolean[nr_params];
302        }
303        else
304        {
305            params = fixed_params;
306        }
307
308        sipCpp->glGetBooleanv(a0, params);
309        a1 = qpyopengl_from_GLboolean(&sipIsErr, params, nr_params);
310
311        if (params != fixed_params)
312            delete[] params;
313%End
314
315    void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
316    GLenum glGetError();
317    void glGetFloatv(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, ...]]"/);
318%MethodCode
319        GLfloat fixed_params[16], *params;
320        GLint nr_params;
321        GLenum query;
322
323        nr_params = qpyopengl_get(a0, &query);
324
325        if (nr_params == 0)
326        {
327            sipCpp->glGetIntegerv(query, &nr_params);
328            params = new GLfloat[nr_params];
329        }
330        else
331        {
332            params = fixed_params;
333        }
334
335        sipCpp->glGetFloatv(a0, params);
336        a1 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params);
337
338        if (params != fixed_params)
339            delete[] params;
340%End
341
342    void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params);
343    void glGetIntegerv(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, ...]]"/);
344%MethodCode
345        GLint fixed_params[16], *params;
346        GLint nr_params;
347        GLenum query;
348
349        nr_params = qpyopengl_get(a0, &query);
350
351        if (nr_params == 0)
352        {
353            sipCpp->glGetIntegerv(query, &nr_params);
354            params = new GLint[nr_params];
355        }
356        else
357        {
358            params = fixed_params;
359        }
360
361        sipCpp->glGetIntegerv(a0, params);
362        a1 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
363
364        if (params != fixed_params)
365            delete[] params;
366%End
367
368    void glGetProgramiv(GLuint program, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int]]"/);
369%MethodCode
370        GLint params[3];
371        Py_ssize_t nr_params;
372
373        switch (a1)
374        {
375        #if defined(GL_COMPUTE_LOCAL_WORK_SIZE)
376        case GL_COMPUTE_LOCAL_WORK_SIZE:
377            nr_params = 3;
378            break;
379        #endif
380
381        default:
382            nr_params = 1;
383        }
384
385        sipCpp->glGetProgramiv(a0, a1, params);
386
387        a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
388%End
389
390    SIP_PYOBJECT glGetProgramInfoLog(GLuint program) /TypeHint="Py_v3:bytes;str"/;
391%MethodCode
392        GLint bufsize;
393
394        sipCpp->glGetProgramiv(a0, GL_INFO_LOG_LENGTH, &bufsize);
395
396        if (bufsize > 0)
397        {
398            GLchar *log = new GLchar[bufsize];
399
400            sipCpp->glGetProgramInfoLog(a0, bufsize, 0, log);
401            sipRes = SIPBytes_FromString(log);
402
403            delete[] log;
404        }
405        else
406        {
407            sipRes = SIPBytes_FromString("");
408        }
409%End
410
411    void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params);
412    void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
413    SIP_PYOBJECT glGetShaderInfoLog(GLuint shader) /TypeHint="Py_v3:bytes;str"/;
414%MethodCode
415        GLint bufsize;
416
417        sipCpp->glGetShaderiv(a0, GL_INFO_LOG_LENGTH, &bufsize);
418
419        if (bufsize > 0)
420        {
421            GLchar *log = new GLchar[bufsize];
422
423            sipCpp->glGetShaderInfoLog(a0, bufsize, 0, log);
424            sipRes = SIPBytes_FromString(log);
425
426            delete[] log;
427        }
428        else
429        {
430            sipRes = SIPBytes_FromString("");
431        }
432%End
433
434    SIP_PYOBJECT glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype) /TypeHint="Tuple[Tuple[int, int], int]"/;
435%MethodCode
436        GLint range[2], precision;
437
438        sipCpp->glGetShaderPrecisionFormat(a0, a1, range, &precision);
439
440        sipRes = Py_BuildValue("(ii)i", (int)range[0], (int)range[1], (int)precision);
441
442        if (!sipRes)
443            sipIsErr = 1;
444%End
445
446    SIP_PYOBJECT glGetShaderSource(GLuint shader) /TypeHint="Py_v3:bytes;str"/;
447%MethodCode
448        GLint bufsize;
449
450        sipCpp->glGetShaderiv(a0, GL_SHADER_SOURCE_LENGTH, &bufsize);
451
452        if (bufsize > 0)
453        {
454            GLchar *source = new GLchar[bufsize];
455
456            sipCpp->glGetShaderSource(a0, bufsize, 0, source);
457            sipRes = SIPBytes_FromString(source);
458
459            delete[] source;
460        }
461        else
462        {
463            sipRes = SIPBytes_FromString("");
464        }
465%End
466
467    const char *glGetString(GLenum name);
468%MethodCode
469        sipRes = reinterpret_cast<const char *>(sipCpp->glGetString(a0));
470%End
471
472    void glGetTexParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/);
473%MethodCode
474        GLfloat params[4];
475        Py_ssize_t nr_params;
476
477        switch (a1)
478        {
479        #if defined(GL_TEXTURE_SWIZZLE_RGBA) || defined(GL_TEXTURE_BORDER_COLOR)
480        #if defined(GL_TEXTURE_SWIZZLE_RGBA)
481        case GL_TEXTURE_SWIZZLE_RGBA:
482        #endif
483        #if defined(GL_TEXTURE_BORDER_COLOR)
484        case GL_TEXTURE_BORDER_COLOR:
485        #endif
486            nr_params = 4;
487            break;
488        #endif
489
490        default:
491            nr_params = 1;
492        }
493
494        sipCpp->glGetTexParameterfv(a0, a1, params);
495
496        a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params);
497%End
498
499    void glGetTexParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/);
500%MethodCode
501        GLint params[4];
502        Py_ssize_t nr_params;
503
504        switch (a1)
505        {
506        #if defined(GL_TEXTURE_SWIZZLE_RGBA) || defined(GL_TEXTURE_BORDER_COLOR)
507        #if defined(GL_TEXTURE_SWIZZLE_RGBA)
508        case GL_TEXTURE_SWIZZLE_RGBA:
509        #endif
510        #if defined(GL_TEXTURE_BORDER_COLOR)
511        case GL_TEXTURE_BORDER_COLOR:
512        #endif
513            nr_params = 4;
514            break;
515        #endif
516
517        default:
518            nr_params = 1;
519        }
520
521        sipCpp->glGetTexParameteriv(a0, a1, params);
522
523        a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
524%End
525
526    int glGetUniformLocation(GLuint program, const GLchar *name);
527    void glGetVertexAttribfv(GLuint index, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/);
528%MethodCode
529        GLfloat params[4];
530        Py_ssize_t nr_params;
531
532        switch (a1)
533        {
534        case GL_CURRENT_VERTEX_ATTRIB:
535            nr_params = 4;
536            break;
537
538        default:
539            nr_params = 1;
540        }
541
542        sipCpp->glGetVertexAttribfv(a0, a1, params);
543
544        a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params);
545%End
546
547    void glGetVertexAttribiv(GLuint index, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/);
548%MethodCode
549        GLint params[4];
550        Py_ssize_t nr_params;
551
552        switch (a1)
553        {
554        case GL_CURRENT_VERTEX_ATTRIB:
555            nr_params = 4;
556            break;
557
558        default:
559            nr_params = 1;
560        }
561
562        sipCpp->glGetVertexAttribiv(a0, a1, params);
563
564        a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
565%End
566
567    void glHint(GLenum target, GLenum mode);
568    GLboolean glIsBuffer(GLuint buffer);
569    GLboolean glIsEnabled(GLenum cap);
570    GLboolean glIsFramebuffer(GLuint framebuffer);
571    GLboolean glIsProgram(GLuint program);
572    GLboolean glIsRenderbuffer(GLuint renderbuffer);
573    GLboolean glIsShader(GLuint shader);
574    GLboolean glIsTexture(GLuint texture);
575    void glLineWidth(GLfloat width);
576    void glLinkProgram(GLuint program);
577    void glPixelStorei(GLenum pname, GLint param);
578    void glPolygonOffset(GLfloat factor, GLfloat units);
579    SIP_PYOBJECT glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type) /TypeHint="Union[Tuple[float, ...], Tuple[int, ...]]"/;
580%MethodCode
581        int components;
582
583        switch (a4)
584        {
585            case GL_RGB:
586            {
587                components = 3;
588                break;
589            }
590
591            case GL_RGBA:
592            {
593                components = 4;
594                break;
595            }
596
597            case GL_ALPHA:
598            {
599                components = 1;
600                break;
601            }
602
603            default:
604                components = 0;
605        }
606
607        Py_ssize_t length = components * a2 * a3;
608
609        switch (a5)
610        {
611            // TODO: Implement array convertors for these formats.
612            case GL_UNSIGNED_SHORT_5_6_5:
613            case GL_UNSIGNED_SHORT_4_4_4_4:
614            case GL_UNSIGNED_SHORT_5_5_5_1:
615            case GL_UNSIGNED_BYTE:
616            default:
617                sipIsErr = 1;
618                PyErr_SetString(PyExc_ValueError, "pixel data format not supported");
619        }
620%End
621
622    void glReleaseShaderCompiler();
623    void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
624    void glSampleCoverage(GLclampf value, GLboolean invert);
625    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
626    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
627    void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
628    void glStencilMask(GLuint mask);
629    void glStencilMaskSeparate(GLenum face, GLuint mask);
630    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
631    void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
632    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/);
633%MethodCode
634        const GLvoid *array = qpyopengl_value_array(&sipError, a8, a7, sipSelf);
635
636        if (sipError == sipErrorNone)
637            sipCpp->glTexImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array);
638%End
639
640    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
641    void glTexParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/);
642%MethodCode
643        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
644
645        if (sipError == sipErrorNone)
646            sipCpp->glTexParameterfv(a0, a1, reinterpret_cast<const GLfloat *>(array));
647%End
648
649    void glTexParameteri(GLenum target, GLenum pname, GLint param);
650    void glTexParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/);
651%MethodCode
652        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
653
654        if (sipError == sipErrorNone)
655            sipCpp->glTexParameteriv(a0, a1, reinterpret_cast<const GLint *>(array));
656%End
657
658    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/);
659%MethodCode
660        const GLvoid *array = qpyopengl_value_array(&sipError, a8, a7, sipSelf);
661
662        if (sipError == sipErrorNone)
663            sipCpp->glTexSubImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array);
664%End
665
666    void glUniform1f(GLint location, GLfloat x);
667    void glUniform1fv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
668%MethodCode
669        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
670
671        if (sipError == sipErrorNone)
672            sipCpp->glUniform1fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
673%End
674
675    void glUniform1i(GLint location, GLint x);
676    void glUniform1iv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
677%MethodCode
678        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
679
680        if (sipError == sipErrorNone)
681            sipCpp->glUniform1iv(a0, a1, reinterpret_cast<const GLint *>(array));
682%End
683
684    void glUniform2f(GLint location, GLfloat x, GLfloat y);
685    void glUniform2fv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
686%MethodCode
687        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
688
689        if (sipError == sipErrorNone)
690            sipCpp->glUniform2fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
691%End
692
693    void glUniform2i(GLint location, GLint x, GLint y);
694    void glUniform2iv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
695%MethodCode
696        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
697
698        if (sipError == sipErrorNone)
699            sipCpp->glUniform2iv(a0, a1, reinterpret_cast<const GLint *>(array));
700%End
701
702    void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);
703    void glUniform3fv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
704%MethodCode
705        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
706
707        if (sipError == sipErrorNone)
708            sipCpp->glUniform3fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
709%End
710
711    void glUniform3i(GLint location, GLint x, GLint y, GLint z);
712    void glUniform3iv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
713%MethodCode
714        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
715
716        if (sipError == sipErrorNone)
717            sipCpp->glUniform3iv(a0, a1, reinterpret_cast<const GLint *>(array));
718%End
719
720    void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
721    void glUniform4fv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
722%MethodCode
723        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
724
725        if (sipError == sipErrorNone)
726            sipCpp->glUniform4fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
727%End
728
729    void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);
730    void glUniform4iv(GLint location, GLsizei count, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/);
731%MethodCode
732        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
733
734        if (sipError == sipErrorNone)
735            sipCpp->glUniform4iv(a0, a1, reinterpret_cast<const GLint *>(array));
736%End
737
738    void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/);
739%MethodCode
740        const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf);
741
742        if (sipError == sipErrorNone)
743            sipCpp->glUniformMatrix2fv(a0, a1, a2,
744                    reinterpret_cast<const GLfloat *>(array));
745%End
746
747    void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/);
748%MethodCode
749        const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf);
750
751        if (sipError == sipErrorNone)
752            sipCpp->glUniformMatrix3fv(a0, a1, a2,
753                    reinterpret_cast<const GLfloat *>(array));
754%End
755
756    void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/);
757%MethodCode
758        const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf);
759
760        if (sipError == sipErrorNone)
761            sipCpp->glUniformMatrix4fv(a0, a1, a2,
762                    reinterpret_cast<const GLfloat *>(array));
763%End
764
765    void glUseProgram(GLuint program);
766    void glValidateProgram(GLuint program);
767    void glVertexAttrib1f(GLuint indx, GLfloat x);
768    void glVertexAttrib1fv(GLuint indx, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/);
769%MethodCode
770        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf);
771
772        if (sipError == sipErrorNone)
773            sipCpp->glVertexAttrib1fv(a0, reinterpret_cast<const GLfloat *>(array));
774%End
775
776    void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
777    void glVertexAttrib2fv(GLuint indx, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/);
778%MethodCode
779        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf);
780
781        if (sipError == sipErrorNone)
782            sipCpp->glVertexAttrib2fv(a0, reinterpret_cast<const GLfloat *>(array));
783%End
784
785    void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
786    void glVertexAttrib3fv(GLuint indx, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/);
787%MethodCode
788        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf);
789
790        if (sipError == sipErrorNone)
791            sipCpp->glVertexAttrib3fv(a0, reinterpret_cast<const GLfloat *>(array));
792%End
793
794    void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
795    void glVertexAttrib4fv(GLuint indx, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/);
796%MethodCode
797        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf);
798
799        if (sipError == sipErrorNone)
800            sipCpp->glVertexAttrib4fv(a0, reinterpret_cast<const GLfloat *>(array));
801%End
802
803    void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, SIP_PYOBJECT ptr /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/);
804%MethodCode
805        const GLvoid *array = qpyopengl_value_array_cached(&sipError, a5, a2, sipSelf,
806                "VertexAttribPointer", a0);
807
808        if (sipError == sipErrorNone)
809            sipCpp->glVertexAttribPointer(a0, a1, a2, a3, a4, array);
810%End
811
812    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
813};
814
815%End
816
817%ModuleHeaderCode
818#include <qopengl.h>
819
820// Imports from QtGui.
821typedef const GLvoid *(*qpyopengl_value_array_t)(sipErrorState *, PyObject *, GLenum, PyObject *);
822extern qpyopengl_value_array_t qpyopengl_value_array;
823
824typedef const GLvoid *(*qpyopengl_value_array_cached_t)(sipErrorState *, PyObject *, GLenum, PyObject *, const char *, GLuint);
825extern qpyopengl_value_array_cached_t qpyopengl_value_array_cached;
826
827typedef GLint (*qpyopengl_get_t)(GLenum, GLenum *);
828extern qpyopengl_get_t qpyopengl_get;
829
830typedef PyObject *(*qpyopengl_from_GLint_t)(int *, const GLint *, Py_ssize_t);
831extern qpyopengl_from_GLint_t qpyopengl_from_GLint;
832
833typedef PyObject *(*qpyopengl_from_GLuint_t)(int *, const GLuint *, Py_ssize_t);
834extern qpyopengl_from_GLuint_t qpyopengl_from_GLuint;
835
836typedef PyObject *(*qpyopengl_from_GLboolean_t)(int *, const GLboolean *, Py_ssize_t);
837extern qpyopengl_from_GLboolean_t qpyopengl_from_GLboolean;
838
839typedef PyObject *(*qpyopengl_from_GLfloat_t)(int *, const GLfloat *, Py_ssize_t);
840extern qpyopengl_from_GLfloat_t qpyopengl_from_GLfloat;
841%End
842
843%ModuleCode
844// Imports from QtGui.
845qpyopengl_value_array_t qpyopengl_value_array;
846qpyopengl_value_array_cached_t qpyopengl_value_array_cached;
847qpyopengl_get_t qpyopengl_get;
848qpyopengl_from_GLint_t qpyopengl_from_GLint;
849qpyopengl_from_GLuint_t qpyopengl_from_GLuint;
850qpyopengl_from_GLboolean_t qpyopengl_from_GLboolean;
851qpyopengl_from_GLfloat_t qpyopengl_from_GLfloat;
852%End
853
854%PostInitialisationCode
855// Imports from QtGui.
856qpyopengl_value_array = (qpyopengl_value_array_t)sipImportSymbol("qpyopengl_value_array");
857Q_ASSERT(qpyopengl_value_array);
858
859qpyopengl_value_array_cached = (qpyopengl_value_array_cached_t)sipImportSymbol("qpyopengl_value_array_cached");
860Q_ASSERT(qpyopengl_value_array_cached);
861
862qpyopengl_get = (qpyopengl_get_t)sipImportSymbol("qpyopengl_get");
863Q_ASSERT(qpyopengl_get);
864
865qpyopengl_from_GLint = (qpyopengl_from_GLint_t)sipImportSymbol("qpyopengl_from_GLint");
866Q_ASSERT(qpyopengl_from_GLint);
867
868qpyopengl_from_GLuint = (qpyopengl_from_GLuint_t)sipImportSymbol("qpyopengl_from_GLuint");
869Q_ASSERT(qpyopengl_from_GLuint);
870
871qpyopengl_from_GLboolean = (qpyopengl_from_GLboolean_t)sipImportSymbol("qpyopengl_from_GLboolean");
872Q_ASSERT(qpyopengl_from_GLboolean);
873
874qpyopengl_from_GLfloat = (qpyopengl_from_GLfloat_t)sipImportSymbol("qpyopengl_from_GLfloat");
875Q_ASSERT(qpyopengl_from_GLfloat);
876%End
877