1// qopenglfunctions_2_1.sip generated by MetaSIP 2// 3// This file is part of the _QOpenGLFunctions_2_1 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_2_1 : QAbstractOpenGLFunctions 26{ 27%TypeHeaderCode 28#include <qopenglfunctions_2_1.h> 29%End 30 31public: 32 QOpenGLFunctions_2_1(); 33 virtual ~QOpenGLFunctions_2_1(); 34 virtual bool initializeOpenGLFunctions(); 35 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); 36 void glDepthRange(GLdouble nearVal, GLdouble farVal); 37 GLboolean glIsEnabled(GLenum cap); 38 void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, SIP_PYOBJECT *params /TypeHint="int"/); 39%MethodCode 40 GLint params[1]; 41 42 sipCpp->glGetTexLevelParameteriv(a0, a1, a2, params); 43 44 a3 = qpyopengl_from_GLint(&sipIsErr, params, 1); 45%End 46 47 void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, SIP_PYOBJECT *params /TypeHint="float"/); 48%MethodCode 49 GLfloat params[1]; 50 51 sipCpp->glGetTexLevelParameterfv(a0, a1, a2, params); 52 53 a3 = qpyopengl_from_GLfloat(&sipIsErr, params, 1); 54%End 55 56 void glGetTexParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/); 57%MethodCode 58 GLint params[4]; 59 Py_ssize_t nr_params; 60 61 switch (a1) 62 { 63 #if defined(GL_TEXTURE_SWIZZLE_RGBA) || defined(GL_TEXTURE_BORDER_COLOR) 64 #if defined(GL_TEXTURE_SWIZZLE_RGBA) 65 case GL_TEXTURE_SWIZZLE_RGBA: 66 #endif 67 #if defined(GL_TEXTURE_BORDER_COLOR) 68 case GL_TEXTURE_BORDER_COLOR: 69 #endif 70 nr_params = 4; 71 break; 72 #endif 73 74 default: 75 nr_params = 1; 76 } 77 78 sipCpp->glGetTexParameteriv(a0, a1, params); 79 80 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 81%End 82 83 void glGetTexParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 84%MethodCode 85 GLfloat params[4]; 86 Py_ssize_t nr_params; 87 88 switch (a1) 89 { 90 #if defined(GL_TEXTURE_SWIZZLE_RGBA) || defined(GL_TEXTURE_BORDER_COLOR) 91 #if defined(GL_TEXTURE_SWIZZLE_RGBA) 92 case GL_TEXTURE_SWIZZLE_RGBA: 93 #endif 94 #if defined(GL_TEXTURE_BORDER_COLOR) 95 case GL_TEXTURE_BORDER_COLOR: 96 #endif 97 nr_params = 4; 98 break; 99 #endif 100 101 default: 102 nr_params = 1; 103 } 104 105 sipCpp->glGetTexParameterfv(a0, a1, params); 106 107 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 108%End 109 110 const char *glGetString(GLenum name); 111%MethodCode 112 sipRes = reinterpret_cast<const char *>(sipCpp->glGetString(a0)); 113%End 114 115 void glGetIntegerv(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, ...]]"/); 116%MethodCode 117 GLint fixed_params[16], *params; 118 GLint nr_params; 119 GLenum query; 120 121 nr_params = qpyopengl_get(a0, &query); 122 123 if (nr_params == 0) 124 { 125 sipCpp->glGetIntegerv(query, &nr_params); 126 params = new GLint[nr_params]; 127 } 128 else 129 { 130 params = fixed_params; 131 } 132 133 sipCpp->glGetIntegerv(a0, params); 134 a1 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 135 136 if (params != fixed_params) 137 delete[] params; 138%End 139 140 void glGetFloatv(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, ...]]"/); 141%MethodCode 142 GLfloat fixed_params[16], *params; 143 GLint nr_params; 144 GLenum query; 145 146 nr_params = qpyopengl_get(a0, &query); 147 148 if (nr_params == 0) 149 { 150 sipCpp->glGetIntegerv(query, &nr_params); 151 params = new GLfloat[nr_params]; 152 } 153 else 154 { 155 params = fixed_params; 156 } 157 158 sipCpp->glGetFloatv(a0, params); 159 a1 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 160 161 if (params != fixed_params) 162 delete[] params; 163%End 164 165 GLenum glGetError(); 166 void glGetDoublev(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, ...]]"/); 167%MethodCode 168 GLdouble fixed_params[16], *params; 169 GLint nr_params; 170 GLenum query; 171 172 nr_params = qpyopengl_get(a0, &query); 173 174 if (nr_params == 0) 175 { 176 sipCpp->glGetIntegerv(query, &nr_params); 177 params = new GLdouble[nr_params]; 178 } 179 else 180 { 181 params = fixed_params; 182 } 183 184 sipCpp->glGetDoublev(a0, params); 185 a1 = qpyopengl_from_GLdouble(&sipIsErr, params, nr_params); 186 187 if (params != fixed_params) 188 delete[] params; 189%End 190 191 void glGetBooleanv(GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[bool, Tuple[bool, ...]]"/); 192%MethodCode 193 GLboolean fixed_params[16], *params; 194 GLint nr_params; 195 GLenum query; 196 197 nr_params = qpyopengl_get(a0, &query); 198 199 if (nr_params == 0) 200 { 201 sipCpp->glGetIntegerv(query, &nr_params); 202 params = new GLboolean[nr_params]; 203 } 204 else 205 { 206 params = fixed_params; 207 } 208 209 sipCpp->glGetBooleanv(a0, params); 210 a1 = qpyopengl_from_GLboolean(&sipIsErr, params, nr_params); 211 212 if (params != fixed_params) 213 delete[] params; 214%End 215 216 SIP_PYOBJECT glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type) /TypeHint="Union[Tuple[float, ...], Tuple[int, ...]]"/; 217%MethodCode 218 int components; 219 220 switch (a4) 221 { 222 case GL_BGR: 223 case GL_RGB: 224 { 225 components = 3; 226 break; 227 } 228 229 case GL_BGRA: 230 case GL_RGBA: 231 { 232 components = 4; 233 break; 234 } 235 236 case GL_RED: 237 case GL_GREEN: 238 case GL_BLUE: 239 case GL_ALPHA: 240 case GL_DEPTH_COMPONENT: 241 case GL_STENCIL_INDEX: 242 case GL_DEPTH_STENCIL: 243 { 244 components = 1; 245 break; 246 } 247 248 default: 249 components = 0; 250 } 251 252 Py_ssize_t length = components * a2 * a3; 253 254 switch (a5) 255 { 256 case GL_FLOAT: 257 { 258 GLfloat *data = new GLfloat[length]; 259 260 sipCpp->glReadPixels(a0, a1, a2, a3, a4, a5, data); 261 sipRes = qpyopengl_from_GLfloat(&sipIsErr, data, length); 262 delete [] data; 263 264 break; 265 } 266 267 case GL_INT: 268 { 269 GLint *data = new GLint[length]; 270 271 sipCpp->glReadPixels(a0, a1, a2, a3, a4, a5, data); 272 sipRes = qpyopengl_from_GLint(&sipIsErr, data, length); 273 delete [] data; 274 275 break; 276 } 277 278 case GL_UNSIGNED_INT: 279 case GL_UNSIGNED_INT_8_8_8_8: 280 case GL_UNSIGNED_INT_8_8_8_8_REV: 281 case GL_UNSIGNED_INT_10_10_10_2: 282 case GL_UNSIGNED_INT_2_10_10_10_REV: 283 case GL_UNSIGNED_INT_24_8: 284 case GL_UNSIGNED_INT_10F_11F_11F_REV: 285 case GL_UNSIGNED_INT_5_9_9_9_REV: 286 { 287 GLuint *data = new GLuint[length]; 288 289 sipCpp->glReadPixels(a0, a1, a2, a3, a4, a5, data); 290 sipRes = qpyopengl_from_GLuint(&sipIsErr, data, length); 291 delete [] data; 292 293 break; 294 } 295 296 case GL_SHORT: 297 case GL_UNSIGNED_SHORT: 298 case GL_UNSIGNED_SHORT_5_6_5: 299 case GL_UNSIGNED_SHORT_5_6_5_REV: 300 case GL_UNSIGNED_SHORT_4_4_4_4: 301 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 302 case GL_UNSIGNED_SHORT_5_5_5_1: 303 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 304 case GL_BYTE: 305 case GL_UNSIGNED_BYTE: 306 case GL_UNSIGNED_BYTE_3_3_2: 307 case GL_UNSIGNED_BYTE_2_3_3_REV: 308 case GL_HALF_FLOAT: 309 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 310 default: 311 sipIsErr = 1; 312 PyErr_SetString(PyExc_ValueError, "pixel data format not supported"); 313 } 314%End 315 316 void glReadBuffer(GLenum mode); 317 void glPixelStorei(GLenum pname, GLint param); 318 void glPixelStoref(GLenum pname, GLfloat param); 319 void glDepthFunc(GLenum func); 320 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); 321 void glStencilFunc(GLenum func, GLint ref, GLuint mask); 322 void glLogicOp(GLenum opcode); 323 void glBlendFunc(GLenum sfactor, GLenum dfactor); 324 void glFlush(); 325 void glFinish(); 326 void glEnable(GLenum cap); 327 void glDisable(GLenum cap); 328 void glDepthMask(GLboolean flag); 329 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); 330 void glStencilMask(GLuint mask); 331 void glClearDepth(GLdouble depth); 332 void glClearStencil(GLint s); 333 void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); 334 void glClear(GLbitfield mask); 335 void glDrawBuffer(GLenum mode); 336 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"/); 337%MethodCode 338 const GLvoid *array = qpyopengl_value_array(&sipError, a8, a7, sipSelf); 339 340 if (sipError == sipErrorNone) 341 sipCpp->glTexImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array); 342%End 343 344 void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/); 345%MethodCode 346 const GLvoid *array = qpyopengl_value_array(&sipError, a7, a6, sipSelf); 347 348 if (sipError == sipErrorNone) 349 sipCpp->glTexImage1D(a0, a1, a2, a3, a4, a5, a6, array); 350%End 351 352 void glTexParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 353%MethodCode 354 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 355 356 if (sipError == sipErrorNone) 357 sipCpp->glTexParameteriv(a0, a1, reinterpret_cast<const GLint *>(array)); 358%End 359 360 void glTexParameteri(GLenum target, GLenum pname, GLint param); 361 void glTexParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 362%MethodCode 363 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 364 365 if (sipError == sipErrorNone) 366 sipCpp->glTexParameterfv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 367%End 368 369 void glTexParameterf(GLenum target, GLenum pname, GLfloat param); 370 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); 371 void glPolygonMode(GLenum face, GLenum mode); 372 void glPointSize(GLfloat size); 373 void glLineWidth(GLfloat width); 374 void glHint(GLenum target, GLenum mode); 375 void glFrontFace(GLenum mode); 376 void glCullFace(GLenum mode); 377 void glIndexubv(SIP_PYOBJECT c /TypeHint="PYQT_OPENGL_ARRAY"/); 378%MethodCode 379 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE, 380 sipSelf); 381 382 if (sipError == sipErrorNone) 383 sipCpp->glIndexubv(reinterpret_cast<const GLubyte *>(array)); 384%End 385 386 void glIndexub(GLubyte c); 387 GLboolean glIsTexture(GLuint texture); 388 void glGenTextures(GLsizei n, SIP_PYOBJECT *textures /TypeHint="Union[int, Tuple[int, ...]]"/); 389%MethodCode 390 GLuint *params = new GLuint[a0]; 391 392 sipCpp->glGenTextures(a0, params); 393 394 a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0); 395 396 delete[] params; 397%End 398 399 void glDeleteTextures(GLsizei n, SIP_PYOBJECT textures /TypeHint="PYQT_OPENGL_ARRAY"/); 400%MethodCode 401 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT, 402 sipSelf); 403 404 if (sipError == sipErrorNone) 405 sipCpp->glDeleteTextures(a0, reinterpret_cast<const GLuint *>(array)); 406%End 407 408 void glBindTexture(GLenum target, GLuint texture); 409 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"/); 410%MethodCode 411 const GLvoid *array = qpyopengl_value_array(&sipError, a8, a7, sipSelf); 412 413 if (sipError == sipErrorNone) 414 sipCpp->glTexSubImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array); 415%End 416 417 void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/); 418%MethodCode 419 const GLvoid *array = qpyopengl_value_array(&sipError, a6, a5, sipSelf); 420 421 if (sipError == sipErrorNone) 422 sipCpp->glTexSubImage1D(a0, a1, a2, a3, a4, a5, array); 423%End 424 425 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); 426 void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); 427 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); 428 void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); 429 void glPolygonOffset(GLfloat factor, GLfloat units); 430 void glDrawElements(GLenum mode, GLsizei count, GLenum type, SIP_PYOBJECT indices /TypeHint="PYQT_OPENGL_ARRAY"/); 431%MethodCode 432 const GLvoid *array = qpyopengl_value_array(&sipError, a3, a2, sipSelf); 433 434 if (sipError == sipErrorNone) 435 sipCpp->glDrawElements(a0, a1, a2, array); 436%End 437 438 void glDrawArrays(GLenum mode, GLint first, GLsizei count); 439 void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); 440 void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/); 441%MethodCode 442 const GLvoid *array = qpyopengl_value_array(&sipError, a10, a9, sipSelf); 443 444 if (sipError == sipErrorNone) 445 sipCpp->glTexSubImage3D(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, array); 446%End 447 448 void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/); 449%MethodCode 450 const GLvoid *array = qpyopengl_value_array(&sipError, a9, a8, sipSelf); 451 452 if (sipError == sipErrorNone) 453 sipCpp->glTexImage3D(a0, a1, a2, a3, a4, a5, a6, a7, a8, array); 454%End 455 456 void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, SIP_PYOBJECT indices /TypeHint="PYQT_OPENGL_ARRAY"/); 457%MethodCode 458 const GLvoid *array = qpyopengl_value_array(&sipError, a5, a4, sipSelf); 459 460 if (sipError == sipErrorNone) 461 sipCpp->glDrawRangeElements(a0, a1, a2, a3, a4, array); 462%End 463 464 void glBlendEquation(GLenum mode); 465 void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); 466 void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 467%MethodCode 468 const GLvoid *array = qpyopengl_value_array(&sipError, a6, GL_UNSIGNED_BYTE, 469 sipSelf); 470 471 if (sipError == sipErrorNone) 472 sipCpp->glCompressedTexSubImage1D(a0, a1, a2, a3, a4, a5, array); 473%End 474 475 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"/); 476%MethodCode 477 const GLvoid *array = qpyopengl_value_array(&sipError, a8, GL_UNSIGNED_BYTE, 478 sipSelf); 479 480 if (sipError == sipErrorNone) 481 sipCpp->glCompressedTexSubImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array); 482%End 483 484 void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 485%MethodCode 486 const GLvoid *array = qpyopengl_value_array(&sipError, a10, GL_UNSIGNED_BYTE, 487 sipSelf); 488 489 if (sipError == sipErrorNone) 490 sipCpp->glCompressedTexSubImage3D(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, 491 array); 492%End 493 494 void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 495%MethodCode 496 const GLvoid *array = qpyopengl_value_array(&sipError, a6, GL_UNSIGNED_BYTE, 497 sipSelf); 498 499 if (sipError == sipErrorNone) 500 sipCpp->glCompressedTexImage1D(a0, a1, a2, a3, a4, a5, array); 501%End 502 503 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 504%MethodCode 505 const GLvoid *array = qpyopengl_value_array(&sipError, a7, GL_UNSIGNED_BYTE, 506 sipSelf); 507 508 if (sipError == sipErrorNone) 509 sipCpp->glCompressedTexImage2D(a0, a1, a2, a3, a4, a5, a6, array); 510%End 511 512 void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 513%MethodCode 514 const GLvoid *array = qpyopengl_value_array(&sipError, a8, GL_UNSIGNED_BYTE, 515 sipSelf); 516 517 if (sipError == sipErrorNone) 518 sipCpp->glCompressedTexImage3D(a0, a1, a2, a3, a4, a5, a6, a7, array); 519%End 520 521 void glSampleCoverage(GLfloat value, GLboolean invert); 522 void glActiveTexture(GLenum texture); 523 void glPointParameteriv(GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 524%MethodCode 525 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 526 527 if (sipError == sipErrorNone) 528 sipCpp->glPointParameteriv(a0, reinterpret_cast<const GLint *>(array)); 529%End 530 531 void glPointParameteri(GLenum pname, GLint param); 532 void glPointParameterfv(GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 533%MethodCode 534 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 535 536 if (sipError == sipErrorNone) 537 sipCpp->glPointParameterfv(a0, reinterpret_cast<const GLfloat *>(array)); 538%End 539 540 void glPointParameterf(GLenum pname, GLfloat param); 541 void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); 542 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params); 543 GLboolean glUnmapBuffer(GLenum target); 544 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 545%MethodCode 546 const GLvoid *array; 547 548 if (a3 == Py_None) 549 array = 0; 550 else 551 array = qpyopengl_value_array(&sipError, a3, GL_UNSIGNED_BYTE, sipSelf); 552 553 if (sipError == sipErrorNone) 554 sipCpp->glBufferSubData(a0, a1, a2, array); 555%End 556 557 void glBufferData(GLenum target, GLsizeiptr size, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/, GLenum usage); 558%MethodCode 559 const GLvoid *array; 560 561 if (a2 == Py_None) 562 array = 0; 563 else 564 array = qpyopengl_value_array(&sipError, a2, GL_UNSIGNED_BYTE, sipSelf); 565 566 if (sipError == sipErrorNone) 567 sipCpp->glBufferData(a0, a1, array, a3); 568%End 569 570 GLboolean glIsBuffer(GLuint buffer); 571 void glGenBuffers(GLsizei n, SIP_PYOBJECT *buffers /TypeHint="Union[int, Tuple[int, ...]]"/); 572%MethodCode 573 GLuint *params = new GLuint[a0]; 574 575 sipCpp->glGenBuffers(a0, params); 576 577 a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0); 578 579 delete[] params; 580%End 581 582 void glDeleteBuffers(GLsizei n, SIP_PYOBJECT buffers /TypeHint="PYQT_OPENGL_ARRAY"/); 583%MethodCode 584 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT, 585 sipSelf); 586 587 if (sipError == sipErrorNone) 588 sipCpp->glDeleteBuffers(a0, reinterpret_cast<const GLuint *>(array)); 589%End 590 591 void glBindBuffer(GLenum target, GLuint buffer); 592 void glGetQueryiv(GLenum target, GLenum pname, GLint *params); 593 void glEndQuery(GLenum target); 594 void glBeginQuery(GLenum target, GLuint id); 595 GLboolean glIsQuery(GLuint id); 596 void glDeleteQueries(GLsizei n, SIP_PYOBJECT ids /TypeHint="PYQT_OPENGL_ARRAY"/); 597%MethodCode 598 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT, 599 sipSelf); 600 601 if (sipError == sipErrorNone) 602 sipCpp->glDeleteQueries(a0, reinterpret_cast<const GLuint *>(array)); 603%End 604 605 void glGenQueries(GLsizei n, SIP_PYOBJECT *ids /TypeHint="Union[int, Tuple[int, ...]]"/); 606%MethodCode 607 GLuint *params = new GLuint[a0]; 608 609 sipCpp->glGenQueries(a0, params); 610 611 a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0); 612 613 delete[] params; 614%End 615 616 void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 617%MethodCode 618 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a5, a2, sipSelf, 619 "VertexAttribPointer", a0); 620 621 if (sipError == sipErrorNone) 622 sipCpp->glVertexAttribPointer(a0, a1, a2, a3, a4, array); 623%End 624 625 void glValidateProgram(GLuint program); 626 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 627%MethodCode 628 const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf); 629 630 if (sipError == sipErrorNone) 631 sipCpp->glUniformMatrix4fv(a0, a1, a2, 632 reinterpret_cast<const GLfloat *>(array)); 633%End 634 635 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 636%MethodCode 637 const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf); 638 639 if (sipError == sipErrorNone) 640 sipCpp->glUniformMatrix3fv(a0, a1, a2, 641 reinterpret_cast<const GLfloat *>(array)); 642%End 643 644 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 645%MethodCode 646 const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf); 647 648 if (sipError == sipErrorNone) 649 sipCpp->glUniformMatrix2fv(a0, a1, a2, 650 reinterpret_cast<const GLfloat *>(array)); 651%End 652 653 void glUniform4iv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 654%MethodCode 655 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 656 657 if (sipError == sipErrorNone) 658 sipCpp->glUniform4iv(a0, a1, reinterpret_cast<const GLint *>(array)); 659%End 660 661 void glUniform3iv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 662%MethodCode 663 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 664 665 if (sipError == sipErrorNone) 666 sipCpp->glUniform3iv(a0, a1, reinterpret_cast<const GLint *>(array)); 667%End 668 669 void glUniform2iv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 670%MethodCode 671 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 672 673 if (sipError == sipErrorNone) 674 sipCpp->glUniform2iv(a0, a1, reinterpret_cast<const GLint *>(array)); 675%End 676 677 void glUniform1iv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 678%MethodCode 679 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 680 681 if (sipError == sipErrorNone) 682 sipCpp->glUniform1iv(a0, a1, reinterpret_cast<const GLint *>(array)); 683%End 684 685 void glUniform4fv(GLint location, GLsizei count, SIP_PYOBJECT value /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->glUniform4fv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 691%End 692 693 void glUniform3fv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 694%MethodCode 695 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 696 697 if (sipError == sipErrorNone) 698 sipCpp->glUniform3fv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 699%End 700 701 void glUniform2fv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 702%MethodCode 703 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 704 705 if (sipError == sipErrorNone) 706 sipCpp->glUniform2fv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 707%End 708 709 void glUniform1fv(GLint location, GLsizei count, SIP_PYOBJECT value /TypeHint="PYQT_OPENGL_ARRAY"/); 710%MethodCode 711 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 712 713 if (sipError == sipErrorNone) 714 sipCpp->glUniform1fv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 715%End 716 717 void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); 718 void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2); 719 void glUniform2i(GLint location, GLint v0, GLint v1); 720 void glUniform1i(GLint location, GLint v0); 721 void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); 722 void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); 723 void glUniform2f(GLint location, GLfloat v0, GLfloat v1); 724 void glUniform1f(GLint location, GLfloat v0); 725 void glUseProgram(GLuint program); 726 void glLinkProgram(GLuint program); 727 GLboolean glIsShader(GLuint shader); 728 GLboolean glIsProgram(GLuint program); 729 void glGetVertexAttribiv(GLuint index, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/); 730%MethodCode 731 GLint params[4]; 732 Py_ssize_t nr_params; 733 734 switch (a1) 735 { 736 case GL_CURRENT_VERTEX_ATTRIB: 737 nr_params = 4; 738 break; 739 740 default: 741 nr_params = 1; 742 } 743 744 sipCpp->glGetVertexAttribiv(a0, a1, params); 745 746 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 747%End 748 749 void glGetVertexAttribfv(GLuint index, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 750%MethodCode 751 GLfloat params[4]; 752 Py_ssize_t nr_params; 753 754 switch (a1) 755 { 756 case GL_CURRENT_VERTEX_ATTRIB: 757 nr_params = 4; 758 break; 759 760 default: 761 nr_params = 1; 762 } 763 764 sipCpp->glGetVertexAttribfv(a0, a1, params); 765 766 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 767%End 768 769 void glGetVertexAttribdv(GLuint index, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 770%MethodCode 771 GLdouble params[4]; 772 Py_ssize_t nr_params; 773 774 switch (a1) 775 { 776 case GL_CURRENT_VERTEX_ATTRIB: 777 nr_params = 4; 778 break; 779 780 default: 781 nr_params = 1; 782 } 783 784 sipCpp->glGetVertexAttribdv(a0, a1, params); 785 786 a2 = qpyopengl_from_GLdouble(&sipIsErr, params, nr_params); 787%End 788 789 GLint glGetUniformLocation(GLuint program, const GLchar *name); 790 SIP_PYOBJECT glGetShaderSource(GLuint shader) /TypeHint="Py_v3:bytes;str"/; 791%MethodCode 792 GLint bufsize; 793 794 sipCpp->glGetShaderiv(a0, GL_SHADER_SOURCE_LENGTH, &bufsize); 795 796 if (bufsize > 0) 797 { 798 GLchar *source = new GLchar[bufsize]; 799 800 sipCpp->glGetShaderSource(a0, bufsize, 0, source); 801 sipRes = SIPBytes_FromString(source); 802 803 delete[] source; 804 } 805 else 806 { 807 sipRes = SIPBytes_FromString(""); 808 } 809%End 810 811 SIP_PYOBJECT glGetShaderInfoLog(GLuint shader) /TypeHint="Py_v3:bytes;str"/; 812%MethodCode 813 GLint bufsize; 814 815 sipCpp->glGetShaderiv(a0, GL_INFO_LOG_LENGTH, &bufsize); 816 817 if (bufsize > 0) 818 { 819 GLchar *log = new GLchar[bufsize]; 820 821 sipCpp->glGetShaderInfoLog(a0, bufsize, 0, log); 822 sipRes = SIPBytes_FromString(log); 823 824 delete[] log; 825 } 826 else 827 { 828 sipRes = SIPBytes_FromString(""); 829 } 830%End 831 832 void glGetShaderiv(GLuint shader, GLenum pname, GLint *params); 833 SIP_PYOBJECT glGetProgramInfoLog(GLuint program) /TypeHint="Py_v3:bytes;str"/; 834%MethodCode 835 GLint bufsize; 836 837 sipCpp->glGetProgramiv(a0, GL_INFO_LOG_LENGTH, &bufsize); 838 839 if (bufsize > 0) 840 { 841 GLchar *log = new GLchar[bufsize]; 842 843 sipCpp->glGetProgramInfoLog(a0, bufsize, 0, log); 844 sipRes = SIPBytes_FromString(log); 845 846 delete[] log; 847 } 848 else 849 { 850 sipRes = SIPBytes_FromString(""); 851 } 852%End 853 854 void glGetProgramiv(GLuint program, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int]]"/); 855%MethodCode 856 GLint params[3]; 857 Py_ssize_t nr_params; 858 859 switch (a1) 860 { 861 #if defined(GL_COMPUTE_LOCAL_WORK_SIZE) 862 case GL_COMPUTE_LOCAL_WORK_SIZE: 863 nr_params = 3; 864 break; 865 #endif 866 867 default: 868 nr_params = 1; 869 } 870 871 sipCpp->glGetProgramiv(a0, a1, params); 872 873 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 874%End 875 876 GLint glGetAttribLocation(GLuint program, const GLchar *name); 877 SIP_PYOBJECT glGetAttachedShaders(GLuint program) /TypeHint="Tuple[int, ...]"/; 878%MethodCode 879 GLint nr_shaders; 880 881 sipCpp->glGetProgramiv(a0, GL_ATTACHED_SHADERS, &nr_shaders); 882 883 if (nr_shaders < 1) 884 { 885 sipRes = PyTuple_New(0); 886 } 887 else 888 { 889 GLuint *shaders = new GLuint[nr_shaders]; 890 891 sipCpp->glGetAttachedShaders(a0, nr_shaders, 0, shaders); 892 893 sipRes = PyTuple_New(nr_shaders); 894 895 if (sipRes) 896 { 897 for (GLint i = 0; i < nr_shaders; ++i) 898 { 899 PyObject *itm = SIPLong_FromLong(shaders[i]); 900 901 if (!itm) 902 { 903 Py_DECREF(sipRes); 904 sipRes = 0; 905 break; 906 } 907 908 PyTuple_SetItem(sipRes, i, itm); 909 } 910 } 911 912 delete[] shaders; 913 } 914 915 if (!sipRes) 916 sipIsErr = 1; 917%End 918 919 SIP_PYOBJECT glGetActiveUniform(GLuint program, GLuint index) /TypeHint="Tuple[str, int, int]"/; 920%MethodCode 921 GLint bufsize; 922 923 sipCpp->glGetProgramiv(a0, GL_ACTIVE_UNIFORM_MAX_LENGTH, &bufsize); 924 925 GLchar *name = new GLchar[bufsize]; 926 GLint size; 927 GLenum type; 928 929 sipCpp->glGetActiveUniform(a0, a1, bufsize, 0, &size, &type, name); 930 931 sipRes = Py_BuildValue("siI", name, size, type); 932 933 if (!sipRes) 934 sipIsErr = 1; 935 936 delete[] name; 937%End 938 939 SIP_PYOBJECT glGetActiveAttrib(GLuint program, GLuint index) /TypeHint="Tuple[str, int, int]"/; 940%MethodCode 941 GLint bufsize; 942 943 sipCpp->glGetProgramiv(a0, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &bufsize); 944 945 GLchar *name = new GLchar[bufsize]; 946 GLint size; 947 GLenum type; 948 949 sipCpp->glGetActiveAttrib(a0, a1, bufsize, 0, &size, &type, name); 950 951 sipRes = Py_BuildValue("siI", name, size, type); 952 953 if (!sipRes) 954 sipIsErr = 1; 955 956 delete[] name; 957%End 958 959 void glEnableVertexAttribArray(GLuint index); 960 void glDisableVertexAttribArray(GLuint index); 961 void glDetachShader(GLuint program, GLuint shader); 962 void glDeleteShader(GLuint shader); 963 void glDeleteProgram(GLuint program); 964 GLuint glCreateShader(GLenum type); 965 GLuint glCreateProgram(); 966 void glCompileShader(GLuint shader); 967 void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name); 968 void glAttachShader(GLuint program, GLuint shader); 969 void glStencilMaskSeparate(GLenum face, GLuint mask); 970 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); 971 void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); 972 void glDrawBuffers(GLsizei n, SIP_PYOBJECT bufs /TypeHint="PYQT_OPENGL_ARRAY"/); 973%MethodCode 974 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT, 975 sipSelf); 976 977 if (sipError == sipErrorNone) 978 sipCpp->glDrawBuffers(a0, reinterpret_cast<const GLenum *>(array)); 979%End 980 981 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); 982 void glTranslatef(GLfloat x, GLfloat y, GLfloat z); 983 void glTranslated(GLdouble x, GLdouble y, GLdouble z); 984 void glScalef(GLfloat x, GLfloat y, GLfloat z); 985 void glScaled(GLdouble x, GLdouble y, GLdouble z); 986 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); 987 void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); 988 void glPushMatrix(); 989 void glPopMatrix(); 990 void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); 991 void glMultMatrixd(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 992%MethodCode 993 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 994 995 if (sipError == sipErrorNone) 996 sipCpp->glMultMatrixd(reinterpret_cast<const GLdouble *>(array)); 997%End 998 999 void glMultMatrixf(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 1000%MethodCode 1001 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1002 1003 if (sipError == sipErrorNone) 1004 sipCpp->glMultMatrixf(reinterpret_cast<const GLfloat *>(array)); 1005%End 1006 1007 void glMatrixMode(GLenum mode); 1008 void glLoadMatrixd(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 1009%MethodCode 1010 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1011 1012 if (sipError == sipErrorNone) 1013 sipCpp->glLoadMatrixd(reinterpret_cast<const GLdouble *>(array)); 1014%End 1015 1016 void glLoadMatrixf(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 1017%MethodCode 1018 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1019 1020 if (sipError == sipErrorNone) 1021 sipCpp->glLoadMatrixf(reinterpret_cast<const GLfloat *>(array)); 1022%End 1023 1024 void glLoadIdentity(); 1025 void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); 1026 GLboolean glIsList(GLuint list); 1027 void glGetTexGeniv(GLenum coord, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/); 1028%MethodCode 1029 GLint params[4]; 1030 Py_ssize_t nr_params; 1031 1032 switch (a1) 1033 { 1034 case GL_OBJECT_PLANE: 1035 case GL_EYE_PLANE: 1036 nr_params = 4; 1037 break; 1038 1039 default: 1040 nr_params = 1; 1041 } 1042 1043 sipCpp->glGetTexGeniv(a0, a1, params); 1044 1045 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 1046%End 1047 1048 void glGetTexGenfv(GLenum coord, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 1049%MethodCode 1050 GLfloat params[4]; 1051 Py_ssize_t nr_params; 1052 1053 switch (a1) 1054 { 1055 case GL_OBJECT_PLANE: 1056 case GL_EYE_PLANE: 1057 nr_params = 4; 1058 break; 1059 1060 default: 1061 nr_params = 1; 1062 } 1063 1064 sipCpp->glGetTexGenfv(a0, a1, params); 1065 1066 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 1067%End 1068 1069 void glGetTexGendv(GLenum coord, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 1070%MethodCode 1071 GLdouble params[4]; 1072 Py_ssize_t nr_params; 1073 1074 switch (a1) 1075 { 1076 case GL_OBJECT_PLANE: 1077 case GL_EYE_PLANE: 1078 nr_params = 4; 1079 break; 1080 1081 default: 1082 nr_params = 1; 1083 } 1084 1085 sipCpp->glGetTexGendv(a0, a1, params); 1086 1087 a2 = qpyopengl_from_GLdouble(&sipIsErr, params, nr_params); 1088%End 1089 1090 void glGetTexEnviv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/); 1091%MethodCode 1092 GLint params[4]; 1093 Py_ssize_t nr_params; 1094 1095 switch (a1) 1096 { 1097 case GL_TEXTURE_ENV_COLOR: 1098 nr_params = 4; 1099 break; 1100 1101 default: 1102 nr_params = 1; 1103 } 1104 1105 sipCpp->glGetTexEnviv(a0, a1, params); 1106 1107 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 1108%End 1109 1110 void glGetTexEnvfv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 1111%MethodCode 1112 GLfloat params[4]; 1113 Py_ssize_t nr_params; 1114 1115 switch (a1) 1116 { 1117 case GL_TEXTURE_ENV_COLOR: 1118 nr_params = 4; 1119 break; 1120 1121 default: 1122 nr_params = 1; 1123 } 1124 1125 sipCpp->glGetTexEnvfv(a0, a1, params); 1126 1127 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 1128%End 1129 1130 void glGetMaterialiv(GLenum face, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int], Tuple[int, int, int, int]]"/); 1131%MethodCode 1132 GLint params[4]; 1133 Py_ssize_t nr_params; 1134 1135 switch (a1) 1136 { 1137 case GL_SHININESS: 1138 nr_params = 1; 1139 break; 1140 1141 case GL_COLOR_INDEXES: 1142 nr_params = 3; 1143 break; 1144 1145 default: 1146 nr_params = 4; 1147 } 1148 1149 sipCpp->glGetMaterialiv(a0, a1, params); 1150 1151 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 1152%End 1153 1154 void glGetMaterialfv(GLenum face, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float], Tuple[float, float, float, float]]"/); 1155%MethodCode 1156 GLfloat params[4]; 1157 Py_ssize_t nr_params; 1158 1159 switch (a1) 1160 { 1161 case GL_SHININESS: 1162 nr_params = 1; 1163 break; 1164 1165 case GL_COLOR_INDEXES: 1166 nr_params = 3; 1167 break; 1168 1169 default: 1170 nr_params = 4; 1171 } 1172 1173 sipCpp->glGetMaterialfv(a0, a1, params); 1174 1175 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 1176%End 1177 1178 void glGetLightiv(GLenum light, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int], Tuple[int, int, int, int]]"/); 1179%MethodCode 1180 GLint params[4]; 1181 Py_ssize_t nr_params; 1182 1183 switch (a1) 1184 { 1185 case GL_AMBIENT: 1186 case GL_DIFFUSE: 1187 case GL_SPECULAR: 1188 case GL_POSITION: 1189 nr_params = 4; 1190 break; 1191 1192 case GL_SPOT_DIRECTION: 1193 nr_params = 3; 1194 break; 1195 1196 default: 1197 nr_params = 1; 1198 } 1199 1200 sipCpp->glGetLightiv(a0, a1, params); 1201 1202 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 1203%End 1204 1205 void glGetLightfv(GLenum light, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float], Tuple[float, float, float, float]]"/); 1206%MethodCode 1207 GLfloat params[4]; 1208 Py_ssize_t nr_params; 1209 1210 switch (a1) 1211 { 1212 case GL_AMBIENT: 1213 case GL_DIFFUSE: 1214 case GL_SPECULAR: 1215 case GL_POSITION: 1216 nr_params = 4; 1217 break; 1218 1219 case GL_SPOT_DIRECTION: 1220 nr_params = 3; 1221 break; 1222 1223 default: 1224 nr_params = 1; 1225 } 1226 1227 sipCpp->glGetLightfv(a0, a1, params); 1228 1229 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 1230%End 1231 1232 void glGetClipPlane(GLenum plane, SIP_PYOBJECT *equation /TypeHint="Tuple[float, float, float, float]"/); 1233%MethodCode 1234 GLdouble params[4]; 1235 1236 sipCpp->glGetClipPlane(a0, params); 1237 1238 a1 = qpyopengl_from_GLdouble(&sipIsErr, params, 4); 1239%End 1240 1241 void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, SIP_PYOBJECT pixels /TypeHint="PYQT_OPENGL_ARRAY"/); 1242%MethodCode 1243 const GLvoid *array = qpyopengl_value_array(&sipError, a4, a3, sipSelf); 1244 1245 if (sipError == sipErrorNone) 1246 sipCpp->glDrawPixels(a0, a1, a2, a3, array); 1247%End 1248 1249 void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); 1250 void glPixelMapusv(GLenum map, GLint mapsize, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/); 1251%MethodCode 1252 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_UNSIGNED_SHORT, 1253 sipSelf); 1254 1255 if (sipError == sipErrorNone) 1256 sipCpp->glPixelMapusv(a0, a1, reinterpret_cast<const GLushort *>(array)); 1257%End 1258 1259 void glPixelMapuiv(GLenum map, GLint mapsize, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/); 1260%MethodCode 1261 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_UNSIGNED_INT, 1262 sipSelf); 1263 1264 if (sipError == sipErrorNone) 1265 sipCpp->glPixelMapuiv(a0, a1, reinterpret_cast<const GLuint *>(array)); 1266%End 1267 1268 void glPixelMapfv(GLenum map, GLint mapsize, SIP_PYOBJECT values /TypeHint="PYQT_OPENGL_ARRAY"/); 1269%MethodCode 1270 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 1271 1272 if (sipError == sipErrorNone) 1273 sipCpp->glPixelMapfv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 1274%End 1275 1276 void glPixelTransferi(GLenum pname, GLint param); 1277 void glPixelTransferf(GLenum pname, GLfloat param); 1278 void glPixelZoom(GLfloat xfactor, GLfloat yfactor); 1279 void glAlphaFunc(GLenum func, GLfloat ref); 1280 void glEvalPoint2(GLint i, GLint j); 1281 void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); 1282 void glEvalPoint1(GLint i); 1283 void glEvalMesh1(GLenum mode, GLint i1, GLint i2); 1284 void glEvalCoord2fv(SIP_PYOBJECT u /TypeHint="PYQT_OPENGL_ARRAY"/); 1285%MethodCode 1286 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1287 1288 if (sipError == sipErrorNone) 1289 sipCpp->glEvalCoord2fv(reinterpret_cast<const GLfloat *>(array)); 1290%End 1291 1292 void glEvalCoord2f(GLfloat u, GLfloat v); 1293 void glEvalCoord2dv(SIP_PYOBJECT u /TypeHint="PYQT_OPENGL_ARRAY"/); 1294%MethodCode 1295 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1296 1297 if (sipError == sipErrorNone) 1298 sipCpp->glEvalCoord2dv(reinterpret_cast<const GLdouble *>(array)); 1299%End 1300 1301 void glEvalCoord2d(GLdouble u, GLdouble v); 1302 void glEvalCoord1fv(SIP_PYOBJECT u /TypeHint="PYQT_OPENGL_ARRAY"/); 1303%MethodCode 1304 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1305 1306 if (sipError == sipErrorNone) 1307 sipCpp->glEvalCoord1fv(reinterpret_cast<const GLfloat *>(array)); 1308%End 1309 1310 void glEvalCoord1f(GLfloat u); 1311 void glEvalCoord1dv(SIP_PYOBJECT u /TypeHint="PYQT_OPENGL_ARRAY"/); 1312%MethodCode 1313 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1314 1315 if (sipError == sipErrorNone) 1316 sipCpp->glEvalCoord1dv(reinterpret_cast<const GLdouble *>(array)); 1317%End 1318 1319 void glEvalCoord1d(GLdouble u); 1320 void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); 1321 void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); 1322 void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2); 1323 void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2); 1324 void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, SIP_PYOBJECT points /TypeHint="PYQT_OPENGL_ARRAY"/); 1325%MethodCode 1326 const GLvoid *array = qpyopengl_value_array(&sipError, a9, GL_FLOAT, sipSelf); 1327 1328 if (sipError == sipErrorNone) 1329 sipCpp->glMap2f(a0, a1, a2, a3, a4, a5, a6, a7, a8, 1330 reinterpret_cast<const GLfloat *>(array)); 1331%End 1332 1333 void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, SIP_PYOBJECT points /TypeHint="PYQT_OPENGL_ARRAY"/); 1334%MethodCode 1335 const GLvoid *array = qpyopengl_value_array(&sipError, a9, GL_DOUBLE, sipSelf); 1336 1337 if (sipError == sipErrorNone) 1338 sipCpp->glMap2d(a0, a1, a2, a3, a4, a5, a6, a7, a8, 1339 reinterpret_cast<const GLdouble *>(array)); 1340%End 1341 1342 void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, SIP_PYOBJECT points /TypeHint="PYQT_OPENGL_ARRAY"/); 1343%MethodCode 1344 const GLvoid *array = qpyopengl_value_array(&sipError, a5, GL_FLOAT, sipSelf); 1345 1346 if (sipError == sipErrorNone) 1347 sipCpp->glMap1f(a0, a1, a2, a3, a4, 1348 reinterpret_cast<const GLfloat *>(array)); 1349%End 1350 1351 void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, SIP_PYOBJECT points /TypeHint="PYQT_OPENGL_ARRAY"/); 1352%MethodCode 1353 const GLvoid *array = qpyopengl_value_array(&sipError, a5, GL_DOUBLE, sipSelf); 1354 1355 if (sipError == sipErrorNone) 1356 sipCpp->glMap1d(a0, a1, a2, a3, a4, 1357 reinterpret_cast<const GLdouble *>(array)); 1358%End 1359 1360 void glPushAttrib(GLbitfield mask); 1361 void glPopAttrib(); 1362 void glAccum(GLenum op, GLfloat value); 1363 void glIndexMask(GLuint mask); 1364 void glClearIndex(GLfloat c); 1365 void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); 1366 void glPushName(GLuint name); 1367 void glPopName(); 1368 void glPassThrough(GLfloat token); 1369 void glLoadName(GLuint name); 1370 void glInitNames(); 1371 GLint glRenderMode(GLenum mode); 1372 void glTexGeniv(GLenum coord, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1373%MethodCode 1374 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 1375 1376 if (sipError == sipErrorNone) 1377 sipCpp->glTexGeniv(a0, a1, reinterpret_cast<const GLint *>(array)); 1378%End 1379 1380 void glTexGeni(GLenum coord, GLenum pname, GLint param); 1381 void glTexGenfv(GLenum coord, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1382%MethodCode 1383 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 1384 1385 if (sipError == sipErrorNone) 1386 sipCpp->glTexGenfv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 1387%End 1388 1389 void glTexGenf(GLenum coord, GLenum pname, GLfloat param); 1390 void glTexGendv(GLenum coord, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1391%MethodCode 1392 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_DOUBLE, sipSelf); 1393 1394 if (sipError == sipErrorNone) 1395 sipCpp->glTexGendv(a0, a1, reinterpret_cast<const GLdouble *>(array)); 1396%End 1397 1398 void glTexGend(GLenum coord, GLenum pname, GLdouble param); 1399 void glTexEnviv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1400%MethodCode 1401 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 1402 1403 if (sipError == sipErrorNone) 1404 sipCpp->glTexEnviv(a0, a1, reinterpret_cast<const GLint *>(array)); 1405%End 1406 1407 void glTexEnvi(GLenum target, GLenum pname, GLint param); 1408 void glTexEnvfv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1409%MethodCode 1410 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 1411 1412 if (sipError == sipErrorNone) 1413 sipCpp->glTexEnvfv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 1414%End 1415 1416 void glTexEnvf(GLenum target, GLenum pname, GLfloat param); 1417 void glShadeModel(GLenum mode); 1418 void glPolygonStipple(SIP_PYOBJECT mask /TypeHint="PYQT_OPENGL_ARRAY"/); 1419%MethodCode 1420 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE, 1421 sipSelf); 1422 1423 if (sipError == sipErrorNone) 1424 sipCpp->glPolygonStipple(reinterpret_cast<const GLubyte *>(array)); 1425%End 1426 1427 void glMaterialiv(GLenum face, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1428%MethodCode 1429 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 1430 1431 if (sipError == sipErrorNone) 1432 sipCpp->glMaterialiv(a0, a1, reinterpret_cast<const GLint *>(array)); 1433%End 1434 1435 void glMateriali(GLenum face, GLenum pname, GLint param); 1436 void glMaterialfv(GLenum face, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1437%MethodCode 1438 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 1439 1440 if (sipError == sipErrorNone) 1441 sipCpp->glMaterialfv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 1442%End 1443 1444 void glMaterialf(GLenum face, GLenum pname, GLfloat param); 1445 void glLineStipple(GLint factor, GLushort pattern); 1446 void glLightModeliv(GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1447%MethodCode 1448 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 1449 1450 if (sipError == sipErrorNone) 1451 sipCpp->glLightModeliv(a0, reinterpret_cast<const GLint *>(array)); 1452%End 1453 1454 void glLightModeli(GLenum pname, GLint param); 1455 void glLightModelfv(GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1456%MethodCode 1457 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 1458 1459 if (sipError == sipErrorNone) 1460 sipCpp->glLightModelfv(a0, reinterpret_cast<const GLfloat *>(array)); 1461%End 1462 1463 void glLightModelf(GLenum pname, GLfloat param); 1464 void glLightiv(GLenum light, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1465%MethodCode 1466 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 1467 1468 if (sipError == sipErrorNone) 1469 sipCpp->glLightiv(a0, a1, reinterpret_cast<const GLint *>(array)); 1470%End 1471 1472 void glLighti(GLenum light, GLenum pname, GLint param); 1473 void glLightfv(GLenum light, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1474%MethodCode 1475 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 1476 1477 if (sipError == sipErrorNone) 1478 sipCpp->glLightfv(a0, a1, reinterpret_cast<const GLfloat *>(array)); 1479%End 1480 1481 void glLightf(GLenum light, GLenum pname, GLfloat param); 1482 void glFogiv(GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1483%MethodCode 1484 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 1485 1486 if (sipError == sipErrorNone) 1487 sipCpp->glFogiv(a0, reinterpret_cast<const GLint *>(array)); 1488%End 1489 1490 void glFogi(GLenum pname, GLint param); 1491 void glFogfv(GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 1492%MethodCode 1493 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 1494 1495 if (sipError == sipErrorNone) 1496 sipCpp->glFogfv(a0, reinterpret_cast<const GLfloat *>(array)); 1497%End 1498 1499 void glFogf(GLenum pname, GLfloat param); 1500 void glColorMaterial(GLenum face, GLenum mode); 1501 void glClipPlane(GLenum plane, SIP_PYOBJECT equation /TypeHint="PYQT_OPENGL_ARRAY"/); 1502%MethodCode 1503 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 1504 1505 if (sipError == sipErrorNone) 1506 sipCpp->glClipPlane(a0, reinterpret_cast<const GLdouble *>(array)); 1507%End 1508 1509 void glVertex4sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1510%MethodCode 1511 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1512 1513 if (sipError == sipErrorNone) 1514 sipCpp->glVertex4sv(reinterpret_cast<const GLshort *>(array)); 1515%End 1516 1517 void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w); 1518 void glVertex4iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1519%MethodCode 1520 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1521 1522 if (sipError == sipErrorNone) 1523 sipCpp->glVertex4iv(reinterpret_cast<const GLint *>(array)); 1524%End 1525 1526 void glVertex4i(GLint x, GLint y, GLint z, GLint w); 1527 void glVertex4fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1528%MethodCode 1529 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1530 1531 if (sipError == sipErrorNone) 1532 sipCpp->glVertex4fv(reinterpret_cast<const GLfloat *>(array)); 1533%End 1534 1535 void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); 1536 void glVertex4dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1537%MethodCode 1538 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1539 1540 if (sipError == sipErrorNone) 1541 sipCpp->glVertex4dv(reinterpret_cast<const GLdouble *>(array)); 1542%End 1543 1544 void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); 1545 void glVertex3sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1546%MethodCode 1547 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1548 1549 if (sipError == sipErrorNone) 1550 sipCpp->glVertex3sv(reinterpret_cast<const GLshort *>(array)); 1551%End 1552 1553 void glVertex3s(GLshort x, GLshort y, GLshort z); 1554 void glVertex3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1555%MethodCode 1556 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1557 1558 if (sipError == sipErrorNone) 1559 sipCpp->glVertex3iv(reinterpret_cast<const GLint *>(array)); 1560%End 1561 1562 void glVertex3i(GLint x, GLint y, GLint z); 1563 void glVertex3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1564%MethodCode 1565 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1566 1567 if (sipError == sipErrorNone) 1568 sipCpp->glVertex3fv(reinterpret_cast<const GLfloat *>(array)); 1569%End 1570 1571 void glVertex3f(GLfloat x, GLfloat y, GLfloat z); 1572 void glVertex3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1573%MethodCode 1574 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1575 1576 if (sipError == sipErrorNone) 1577 sipCpp->glVertex3dv(reinterpret_cast<const GLdouble *>(array)); 1578%End 1579 1580 void glVertex3d(GLdouble x, GLdouble y, GLdouble z); 1581 void glVertex2sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1582%MethodCode 1583 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1584 1585 if (sipError == sipErrorNone) 1586 sipCpp->glVertex2sv(reinterpret_cast<const GLshort *>(array)); 1587%End 1588 1589 void glVertex2s(GLshort x, GLshort y); 1590 void glVertex2iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1591%MethodCode 1592 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1593 1594 if (sipError == sipErrorNone) 1595 sipCpp->glVertex2iv(reinterpret_cast<const GLint *>(array)); 1596%End 1597 1598 void glVertex2i(GLint x, GLint y); 1599 void glVertex2fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1600%MethodCode 1601 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1602 1603 if (sipError == sipErrorNone) 1604 sipCpp->glVertex2fv(reinterpret_cast<const GLfloat *>(array)); 1605%End 1606 1607 void glVertex2f(GLfloat x, GLfloat y); 1608 void glVertex2dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1609%MethodCode 1610 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1611 1612 if (sipError == sipErrorNone) 1613 sipCpp->glVertex2dv(reinterpret_cast<const GLdouble *>(array)); 1614%End 1615 1616 void glVertex2d(GLdouble x, GLdouble y); 1617 void glTexCoord4sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1618%MethodCode 1619 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1620 1621 if (sipError == sipErrorNone) 1622 sipCpp->glTexCoord4sv(reinterpret_cast<const GLshort *>(array)); 1623%End 1624 1625 void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q); 1626 void glTexCoord4iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1627%MethodCode 1628 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1629 1630 if (sipError == sipErrorNone) 1631 sipCpp->glTexCoord4iv(reinterpret_cast<const GLint *>(array)); 1632%End 1633 1634 void glTexCoord4i(GLint s, GLint t, GLint r, GLint q); 1635 void glTexCoord4fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1636%MethodCode 1637 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1638 1639 if (sipError == sipErrorNone) 1640 sipCpp->glTexCoord4fv(reinterpret_cast<const GLfloat *>(array)); 1641%End 1642 1643 void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q); 1644 void glTexCoord4dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1645%MethodCode 1646 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1647 1648 if (sipError == sipErrorNone) 1649 sipCpp->glTexCoord4dv(reinterpret_cast<const GLdouble *>(array)); 1650%End 1651 1652 void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q); 1653 void glTexCoord3sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1654%MethodCode 1655 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1656 1657 if (sipError == sipErrorNone) 1658 sipCpp->glTexCoord3sv(reinterpret_cast<const GLshort *>(array)); 1659%End 1660 1661 void glTexCoord3s(GLshort s, GLshort t, GLshort r); 1662 void glTexCoord3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1663%MethodCode 1664 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1665 1666 if (sipError == sipErrorNone) 1667 sipCpp->glTexCoord3iv(reinterpret_cast<const GLint *>(array)); 1668%End 1669 1670 void glTexCoord3i(GLint s, GLint t, GLint r); 1671 void glTexCoord3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1672%MethodCode 1673 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1674 1675 if (sipError == sipErrorNone) 1676 sipCpp->glTexCoord3fv(reinterpret_cast<const GLfloat *>(array)); 1677%End 1678 1679 void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r); 1680 void glTexCoord3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1681%MethodCode 1682 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1683 1684 if (sipError == sipErrorNone) 1685 sipCpp->glTexCoord3dv(reinterpret_cast<const GLdouble *>(array)); 1686%End 1687 1688 void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r); 1689 void glTexCoord2sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1690%MethodCode 1691 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1692 1693 if (sipError == sipErrorNone) 1694 sipCpp->glTexCoord2sv(reinterpret_cast<const GLshort *>(array)); 1695%End 1696 1697 void glTexCoord2s(GLshort s, GLshort t); 1698 void glTexCoord2iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1699%MethodCode 1700 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1701 1702 if (sipError == sipErrorNone) 1703 sipCpp->glTexCoord2iv(reinterpret_cast<const GLint *>(array)); 1704%End 1705 1706 void glTexCoord2i(GLint s, GLint t); 1707 void glTexCoord2fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1708%MethodCode 1709 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1710 1711 if (sipError == sipErrorNone) 1712 sipCpp->glTexCoord2fv(reinterpret_cast<const GLfloat *>(array)); 1713%End 1714 1715 void glTexCoord2f(GLfloat s, GLfloat t); 1716 void glTexCoord2dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1717%MethodCode 1718 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1719 1720 if (sipError == sipErrorNone) 1721 sipCpp->glTexCoord2dv(reinterpret_cast<const GLdouble *>(array)); 1722%End 1723 1724 void glTexCoord2d(GLdouble s, GLdouble t); 1725 void glTexCoord1sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1726%MethodCode 1727 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1728 1729 if (sipError == sipErrorNone) 1730 sipCpp->glTexCoord1sv(reinterpret_cast<const GLshort *>(array)); 1731%End 1732 1733 void glTexCoord1s(GLshort s); 1734 void glTexCoord1iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1735%MethodCode 1736 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1737 1738 if (sipError == sipErrorNone) 1739 sipCpp->glTexCoord1iv(reinterpret_cast<const GLint *>(array)); 1740%End 1741 1742 void glTexCoord1i(GLint s); 1743 void glTexCoord1fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1744%MethodCode 1745 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1746 1747 if (sipError == sipErrorNone) 1748 sipCpp->glTexCoord1fv(reinterpret_cast<const GLfloat *>(array)); 1749%End 1750 1751 void glTexCoord1f(GLfloat s); 1752 void glTexCoord1dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1753%MethodCode 1754 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1755 1756 if (sipError == sipErrorNone) 1757 sipCpp->glTexCoord1dv(reinterpret_cast<const GLdouble *>(array)); 1758%End 1759 1760 void glTexCoord1d(GLdouble s); 1761 void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2); 1762 void glRecti(GLint x1, GLint y1, GLint x2, GLint y2); 1763 void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); 1764 void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); 1765 void glRasterPos4sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1766%MethodCode 1767 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1768 1769 if (sipError == sipErrorNone) 1770 sipCpp->glRasterPos4sv(reinterpret_cast<const GLshort *>(array)); 1771%End 1772 1773 void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w); 1774 void glRasterPos4iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1775%MethodCode 1776 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1777 1778 if (sipError == sipErrorNone) 1779 sipCpp->glRasterPos4iv(reinterpret_cast<const GLint *>(array)); 1780%End 1781 1782 void glRasterPos4i(GLint x, GLint y, GLint z, GLint w); 1783 void glRasterPos4fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1784%MethodCode 1785 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1786 1787 if (sipError == sipErrorNone) 1788 sipCpp->glRasterPos4fv(reinterpret_cast<const GLfloat *>(array)); 1789%End 1790 1791 void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); 1792 void glRasterPos4dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1793%MethodCode 1794 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1795 1796 if (sipError == sipErrorNone) 1797 sipCpp->glRasterPos4dv(reinterpret_cast<const GLdouble *>(array)); 1798%End 1799 1800 void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); 1801 void glRasterPos3sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1802%MethodCode 1803 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1804 1805 if (sipError == sipErrorNone) 1806 sipCpp->glRasterPos3sv(reinterpret_cast<const GLshort *>(array)); 1807%End 1808 1809 void glRasterPos3s(GLshort x, GLshort y, GLshort z); 1810 void glRasterPos3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1811%MethodCode 1812 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1813 1814 if (sipError == sipErrorNone) 1815 sipCpp->glRasterPos3iv(reinterpret_cast<const GLint *>(array)); 1816%End 1817 1818 void glRasterPos3i(GLint x, GLint y, GLint z); 1819 void glRasterPos3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1820%MethodCode 1821 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1822 1823 if (sipError == sipErrorNone) 1824 sipCpp->glRasterPos3fv(reinterpret_cast<const GLfloat *>(array)); 1825%End 1826 1827 void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z); 1828 void glRasterPos3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1829%MethodCode 1830 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1831 1832 if (sipError == sipErrorNone) 1833 sipCpp->glRasterPos3dv(reinterpret_cast<const GLdouble *>(array)); 1834%End 1835 1836 void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z); 1837 void glRasterPos2sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1838%MethodCode 1839 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1840 1841 if (sipError == sipErrorNone) 1842 sipCpp->glRasterPos2sv(reinterpret_cast<const GLshort *>(array)); 1843%End 1844 1845 void glRasterPos2s(GLshort x, GLshort y); 1846 void glRasterPos2iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1847%MethodCode 1848 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1849 1850 if (sipError == sipErrorNone) 1851 sipCpp->glRasterPos2iv(reinterpret_cast<const GLint *>(array)); 1852%End 1853 1854 void glRasterPos2i(GLint x, GLint y); 1855 void glRasterPos2fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1856%MethodCode 1857 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1858 1859 if (sipError == sipErrorNone) 1860 sipCpp->glRasterPos2fv(reinterpret_cast<const GLfloat *>(array)); 1861%End 1862 1863 void glRasterPos2f(GLfloat x, GLfloat y); 1864 void glRasterPos2dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1865%MethodCode 1866 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1867 1868 if (sipError == sipErrorNone) 1869 sipCpp->glRasterPos2dv(reinterpret_cast<const GLdouble *>(array)); 1870%End 1871 1872 void glRasterPos2d(GLdouble x, GLdouble y); 1873 void glNormal3sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1874%MethodCode 1875 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1876 1877 if (sipError == sipErrorNone) 1878 sipCpp->glNormal3sv(reinterpret_cast<const GLshort *>(array)); 1879%End 1880 1881 void glNormal3s(GLshort nx, GLshort ny, GLshort nz); 1882 void glNormal3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1883%MethodCode 1884 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1885 1886 if (sipError == sipErrorNone) 1887 sipCpp->glNormal3iv(reinterpret_cast<const GLint *>(array)); 1888%End 1889 1890 void glNormal3i(GLint nx, GLint ny, GLint nz); 1891 void glNormal3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1892%MethodCode 1893 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1894 1895 if (sipError == sipErrorNone) 1896 sipCpp->glNormal3fv(reinterpret_cast<const GLfloat *>(array)); 1897%End 1898 1899 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz); 1900 void glNormal3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1901%MethodCode 1902 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1903 1904 if (sipError == sipErrorNone) 1905 sipCpp->glNormal3dv(reinterpret_cast<const GLdouble *>(array)); 1906%End 1907 1908 void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz); 1909 void glNormal3bv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1910%MethodCode 1911 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_BYTE, sipSelf); 1912 1913 if (sipError == sipErrorNone) 1914 sipCpp->glNormal3bv(reinterpret_cast<const GLbyte *>(array)); 1915%End 1916 1917 void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz); 1918 void glIndexsv(SIP_PYOBJECT c /TypeHint="PYQT_OPENGL_ARRAY"/); 1919%MethodCode 1920 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1921 1922 if (sipError == sipErrorNone) 1923 sipCpp->glIndexsv(reinterpret_cast<const GLshort *>(array)); 1924%End 1925 1926 void glIndexs(GLshort c); 1927 void glIndexiv(SIP_PYOBJECT c /TypeHint="PYQT_OPENGL_ARRAY"/); 1928%MethodCode 1929 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 1930 1931 if (sipError == sipErrorNone) 1932 sipCpp->glIndexiv(reinterpret_cast<const GLint *>(array)); 1933%End 1934 1935 void glIndexi(GLint c); 1936 void glIndexfv(SIP_PYOBJECT c /TypeHint="PYQT_OPENGL_ARRAY"/); 1937%MethodCode 1938 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 1939 1940 if (sipError == sipErrorNone) 1941 sipCpp->glIndexfv(reinterpret_cast<const GLfloat *>(array)); 1942%End 1943 1944 void glIndexf(GLfloat c); 1945 void glIndexdv(SIP_PYOBJECT c /TypeHint="PYQT_OPENGL_ARRAY"/); 1946%MethodCode 1947 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 1948 1949 if (sipError == sipErrorNone) 1950 sipCpp->glIndexdv(reinterpret_cast<const GLdouble *>(array)); 1951%End 1952 1953 void glIndexd(GLdouble c); 1954 void glEnd(); 1955 void glEdgeFlagv(SIP_PYOBJECT flag /TypeHint="PYQT_OPENGL_ARRAY"/); 1956%MethodCode 1957 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE, 1958 sipSelf); 1959 1960 if (sipError == sipErrorNone) 1961 sipCpp->glEdgeFlagv(reinterpret_cast<const GLboolean *>(array)); 1962%End 1963 1964 void glEdgeFlag(GLboolean flag); 1965 void glColor4usv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1966%MethodCode 1967 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_SHORT, 1968 sipSelf); 1969 1970 if (sipError == sipErrorNone) 1971 sipCpp->glColor4usv(reinterpret_cast<const GLushort *>(array)); 1972%End 1973 1974 void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha); 1975 void glColor4uiv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1976%MethodCode 1977 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_INT, 1978 sipSelf); 1979 1980 if (sipError == sipErrorNone) 1981 sipCpp->glColor4uiv(reinterpret_cast<const GLuint *>(array)); 1982%End 1983 1984 void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha); 1985 void glColor4ubv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1986%MethodCode 1987 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE, 1988 sipSelf); 1989 1990 if (sipError == sipErrorNone) 1991 sipCpp->glColor4ubv(reinterpret_cast<const GLubyte *>(array)); 1992%End 1993 1994 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); 1995 void glColor4sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 1996%MethodCode 1997 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 1998 1999 if (sipError == sipErrorNone) 2000 sipCpp->glColor4sv(reinterpret_cast<const GLshort *>(array)); 2001%End 2002 2003 void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha); 2004 void glColor4iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2005%MethodCode 2006 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 2007 2008 if (sipError == sipErrorNone) 2009 sipCpp->glColor4iv(reinterpret_cast<const GLint *>(array)); 2010%End 2011 2012 void glColor4i(GLint red, GLint green, GLint blue, GLint alpha); 2013 void glColor4fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2014%MethodCode 2015 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2016 2017 if (sipError == sipErrorNone) 2018 sipCpp->glColor4fv(reinterpret_cast<const GLfloat *>(array)); 2019%End 2020 2021 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); 2022 void glColor4dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2023%MethodCode 2024 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2025 2026 if (sipError == sipErrorNone) 2027 sipCpp->glColor4dv(reinterpret_cast<const GLdouble *>(array)); 2028%End 2029 2030 void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); 2031 void glColor4bv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2032%MethodCode 2033 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_BYTE, sipSelf); 2034 2035 if (sipError == sipErrorNone) 2036 sipCpp->glColor4bv(reinterpret_cast<const GLbyte *>(array)); 2037%End 2038 2039 void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); 2040 void glColor3usv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2041%MethodCode 2042 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_SHORT, 2043 sipSelf); 2044 2045 if (sipError == sipErrorNone) 2046 sipCpp->glColor3usv(reinterpret_cast<const GLushort *>(array)); 2047%End 2048 2049 void glColor3us(GLushort red, GLushort green, GLushort blue); 2050 void glColor3uiv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2051%MethodCode 2052 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_INT, 2053 sipSelf); 2054 2055 if (sipError == sipErrorNone) 2056 sipCpp->glColor3uiv(reinterpret_cast<const GLuint *>(array)); 2057%End 2058 2059 void glColor3ui(GLuint red, GLuint green, GLuint blue); 2060 void glColor3ubv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2061%MethodCode 2062 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE, 2063 sipSelf); 2064 2065 if (sipError == sipErrorNone) 2066 sipCpp->glColor3ubv(reinterpret_cast<const GLubyte *>(array)); 2067%End 2068 2069 void glColor3ub(GLubyte red, GLubyte green, GLubyte blue); 2070 void glColor3sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2071%MethodCode 2072 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 2073 2074 if (sipError == sipErrorNone) 2075 sipCpp->glColor3sv(reinterpret_cast<const GLshort *>(array)); 2076%End 2077 2078 void glColor3s(GLshort red, GLshort green, GLshort blue); 2079 void glColor3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2080%MethodCode 2081 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 2082 2083 if (sipError == sipErrorNone) 2084 sipCpp->glColor3iv(reinterpret_cast<const GLint *>(array)); 2085%End 2086 2087 void glColor3i(GLint red, GLint green, GLint blue); 2088 void glColor3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2089%MethodCode 2090 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2091 2092 if (sipError == sipErrorNone) 2093 sipCpp->glColor3fv(reinterpret_cast<const GLfloat *>(array)); 2094%End 2095 2096 void glColor3f(GLfloat red, GLfloat green, GLfloat blue); 2097 void glColor3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2098%MethodCode 2099 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2100 2101 if (sipError == sipErrorNone) 2102 sipCpp->glColor3dv(reinterpret_cast<const GLdouble *>(array)); 2103%End 2104 2105 void glColor3d(GLdouble red, GLdouble green, GLdouble blue); 2106 void glColor3bv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2107%MethodCode 2108 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_BYTE, sipSelf); 2109 2110 if (sipError == sipErrorNone) 2111 sipCpp->glColor3bv(reinterpret_cast<const GLbyte *>(array)); 2112%End 2113 2114 void glColor3b(GLbyte red, GLbyte green, GLbyte blue); 2115 void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, SIP_PYOBJECT bitmap /TypeHint="PYQT_OPENGL_ARRAY"/); 2116%MethodCode 2117 const GLvoid *array = qpyopengl_value_array(&sipError, a6, GL_UNSIGNED_BYTE, 2118 sipSelf); 2119 2120 if (sipError == sipErrorNone) 2121 sipCpp->glBitmap(a0, a1, a2, a3, a4, a5, 2122 reinterpret_cast<const GLubyte *>(array)); 2123%End 2124 2125 void glBegin(GLenum mode); 2126 void glListBase(GLuint base); 2127 GLuint glGenLists(GLsizei range); 2128 void glDeleteLists(GLuint list, GLsizei range); 2129 void glCallList(GLuint list); 2130 void glEndList(); 2131 void glNewList(GLuint list, GLenum mode); 2132 void glPushClientAttrib(GLbitfield mask); 2133 void glPopClientAttrib(); 2134 void glVertexPointer(GLint size, GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 2135%MethodCode 2136 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a3, a1, sipSelf, 2137 "VertexPointer", 0); 2138 2139 if (sipError == sipErrorNone) 2140 sipCpp->glVertexPointer(a0, a1, a2, array); 2141%End 2142 2143 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 2144%MethodCode 2145 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a3, a1, sipSelf, 2146 "TexCoordPointer", 0); 2147 2148 if (sipError == sipErrorNone) 2149 sipCpp->glTexCoordPointer(a0, a1, a2, array); 2150%End 2151 2152 void glNormalPointer(GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 2153%MethodCode 2154 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a2, a0, sipSelf, 2155 "NormalPointer", 0); 2156 2157 if (sipError == sipErrorNone) 2158 sipCpp->glNormalPointer(a0, a1, array); 2159%End 2160 2161 void glIndexPointer(GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 2162%MethodCode 2163 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a2, a0, sipSelf, 2164 "IndexPointer", 0); 2165 2166 if (sipError == sipErrorNone) 2167 sipCpp->glIndexPointer(a0, a1, array); 2168%End 2169 2170 void glEnableClientState(GLenum array); 2171 void glEdgeFlagPointer(GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 2172%MethodCode 2173 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a1, 2174 GL_UNSIGNED_BYTE, sipSelf, "EdgeFlagPointer", 0); 2175 2176 if (sipError == sipErrorNone) 2177 sipCpp->glEdgeFlagPointer(a0, array); 2178%End 2179 2180 void glDisableClientState(GLenum array); 2181 void glColorPointer(GLint size, GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_BOUND_ARRAY"/); 2182%MethodCode 2183 const GLvoid *array = qpyopengl_value_array_cached(&sipError, a3, a1, sipSelf, 2184 "ColorPointer", 0); 2185 2186 if (sipError == sipErrorNone) 2187 sipCpp->glColorPointer(a0, a1, a2, array); 2188%End 2189 2190 void glArrayElement(GLint i); 2191 void glResetMinmax(GLenum target); 2192 void glResetHistogram(GLenum target); 2193 void glMinmax(GLenum target, GLenum internalformat, GLboolean sink); 2194 void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); 2195 void glGetConvolutionParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/); 2196%MethodCode 2197 GLint params[4]; 2198 Py_ssize_t nr_params; 2199 2200 switch (a1) 2201 { 2202 case GL_CONVOLUTION_BORDER_COLOR: 2203 case GL_CONVOLUTION_FILTER_SCALE: 2204 case GL_CONVOLUTION_FILTER_BIAS: 2205 nr_params = 4; 2206 break; 2207 2208 default: 2209 nr_params = 1; 2210 } 2211 2212 sipCpp->glGetConvolutionParameteriv(a0, a1, params); 2213 2214 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 2215%End 2216 2217 void glGetConvolutionParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 2218%MethodCode 2219 GLfloat params[4]; 2220 Py_ssize_t nr_params; 2221 2222 switch (a1) 2223 { 2224 case GL_CONVOLUTION_BORDER_COLOR: 2225 case GL_CONVOLUTION_FILTER_SCALE: 2226 case GL_CONVOLUTION_FILTER_BIAS: 2227 nr_params = 4; 2228 break; 2229 2230 default: 2231 nr_params = 1; 2232 } 2233 2234 sipCpp->glGetConvolutionParameterfv(a0, a1, params); 2235 2236 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 2237%End 2238 2239 void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); 2240 void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); 2241 void glConvolutionParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 2242%MethodCode 2243 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 2244 2245 if (sipError == sipErrorNone) 2246 sipCpp->glConvolutionParameteriv(a0, a1, 2247 reinterpret_cast<const GLint *>(array)); 2248%End 2249 2250 void glConvolutionParameteri(GLenum target, GLenum pname, GLint params); 2251 void glConvolutionParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 2252%MethodCode 2253 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 2254 2255 if (sipError == sipErrorNone) 2256 sipCpp->glConvolutionParameterfv(a0, a1, 2257 reinterpret_cast<const GLfloat *>(array)); 2258%End 2259 2260 void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params); 2261 void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, SIP_PYOBJECT image /TypeHint="PYQT_OPENGL_ARRAY"/); 2262%MethodCode 2263 const GLvoid *array = qpyopengl_value_array(&sipError, a6, a5, sipSelf); 2264 2265 if (sipError == sipErrorNone) 2266 sipCpp->glConvolutionFilter2D(a0, a1, a2, a3, a4, a5, array); 2267%End 2268 2269 void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, SIP_PYOBJECT image /TypeHint="PYQT_OPENGL_ARRAY"/); 2270%MethodCode 2271 const GLvoid *array = qpyopengl_value_array(&sipError, a5, a4, sipSelf); 2272 2273 if (sipError == sipErrorNone) 2274 sipCpp->glConvolutionFilter1D(a0, a1, a2, a3, a4, array); 2275%End 2276 2277 void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); 2278 void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, SIP_PYOBJECT data /TypeHint="PYQT_OPENGL_ARRAY"/); 2279%MethodCode 2280 const GLvoid *array = qpyopengl_value_array(&sipError, a5, a4, sipSelf); 2281 2282 if (sipError == sipErrorNone) 2283 sipCpp->glColorSubTable(a0, a1, a2, a3, a4, array); 2284%End 2285 2286 void glGetColorTableParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[int, Tuple[int, int, int, int]]"/); 2287%MethodCode 2288 GLint params[4]; 2289 Py_ssize_t nr_params; 2290 2291 switch (a1) 2292 { 2293 case GL_COLOR_TABLE: 2294 case GL_POST_CONVOLUTION_COLOR_TABLE: 2295 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 2296 nr_params = 4; 2297 break; 2298 2299 default: 2300 nr_params = 1; 2301 } 2302 2303 sipCpp->glGetColorTableParameteriv(a0, a1, params); 2304 2305 a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params); 2306%End 2307 2308 void glGetColorTableParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT *params /TypeHint="Union[float, Tuple[float, float, float, float]]"/); 2309%MethodCode 2310 GLfloat params[4]; 2311 Py_ssize_t nr_params; 2312 2313 switch (a1) 2314 { 2315 case GL_COLOR_TABLE: 2316 case GL_POST_CONVOLUTION_COLOR_TABLE: 2317 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 2318 nr_params = 4; 2319 break; 2320 2321 default: 2322 nr_params = 1; 2323 } 2324 2325 sipCpp->glGetColorTableParameterfv(a0, a1, params); 2326 2327 a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params); 2328%End 2329 2330 void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); 2331 void glColorTableParameteriv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 2332%MethodCode 2333 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf); 2334 2335 if (sipError == sipErrorNone) 2336 sipCpp->glColorTableParameteriv(a0, a1, 2337 reinterpret_cast<const GLint *>(array)); 2338%End 2339 2340 void glColorTableParameterfv(GLenum target, GLenum pname, SIP_PYOBJECT params /TypeHint="PYQT_OPENGL_ARRAY"/); 2341%MethodCode 2342 const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf); 2343 2344 if (sipError == sipErrorNone) 2345 sipCpp->glColorTableParameterfv(a0, a1, 2346 reinterpret_cast<const GLfloat *>(array)); 2347%End 2348 2349 void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, SIP_PYOBJECT table /TypeHint="PYQT_OPENGL_ARRAY"/); 2350%MethodCode 2351 const GLvoid *array = qpyopengl_value_array(&sipError, a5, a4, sipSelf); 2352 2353 if (sipError == sipErrorNone) 2354 sipCpp->glColorTable(a0, a1, a2, a3, a4, array); 2355%End 2356 2357 void glMultTransposeMatrixd(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 2358%MethodCode 2359 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2360 2361 if (sipError == sipErrorNone) 2362 sipCpp->glMultTransposeMatrixd(reinterpret_cast<const GLdouble *>(array)); 2363%End 2364 2365 void glMultTransposeMatrixf(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 2366%MethodCode 2367 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2368 2369 if (sipError == sipErrorNone) 2370 sipCpp->glMultTransposeMatrixf(reinterpret_cast<const GLfloat *>(array)); 2371%End 2372 2373 void glLoadTransposeMatrixd(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 2374%MethodCode 2375 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2376 2377 if (sipError == sipErrorNone) 2378 sipCpp->glLoadTransposeMatrixd(reinterpret_cast<const GLdouble *>(array)); 2379%End 2380 2381 void glLoadTransposeMatrixf(SIP_PYOBJECT m /TypeHint="PYQT_OPENGL_ARRAY"/); 2382%MethodCode 2383 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2384 2385 if (sipError == sipErrorNone) 2386 sipCpp->glLoadTransposeMatrixf(reinterpret_cast<const GLfloat *>(array)); 2387%End 2388 2389 void glMultiTexCoord4sv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2390%MethodCode 2391 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2392 2393 if (sipError == sipErrorNone) 2394 sipCpp->glMultiTexCoord4sv(a0, reinterpret_cast<const GLshort *>(array)); 2395%End 2396 2397 void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); 2398 void glMultiTexCoord4iv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2399%MethodCode 2400 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 2401 2402 if (sipError == sipErrorNone) 2403 sipCpp->glMultiTexCoord4iv(a0, reinterpret_cast<const GLint *>(array)); 2404%End 2405 2406 void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q); 2407 void glMultiTexCoord4fv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2408%MethodCode 2409 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2410 2411 if (sipError == sipErrorNone) 2412 sipCpp->glMultiTexCoord4fv(a0, reinterpret_cast<const GLfloat *>(array)); 2413%End 2414 2415 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); 2416 void glMultiTexCoord4dv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2417%MethodCode 2418 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2419 2420 if (sipError == sipErrorNone) 2421 sipCpp->glMultiTexCoord4dv(a0, reinterpret_cast<const GLdouble *>(array)); 2422%End 2423 2424 void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); 2425 void glMultiTexCoord3sv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2426%MethodCode 2427 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2428 2429 if (sipError == sipErrorNone) 2430 sipCpp->glMultiTexCoord3sv(a0, reinterpret_cast<const GLshort *>(array)); 2431%End 2432 2433 void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r); 2434 void glMultiTexCoord3iv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2435%MethodCode 2436 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 2437 2438 if (sipError == sipErrorNone) 2439 sipCpp->glMultiTexCoord3iv(a0, reinterpret_cast<const GLint *>(array)); 2440%End 2441 2442 void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r); 2443 void glMultiTexCoord3fv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2444%MethodCode 2445 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2446 2447 if (sipError == sipErrorNone) 2448 sipCpp->glMultiTexCoord3fv(a0, reinterpret_cast<const GLfloat *>(array)); 2449%End 2450 2451 void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r); 2452 void glMultiTexCoord3dv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2453%MethodCode 2454 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2455 2456 if (sipError == sipErrorNone) 2457 sipCpp->glMultiTexCoord3dv(a0, reinterpret_cast<const GLdouble *>(array)); 2458%End 2459 2460 void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r); 2461 void glMultiTexCoord2sv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2462%MethodCode 2463 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2464 2465 if (sipError == sipErrorNone) 2466 sipCpp->glMultiTexCoord2sv(a0, reinterpret_cast<const GLshort *>(array)); 2467%End 2468 2469 void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t); 2470 void glMultiTexCoord2iv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2471%MethodCode 2472 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 2473 2474 if (sipError == sipErrorNone) 2475 sipCpp->glMultiTexCoord2iv(a0, reinterpret_cast<const GLint *>(array)); 2476%End 2477 2478 void glMultiTexCoord2i(GLenum target, GLint s, GLint t); 2479 void glMultiTexCoord2fv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2480%MethodCode 2481 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2482 2483 if (sipError == sipErrorNone) 2484 sipCpp->glMultiTexCoord2fv(a0, reinterpret_cast<const GLfloat *>(array)); 2485%End 2486 2487 void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t); 2488 void glMultiTexCoord2dv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2489%MethodCode 2490 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2491 2492 if (sipError == sipErrorNone) 2493 sipCpp->glMultiTexCoord2dv(a0, reinterpret_cast<const GLdouble *>(array)); 2494%End 2495 2496 void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t); 2497 void glMultiTexCoord1sv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2498%MethodCode 2499 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2500 2501 if (sipError == sipErrorNone) 2502 sipCpp->glMultiTexCoord1sv(a0, reinterpret_cast<const GLshort *>(array)); 2503%End 2504 2505 void glMultiTexCoord1s(GLenum target, GLshort s); 2506 void glMultiTexCoord1iv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2507%MethodCode 2508 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 2509 2510 if (sipError == sipErrorNone) 2511 sipCpp->glMultiTexCoord1iv(a0, reinterpret_cast<const GLint *>(array)); 2512%End 2513 2514 void glMultiTexCoord1i(GLenum target, GLint s); 2515 void glMultiTexCoord1fv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2516%MethodCode 2517 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2518 2519 if (sipError == sipErrorNone) 2520 sipCpp->glMultiTexCoord1fv(a0, reinterpret_cast<const GLfloat *>(array)); 2521%End 2522 2523 void glMultiTexCoord1f(GLenum target, GLfloat s); 2524 void glMultiTexCoord1dv(GLenum target, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2525%MethodCode 2526 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2527 2528 if (sipError == sipErrorNone) 2529 sipCpp->glMultiTexCoord1dv(a0, reinterpret_cast<const GLdouble *>(array)); 2530%End 2531 2532 void glMultiTexCoord1d(GLenum target, GLdouble s); 2533 void glClientActiveTexture(GLenum texture); 2534 void glWindowPos3sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2535%MethodCode 2536 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 2537 2538 if (sipError == sipErrorNone) 2539 sipCpp->glWindowPos3sv(reinterpret_cast<const GLshort *>(array)); 2540%End 2541 2542 void glWindowPos3s(GLshort x, GLshort y, GLshort z); 2543 void glWindowPos3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2544%MethodCode 2545 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 2546 2547 if (sipError == sipErrorNone) 2548 sipCpp->glWindowPos3iv(reinterpret_cast<const GLint *>(array)); 2549%End 2550 2551 void glWindowPos3i(GLint x, GLint y, GLint z); 2552 void glWindowPos3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2553%MethodCode 2554 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2555 2556 if (sipError == sipErrorNone) 2557 sipCpp->glWindowPos3fv(reinterpret_cast<const GLfloat *>(array)); 2558%End 2559 2560 void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z); 2561 void glWindowPos3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2562%MethodCode 2563 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2564 2565 if (sipError == sipErrorNone) 2566 sipCpp->glWindowPos3dv(reinterpret_cast<const GLdouble *>(array)); 2567%End 2568 2569 void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z); 2570 void glWindowPos2sv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2571%MethodCode 2572 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 2573 2574 if (sipError == sipErrorNone) 2575 sipCpp->glWindowPos2sv(reinterpret_cast<const GLshort *>(array)); 2576%End 2577 2578 void glWindowPos2s(GLshort x, GLshort y); 2579 void glWindowPos2iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2580%MethodCode 2581 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 2582 2583 if (sipError == sipErrorNone) 2584 sipCpp->glWindowPos2iv(reinterpret_cast<const GLint *>(array)); 2585%End 2586 2587 void glWindowPos2i(GLint x, GLint y); 2588 void glWindowPos2fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2589%MethodCode 2590 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2591 2592 if (sipError == sipErrorNone) 2593 sipCpp->glWindowPos2fv(reinterpret_cast<const GLfloat *>(array)); 2594%End 2595 2596 void glWindowPos2f(GLfloat x, GLfloat y); 2597 void glWindowPos2dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2598%MethodCode 2599 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2600 2601 if (sipError == sipErrorNone) 2602 sipCpp->glWindowPos2dv(reinterpret_cast<const GLdouble *>(array)); 2603%End 2604 2605 void glWindowPos2d(GLdouble x, GLdouble y); 2606 void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_ARRAY"/); 2607%MethodCode 2608 const GLvoid *array = qpyopengl_value_array(&sipError, a3, a1, sipSelf); 2609 2610 if (sipError == sipErrorNone) 2611 sipCpp->glSecondaryColorPointer(a0, a1, a2, array); 2612%End 2613 2614 void glSecondaryColor3usv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2615%MethodCode 2616 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_SHORT, 2617 sipSelf); 2618 2619 if (sipError == sipErrorNone) 2620 sipCpp->glSecondaryColor3usv(reinterpret_cast<const GLushort *>(array)); 2621%End 2622 2623 void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue); 2624 void glSecondaryColor3uiv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2625%MethodCode 2626 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_INT, 2627 sipSelf); 2628 2629 if (sipError == sipErrorNone) 2630 sipCpp->glSecondaryColor3uiv(reinterpret_cast<const GLuint *>(array)); 2631%End 2632 2633 void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue); 2634 void glSecondaryColor3ubv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2635%MethodCode 2636 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE, 2637 sipSelf); 2638 2639 if (sipError == sipErrorNone) 2640 sipCpp->glSecondaryColor3ubv(reinterpret_cast<const GLubyte *>(array)); 2641%End 2642 2643 void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue); 2644 void glSecondaryColor3sv(SIP_PYBUFFER v /TypeHint="PYQT_OPENGL_ARRAY"/); 2645%MethodCode 2646 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_SHORT, sipSelf); 2647 2648 if (sipError == sipErrorNone) 2649 sipCpp->glSecondaryColor3sv(reinterpret_cast<const GLshort *>(array)); 2650%End 2651 2652 void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue); 2653 void glSecondaryColor3iv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2654%MethodCode 2655 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_INT, sipSelf); 2656 2657 if (sipError == sipErrorNone) 2658 sipCpp->glSecondaryColor3iv(reinterpret_cast<const GLint *>(array)); 2659%End 2660 2661 void glSecondaryColor3i(GLint red, GLint green, GLint blue); 2662 void glSecondaryColor3fv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2663%MethodCode 2664 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2665 2666 if (sipError == sipErrorNone) 2667 sipCpp->glSecondaryColor3fv(reinterpret_cast<const GLfloat *>(array)); 2668%End 2669 2670 void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue); 2671 void glSecondaryColor3dv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2672%MethodCode 2673 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2674 2675 if (sipError == sipErrorNone) 2676 sipCpp->glSecondaryColor3dv(reinterpret_cast<const GLdouble *>(array)); 2677%End 2678 2679 void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue); 2680 void glSecondaryColor3bv(SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2681%MethodCode 2682 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_BYTE, sipSelf); 2683 2684 if (sipError == sipErrorNone) 2685 sipCpp->glSecondaryColor3bv(reinterpret_cast<const GLbyte *>(array)); 2686%End 2687 2688 void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue); 2689 void glFogCoordPointer(GLenum type, GLsizei stride, SIP_PYOBJECT pointer /TypeHint="PYQT_OPENGL_ARRAY"/); 2690%MethodCode 2691 const GLvoid *array = qpyopengl_value_array(&sipError, a2, a0, sipSelf); 2692 2693 if (sipError == sipErrorNone) 2694 sipCpp->glFogCoordPointer(a0, a1, array); 2695%End 2696 2697 void glFogCoorddv(SIP_PYOBJECT coord /TypeHint="PYQT_OPENGL_ARRAY"/); 2698%MethodCode 2699 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_DOUBLE, sipSelf); 2700 2701 if (sipError == sipErrorNone) 2702 sipCpp->glFogCoorddv(reinterpret_cast<const GLdouble *>(array)); 2703%End 2704 2705 void glFogCoordd(GLdouble coord); 2706 void glFogCoordfv(SIP_PYOBJECT coord /TypeHint="PYQT_OPENGL_ARRAY"/); 2707%MethodCode 2708 const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_FLOAT, sipSelf); 2709 2710 if (sipError == sipErrorNone) 2711 sipCpp->glFogCoordfv(reinterpret_cast<const GLfloat *>(array)); 2712%End 2713 2714 void glFogCoordf(GLfloat coord); 2715 void glVertexAttrib4usv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2716%MethodCode 2717 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_SHORT, 2718 sipSelf); 2719 2720 if (sipError == sipErrorNone) 2721 sipCpp->glVertexAttrib4usv(a0, reinterpret_cast<const GLushort *>(array)); 2722%End 2723 2724 void glVertexAttrib4uiv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2725%MethodCode 2726 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT, 2727 sipSelf); 2728 2729 if (sipError == sipErrorNone) 2730 sipCpp->glVertexAttrib4uiv(a0, reinterpret_cast<const GLuint *>(array)); 2731%End 2732 2733 void glVertexAttrib4ubv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2734%MethodCode 2735 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_BYTE, 2736 sipSelf); 2737 2738 if (sipError == sipErrorNone) 2739 sipCpp->glVertexAttrib4ubv(a0, reinterpret_cast<const GLubyte *>(array)); 2740%End 2741 2742 void glVertexAttrib4sv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2743%MethodCode 2744 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2745 2746 if (sipError == sipErrorNone) 2747 sipCpp->glVertexAttrib4sv(a0, reinterpret_cast<const GLshort *>(array)); 2748%End 2749 2750 void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); 2751 void glVertexAttrib4iv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2752%MethodCode 2753 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 2754 2755 if (sipError == sipErrorNone) 2756 sipCpp->glVertexAttrib4iv(a0, reinterpret_cast<const GLint *>(array)); 2757%End 2758 2759 void glVertexAttrib4fv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2760%MethodCode 2761 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2762 2763 if (sipError == sipErrorNone) 2764 sipCpp->glVertexAttrib4fv(a0, reinterpret_cast<const GLfloat *>(array)); 2765%End 2766 2767 void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); 2768 void glVertexAttrib4dv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2769%MethodCode 2770 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2771 2772 if (sipError == sipErrorNone) 2773 sipCpp->glVertexAttrib4dv(a0, reinterpret_cast<const GLdouble *>(array)); 2774%End 2775 2776 void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); 2777 void glVertexAttrib4bv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2778%MethodCode 2779 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_BYTE, sipSelf); 2780 2781 if (sipError == sipErrorNone) 2782 sipCpp->glVertexAttrib4bv(a0, reinterpret_cast<const GLbyte *>(array)); 2783%End 2784 2785 void glVertexAttrib4Nusv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2786%MethodCode 2787 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_SHORT, 2788 sipSelf); 2789 2790 if (sipError == sipErrorNone) 2791 sipCpp->glVertexAttrib4Nusv(a0, reinterpret_cast<const GLushort *>(array)); 2792%End 2793 2794 void glVertexAttrib4Nuiv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2795%MethodCode 2796 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT, 2797 sipSelf); 2798 2799 if (sipError == sipErrorNone) 2800 sipCpp->glVertexAttrib4Nuiv(a0, reinterpret_cast<const GLuint *>(array)); 2801%End 2802 2803 void glVertexAttrib4Nubv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2804%MethodCode 2805 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_BYTE, 2806 sipSelf); 2807 2808 if (sipError == sipErrorNone) 2809 sipCpp->glVertexAttrib4Nubv(a0, reinterpret_cast<const GLubyte *>(array)); 2810%End 2811 2812 void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); 2813 void glVertexAttrib4Nsv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2814%MethodCode 2815 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2816 2817 if (sipError == sipErrorNone) 2818 sipCpp->glVertexAttrib4Nsv(a0, reinterpret_cast<const GLshort *>(array)); 2819%End 2820 2821 void glVertexAttrib4Niv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2822%MethodCode 2823 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf); 2824 2825 if (sipError == sipErrorNone) 2826 sipCpp->glVertexAttrib4Niv(a0, reinterpret_cast<const GLint *>(array)); 2827%End 2828 2829 void glVertexAttrib4Nbv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2830%MethodCode 2831 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_BYTE, sipSelf); 2832 2833 if (sipError == sipErrorNone) 2834 sipCpp->glVertexAttrib4Nbv(a0, reinterpret_cast<const GLbyte *>(array)); 2835%End 2836 2837 void glVertexAttrib3sv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2838%MethodCode 2839 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2840 2841 if (sipError == sipErrorNone) 2842 sipCpp->glVertexAttrib3sv(a0, reinterpret_cast<const GLshort *>(array)); 2843%End 2844 2845 void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z); 2846 void glVertexAttrib3fv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2847%MethodCode 2848 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2849 2850 if (sipError == sipErrorNone) 2851 sipCpp->glVertexAttrib3fv(a0, reinterpret_cast<const GLfloat *>(array)); 2852%End 2853 2854 void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); 2855 void glVertexAttrib3dv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2856%MethodCode 2857 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2858 2859 if (sipError == sipErrorNone) 2860 sipCpp->glVertexAttrib3dv(a0, reinterpret_cast<const GLdouble *>(array)); 2861%End 2862 2863 void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z); 2864 void glVertexAttrib2sv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2865%MethodCode 2866 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2867 2868 if (sipError == sipErrorNone) 2869 sipCpp->glVertexAttrib2sv(a0, reinterpret_cast<const GLshort *>(array)); 2870%End 2871 2872 void glVertexAttrib2s(GLuint index, GLshort x, GLshort y); 2873 void glVertexAttrib2fv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2874%MethodCode 2875 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2876 2877 if (sipError == sipErrorNone) 2878 sipCpp->glVertexAttrib2fv(a0, reinterpret_cast<const GLfloat *>(array)); 2879%End 2880 2881 void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y); 2882 void glVertexAttrib2dv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2883%MethodCode 2884 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2885 2886 if (sipError == sipErrorNone) 2887 sipCpp->glVertexAttrib2dv(a0, reinterpret_cast<const GLdouble *>(array)); 2888%End 2889 2890 void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y); 2891 void glVertexAttrib1sv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2892%MethodCode 2893 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_SHORT, sipSelf); 2894 2895 if (sipError == sipErrorNone) 2896 sipCpp->glVertexAttrib1sv(a0, reinterpret_cast<const GLshort *>(array)); 2897%End 2898 2899 void glVertexAttrib1s(GLuint index, GLshort x); 2900 void glVertexAttrib1fv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2901%MethodCode 2902 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf); 2903 2904 if (sipError == sipErrorNone) 2905 sipCpp->glVertexAttrib1fv(a0, reinterpret_cast<const GLfloat *>(array)); 2906%End 2907 2908 void glVertexAttrib1f(GLuint index, GLfloat x); 2909 void glVertexAttrib1dv(GLuint index, SIP_PYOBJECT v /TypeHint="PYQT_OPENGL_ARRAY"/); 2910%MethodCode 2911 const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_DOUBLE, sipSelf); 2912 2913 if (sipError == sipErrorNone) 2914 sipCpp->glVertexAttrib1dv(a0, reinterpret_cast<const GLdouble *>(array)); 2915%End 2916 2917 void glVertexAttrib1d(GLuint index, GLdouble x); 2918}; 2919 2920%End 2921 2922%ModuleHeaderCode 2923#include <qopengl.h> 2924 2925// Imports from QtGui. 2926typedef const GLvoid *(*qpyopengl_value_array_t)(sipErrorState *, PyObject *, GLenum, PyObject *); 2927extern qpyopengl_value_array_t qpyopengl_value_array; 2928 2929typedef const GLvoid *(*qpyopengl_value_array_cached_t)(sipErrorState *, PyObject *, GLenum, PyObject *, const char *, GLuint); 2930extern qpyopengl_value_array_cached_t qpyopengl_value_array_cached; 2931 2932typedef GLint (*qpyopengl_get_t)(GLenum, GLenum *); 2933extern qpyopengl_get_t qpyopengl_get; 2934 2935typedef PyObject *(*qpyopengl_from_GLint_t)(int *, const GLint *, Py_ssize_t); 2936extern qpyopengl_from_GLint_t qpyopengl_from_GLint; 2937 2938typedef PyObject *(*qpyopengl_from_GLuint_t)(int *, const GLuint *, Py_ssize_t); 2939extern qpyopengl_from_GLuint_t qpyopengl_from_GLuint; 2940 2941typedef PyObject *(*qpyopengl_from_GLboolean_t)(int *, const GLboolean *, Py_ssize_t); 2942extern qpyopengl_from_GLboolean_t qpyopengl_from_GLboolean; 2943 2944typedef PyObject *(*qpyopengl_from_GLfloat_t)(int *, const GLfloat *, Py_ssize_t); 2945extern qpyopengl_from_GLfloat_t qpyopengl_from_GLfloat; 2946 2947typedef PyObject *(*qpyopengl_from_GLdouble_t)(int *, const GLdouble *, Py_ssize_t); 2948extern qpyopengl_from_GLdouble_t qpyopengl_from_GLdouble; 2949%End 2950 2951%ModuleCode 2952// Imports from QtGui. 2953qpyopengl_value_array_t qpyopengl_value_array; 2954qpyopengl_value_array_cached_t qpyopengl_value_array_cached; 2955qpyopengl_get_t qpyopengl_get; 2956qpyopengl_from_GLint_t qpyopengl_from_GLint; 2957qpyopengl_from_GLuint_t qpyopengl_from_GLuint; 2958qpyopengl_from_GLboolean_t qpyopengl_from_GLboolean; 2959qpyopengl_from_GLfloat_t qpyopengl_from_GLfloat; 2960qpyopengl_from_GLdouble_t qpyopengl_from_GLdouble; 2961%End 2962 2963%PostInitialisationCode 2964// Imports from QtGui. 2965qpyopengl_value_array = (qpyopengl_value_array_t)sipImportSymbol("qpyopengl_value_array"); 2966Q_ASSERT(qpyopengl_value_array); 2967 2968qpyopengl_value_array_cached = (qpyopengl_value_array_cached_t)sipImportSymbol("qpyopengl_value_array_cached"); 2969Q_ASSERT(qpyopengl_value_array_cached); 2970 2971qpyopengl_get = (qpyopengl_get_t)sipImportSymbol("qpyopengl_get"); 2972Q_ASSERT(qpyopengl_get); 2973 2974qpyopengl_from_GLint = (qpyopengl_from_GLint_t)sipImportSymbol("qpyopengl_from_GLint"); 2975Q_ASSERT(qpyopengl_from_GLint); 2976 2977qpyopengl_from_GLuint = (qpyopengl_from_GLuint_t)sipImportSymbol("qpyopengl_from_GLuint"); 2978Q_ASSERT(qpyopengl_from_GLuint); 2979 2980qpyopengl_from_GLboolean = (qpyopengl_from_GLboolean_t)sipImportSymbol("qpyopengl_from_GLboolean"); 2981Q_ASSERT(qpyopengl_from_GLboolean); 2982 2983qpyopengl_from_GLfloat = (qpyopengl_from_GLfloat_t)sipImportSymbol("qpyopengl_from_GLfloat"); 2984Q_ASSERT(qpyopengl_from_GLfloat); 2985 2986qpyopengl_from_GLdouble = (qpyopengl_from_GLdouble_t)sipImportSymbol("qpyopengl_from_GLdouble"); 2987Q_ASSERT(qpyopengl_from_GLdouble); 2988%End 2989