src/type3_AndroidCloud/anbox-master/android/opengl/tests/gles_android_wrapper/gles.cpp

   1 /*
   2 * Copyright (C) 2011 The Android Open Source Project
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include "gles_dispatch.h"
  20 #include "gles_ftable.h"
  21 #include <EGL/egl.h>
  22 #include <cutils/log.h>
  23
  24 static struct gles_dispatch *s_dispatch = NULL;
  25
  26 void init_gles(void *gles_android)
  27 {
  28     s_dispatch = create_gles_dispatch(gles_android);
  29     if (s_dispatch == NULL) {
  30         ALOGE("failed to create gles dispatch\n");
  31     }
  32 }
  33
  34 static struct gles_dispatch *getDispatch()
  35 {
  36     if (!s_dispatch) {
  37         fprintf(stderr,"FATAL ERROR: GLES has not been initialized\n");
  38         exit(-1);
  39     }
  40
  41     return s_dispatch;
  42 }
  43
  44 __eglMustCastToProperFunctionPointerType gles_getProcAddress(const char *procname)
  45 {
  46      for (int i=0; i<gles_num_funcs; i++) {
  47          if (!strcmp(gles_funcs_by_name[i].name, procname)) {
  48              return (__eglMustCastToProperFunctionPointerType)gles_funcs_by_name[i].proc;
  49          }
  50      }
  51
  52      return NULL;
  53 }
  54
  55 ///////////// Path-through functions ///////////////
  56 void glAlphaFunc(GLenum func, GLclampf ref)
  57 {
  58      getDispatch()->glAlphaFunc(func, ref);
  59 }
  60
  61 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
  62 {
  63      getDispatch()->glClearColor(red, green, blue, alpha);
  64 }
  65
  66 void glClearDepthf(GLclampf depth)
  67 {
  68      getDispatch()->glClearDepthf(depth);
  69 }
  70
  71 void glClipPlanef(GLenum plane, const GLfloat *equation)
  72 {
  73      getDispatch()->glClipPlanef(plane, equation);
  74 }
  75
  76 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  77 {
  78      getDispatch()->glColor4f(red, green, blue, alpha);
  79 }
  80
  81 void glDepthRangef(GLclampf zNear, GLclampf zFar)
  82 {
  83      getDispatch()->glDepthRangef(zNear, zFar);
  84 }
  85
  86 void glFogf(GLenum pname, GLfloat param)
  87 {
  88      getDispatch()->glFogf(pname, param);
  89 }
  90
  91 void glFogfv(GLenum pname, const GLfloat *params)
  92 {
  93      getDispatch()->glFogfv(pname, params);
  94 }
  95
  96 void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
  97 {
  98      getDispatch()->glFrustumf(left, right, bottom, top, zNear, zFar);
  99 }
 100
 101 void glGetClipPlanef(GLenum pname, GLfloat eqn[4])
 102 {
 103      getDispatch()->glGetClipPlanef(pname, eqn);
 104 }
 105
 106 void glGetFloatv(GLenum pname, GLfloat *params)
 107 {
 108      getDispatch()->glGetFloatv(pname, params);
 109 }
 110
 111 void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 112 {
 113      getDispatch()->glGetLightfv(light, pname, params);
 114 }
 115
 116 void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 117 {
 118      getDispatch()->glGetMaterialfv(face, pname, params);
 119 }
 120
 121 void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params)
 122 {
 123      getDispatch()->glGetTexEnvfv(env, pname, params);
 124 }
 125
 126 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 127 {
 128      getDispatch()->glGetTexParameterfv(target, pname, params);
 129 }
 130
 131 void glLightModelf(GLenum pname, GLfloat param)
 132 {
 133      getDispatch()->glLightModelf(pname, param);
 134 }
 135
 136 void glLightModelfv(GLenum pname, const GLfloat *params)
 137 {
 138      getDispatch()->glLightModelfv(pname, params);
 139 }
 140
 141 void glLightf(GLenum light, GLenum pname, GLfloat param)
 142 {
 143      getDispatch()->glLightf(light, pname, param);
 144 }
 145
 146 void glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 147 {
 148      getDispatch()->glLightfv(light, pname, params);
 149 }
 150
 151 void glLineWidth(GLfloat width)
 152 {
 153      getDispatch()->glLineWidth(width);
 154 }
 155
 156 void glLoadMatrixf(const GLfloat *m)
 157 {
 158      getDispatch()->glLoadMatrixf(m);
 159 }
 160
 161 void glMaterialf(GLenum face, GLenum pname, GLfloat param)
 162 {
 163      getDispatch()->glMaterialf(face, pname, param);
 164 }
 165
 166 void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 167 {
 168      getDispatch()->glMaterialfv(face, pname, params);
 169 }
 170
 171 void glMultMatrixf(const GLfloat *m)
 172 {
 173      getDispatch()->glMultMatrixf(m);
 174 }
 175
 176 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 177 {
 178      getDispatch()->glMultiTexCoord4f(target, s, t, r, q);
 179 }
 180
 181 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 182 {
 183      getDispatch()->glNormal3f(nx, ny, nz);
 184 }
 185
 186 void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 187 {
 188      getDispatch()->glOrthof(left, right, bottom, top, zNear, zFar);
 189 }
 190
 191 void glPointParameterf(GLenum pname, GLfloat param)
 192 {
 193      getDispatch()->glPointParameterf(pname, param);
 194 }
 195
 196 void glPointParameterfv(GLenum pname, const GLfloat *params)
 197 {
 198      getDispatch()->glPointParameterfv(pname, params);
 199 }
 200
 201 void glPointSize(GLfloat size)
 202 {
 203      getDispatch()->glPointSize(size);
 204 }
 205
 206 void glPolygonOffset(GLfloat factor, GLfloat units)
 207 {
 208      getDispatch()->glPolygonOffset(factor, units);
 209 }
 210
 211 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 212 {
 213      getDispatch()->glRotatef(angle, x, y, z);
 214 }
 215
 216 void glScalef(GLfloat x, GLfloat y, GLfloat z)
 217 {
 218      getDispatch()->glScalef(x, y, z);
 219 }
 220
 221 void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 222 {
 223      getDispatch()->glTexEnvf(target, pname, param);
 224 }
 225
 226 void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 227 {
 228      getDispatch()->glTexEnvfv(target, pname, params);
 229 }
 230
 231 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 232 {
 233      getDispatch()->glTexParameterf(target, pname, param);
 234 }
 235
 236 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 237 {
 238      getDispatch()->glTexParameterfv(target, pname, params);
 239 }
 240
 241 void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 242 {
 243      getDispatch()->glTranslatef(x, y, z);
 244 }
 245
 246 void glActiveTexture(GLenum texture)
 247 {
 248      getDispatch()->glActiveTexture(texture);
 249 }
 250
 251 void glAlphaFuncx(GLenum func, GLclampx ref)
 252 {
 253      getDispatch()->glAlphaFuncx(func, ref);
 254 }
 255
 256 void glBindBuffer(GLenum target, GLuint buffer)
 257 {
 258      getDispatch()->glBindBuffer(target, buffer);
 259 }
 260
 261 void glBindTexture(GLenum target, GLuint texture)
 262 {
 263      getDispatch()->glBindTexture(target, texture);
 264 }
 265
 266 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 267 {
 268      getDispatch()->glBlendFunc(sfactor, dfactor);
 269 }
 270
 271 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 272 {
 273      getDispatch()->glBufferData(target, size, data, usage);
 274 }
 275
 276 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 277 {
 278      getDispatch()->glBufferSubData(target, offset, size, data);
 279 }
 280
 281 void glClear(GLbitfield mask)
 282 {
 283      getDispatch()->glClear(mask);
 284 }
 285
 286 void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 287 {
 288      getDispatch()->glClearColorx(red, green, blue, alpha);
 289 }
 290
 291 void glClearDepthx(GLclampx depth)
 292 {
 293      getDispatch()->glClearDepthx(depth);
 294 }
 295
 296 void glClearStencil(GLint s)
 297 {
 298      getDispatch()->glClearStencil(s);
 299 }
 300
 301 void glClientActiveTexture(GLenum texture)
 302 {
 303      getDispatch()->glClientActiveTexture(texture);
 304 }
 305
 306 void glClipPlanex(GLenum plane, const GLfixed *equation)
 307 {
 308      getDispatch()->glClipPlanex(plane, equation);
 309 }
 310
 311 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 312 {
 313      getDispatch()->glColor4ub(red, green, blue, alpha);
 314 }
 315
 316 void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 317 {
 318      getDispatch()->glColor4x(red, green, blue, alpha);
 319 }
 320
 321 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 322 {
 323      getDispatch()->glColorMask(red, green, blue, alpha);
 324 }
 325
 326 void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 327 {
 328      getDispatch()->glColorPointer(size, type, stride, pointer);
 329 }
 330
 331 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 332 {
 333      getDispatch()->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 334 }
 335
 336 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 337 {
 338      getDispatch()->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 339 }
 340
 341 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 342 {
 343      getDispatch()->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 344 }
 345
 346 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 347 {
 348      getDispatch()->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 349 }
 350
 351 void glCullFace(GLenum mode)
 352 {
 353      getDispatch()->glCullFace(mode);
 354 }
 355
 356 void glDeleteBuffers(GLsizei n, const GLuint *buffers)
 357 {
 358      getDispatch()->glDeleteBuffers(n, buffers);
 359 }
 360
 361 void glDeleteTextures(GLsizei n, const GLuint *textures)
 362 {
 363      getDispatch()->glDeleteTextures(n, textures);
 364 }
 365
 366 void glDepthFunc(GLenum func)
 367 {
 368      getDispatch()->glDepthFunc(func);
 369 }
 370
 371 void glDepthMask(GLboolean flag)
 372 {
 373      getDispatch()->glDepthMask(flag);
 374 }
 375
 376 void glDepthRangex(GLclampx zNear, GLclampx zFar)
 377 {
 378      getDispatch()->glDepthRangex(zNear, zFar);
 379 }
 380
 381 void glDisable(GLenum cap)
 382 {
 383      getDispatch()->glDisable(cap);
 384 }
 385
 386 void glDisableClientState(GLenum array)
 387 {
 388      getDispatch()->glDisableClientState(array);
 389 }
 390
 391 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 392 {
 393      getDispatch()->glDrawArrays(mode, first, count);
 394 }
 395
 396 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 397 {
 398      getDispatch()->glDrawElements(mode, count, type, indices);
 399 }
 400
 401 void glEnable(GLenum cap)
 402 {
 403      getDispatch()->glEnable(cap);
 404 }
 405
 406 void glEnableClientState(GLenum array)
 407 {
 408      getDispatch()->glEnableClientState(array);
 409 }
 410
 411 void glFinish()
 412 {
 413      getDispatch()->glFinish();
 414 }
 415
 416 void glFlush()
 417 {
 418      getDispatch()->glFlush();
 419 }
 420
 421 void glFogx(GLenum pname, GLfixed param)
 422 {
 423      getDispatch()->glFogx(pname, param);
 424 }
 425
 426 void glFogxv(GLenum pname, const GLfixed *params)
 427 {
 428      getDispatch()->glFogxv(pname, params);
 429 }
 430
 431 void glFrontFace(GLenum mode)
 432 {
 433      getDispatch()->glFrontFace(mode);
 434 }
 435
 436 void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 437 {
 438      getDispatch()->glFrustumx(left, right, bottom, top, zNear, zFar);
 439 }
 440
 441 void glGetBooleanv(GLenum pname, GLboolean *params)
 442 {
 443      getDispatch()->glGetBooleanv(pname, params);
 444 }
 445
 446 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 447 {
 448      getDispatch()->glGetBufferParameteriv(target, pname, params);
 449 }
 450
 451 void glGetClipPlanex(GLenum pname, GLfixed eqn[4])
 452 {
 453      getDispatch()->glGetClipPlanex(pname, eqn);
 454 }
 455
 456 void glGenBuffers(GLsizei n, GLuint *buffers)
 457 {
 458      getDispatch()->glGenBuffers(n, buffers);
 459 }
 460
 461 void glGenTextures(GLsizei n, GLuint *textures)
 462 {
 463      getDispatch()->glGenTextures(n, textures);
 464 }
 465
 466 GLenum glGetError()
 467 {
 468      return getDispatch()->glGetError();
 469 }
 470
 471 void glGetFixedv(GLenum pname, GLfixed *params)
 472 {
 473      getDispatch()->glGetFixedv(pname, params);
 474 }
 475
 476 void glGetIntegerv(GLenum pname, GLint *params)
 477 {
 478      getDispatch()->glGetIntegerv(pname, params);
 479 }
 480
 481 void glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
 482 {
 483      getDispatch()->glGetLightxv(light, pname, params);
 484 }
 485
 486 void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
 487 {
 488      getDispatch()->glGetMaterialxv(face, pname, params);
 489 }
 490
 491 void glGetPointerv(GLenum pname, GLvoid **params)
 492 {
 493      getDispatch()->glGetPointerv(pname, params);
 494 }
 495
 496 const GLubyte* glGetString(GLenum name)
 497 {
 498      return getDispatch()->glGetString(name);
 499 }
 500
 501 void glGetTexEnviv(GLenum env, GLenum pname, GLint *params)
 502 {
 503      getDispatch()->glGetTexEnviv(env, pname, params);
 504 }
 505
 506 void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params)
 507 {
 508      getDispatch()->glGetTexEnvxv(env, pname, params);
 509 }
 510
 511 void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 512 {
 513      getDispatch()->glGetTexParameteriv(target, pname, params);
 514 }
 515
 516 void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
 517 {
 518      getDispatch()->glGetTexParameterxv(target, pname, params);
 519 }
 520
 521 void glHint(GLenum target, GLenum mode)
 522 {
 523      getDispatch()->glHint(target, mode);
 524 }
 525
 526 GLboolean glIsBuffer(GLuint buffer)
 527 {
 528      return getDispatch()->glIsBuffer(buffer);
 529 }
 530
 531 GLboolean glIsEnabled(GLenum cap)
 532 {
 533      return getDispatch()->glIsEnabled(cap);
 534 }
 535
 536 GLboolean glIsTexture(GLuint texture)
 537 {
 538      return getDispatch()->glIsTexture(texture);
 539 }
 540
 541 void glLightModelx(GLenum pname, GLfixed param)
 542 {
 543      getDispatch()->glLightModelx(pname, param);
 544 }
 545
 546 void glLightModelxv(GLenum pname, const GLfixed *params)
 547 {
 548      getDispatch()->glLightModelxv(pname, params);
 549 }
 550
 551 void glLightx(GLenum light, GLenum pname, GLfixed param)
 552 {
 553      getDispatch()->glLightx(light, pname, param);
 554 }
 555
 556 void glLightxv(GLenum light, GLenum pname, const GLfixed *params)
 557 {
 558      getDispatch()->glLightxv(light, pname, params);
 559 }
 560
 561 void glLineWidthx(GLfixed width)
 562 {
 563      getDispatch()->glLineWidthx(width);
 564 }
 565
 566 void glLoadIdentity()
 567 {
 568      getDispatch()->glLoadIdentity();
 569 }
 570
 571 void glLoadMatrixx(const GLfixed *m)
 572 {
 573      getDispatch()->glLoadMatrixx(m);
 574 }
 575
 576 void glLogicOp(GLenum opcode)
 577 {
 578      getDispatch()->glLogicOp(opcode);
 579 }
 580
 581 void glMaterialx(GLenum face, GLenum pname, GLfixed param)
 582 {
 583      getDispatch()->glMaterialx(face, pname, param);
 584 }
 585
 586 void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params)
 587 {
 588      getDispatch()->glMaterialxv(face, pname, params);
 589 }
 590
 591 void glMatrixMode(GLenum mode)
 592 {
 593      getDispatch()->glMatrixMode(mode);
 594 }
 595
 596 void glMultMatrixx(const GLfixed *m)
 597 {
 598      getDispatch()->glMultMatrixx(m);
 599 }
 600
 601 void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 602 {
 603      getDispatch()->glMultiTexCoord4x(target, s, t, r, q);
 604 }
 605
 606 void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
 607 {
 608      getDispatch()->glNormal3x(nx, ny, nz);
 609 }
 610
 611 void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 612 {
 613      getDispatch()->glNormalPointer(type, stride, pointer);
 614 }
 615
 616 void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 617 {
 618      getDispatch()->glOrthox(left, right, bottom, top, zNear, zFar);
 619 }
 620
 621 void glPixelStorei(GLenum pname, GLint param)
 622 {
 623      getDispatch()->glPixelStorei(pname, param);
 624 }
 625
 626 void glPointParameterx(GLenum pname, GLfixed param)
 627 {
 628      getDispatch()->glPointParameterx(pname, param);
 629 }
 630
 631 void glPointParameterxv(GLenum pname, const GLfixed *params)
 632 {
 633      getDispatch()->glPointParameterxv(pname, params);
 634 }
 635
 636 void glPointSizex(GLfixed size)
 637 {
 638      getDispatch()->glPointSizex(size);
 639 }
 640
 641 void glPolygonOffsetx(GLfixed factor, GLfixed units)
 642 {
 643      getDispatch()->glPolygonOffsetx(factor, units);
 644 }
 645
 646 void glPopMatrix()
 647 {
 648      getDispatch()->glPopMatrix();
 649 }
 650
 651 void glPushMatrix()
 652 {
 653      getDispatch()->glPushMatrix();
 654 }
 655
 656 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 657 {
 658      getDispatch()->glReadPixels(x, y, width, height, format, type, pixels);
 659 }
 660
 661 void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 662 {
 663      getDispatch()->glRotatex(angle, x, y, z);
 664 }
 665
 666 void glSampleCoverage(GLclampf value, GLboolean invert)
 667 {
 668      getDispatch()->glSampleCoverage(value, invert);
 669 }
 670
 671 void glSampleCoveragex(GLclampx value, GLboolean invert)
 672 {
 673      getDispatch()->glSampleCoveragex(value, invert);
 674 }
 675
 676 void glScalex(GLfixed x, GLfixed y, GLfixed z)
 677 {
 678      getDispatch()->glScalex(x, y, z);
 679 }
 680
 681 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 682 {
 683      getDispatch()->glScissor(x, y, width, height);
 684 }
 685
 686 void glShadeModel(GLenum mode)
 687 {
 688      getDispatch()->glShadeModel(mode);
 689 }
 690
 691 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
 692 {
 693      getDispatch()->glStencilFunc(func, ref, mask);
 694 }
 695
 696 void glStencilMask(GLuint mask)
 697 {
 698      getDispatch()->glStencilMask(mask);
 699 }
 700
 701 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 702 {
 703      getDispatch()->glStencilOp(fail, zfail, zpass);
 704 }
 705
 706 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 707 {
 708      getDispatch()->glTexCoordPointer(size, type, stride, pointer);
 709 }
 710
 711 void glTexEnvi(GLenum target, GLenum pname, GLint param)
 712 {
 713      getDispatch()->glTexEnvi(target, pname, param);
 714 }
 715
 716 void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
 717 {
 718      getDispatch()->glTexEnvx(target, pname, param);
 719 }
 720
 721 void glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 722 {
 723      getDispatch()->glTexEnviv(target, pname, params);
 724 }
 725
 726 void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
 727 {
 728      getDispatch()->glTexEnvxv(target, pname, params);
 729 }
 730
 731 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 732 {
 733      getDispatch()->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 734 }
 735
 736 void glTexParameteri(GLenum target, GLenum pname, GLint param)
 737 {
 738      getDispatch()->glTexParameteri(target, pname, param);
 739 }
 740
 741 void glTexParameterx(GLenum target, GLenum pname, GLfixed param)
 742 {
 743      getDispatch()->glTexParameterx(target, pname, param);
 744 }
 745
 746 void glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 747 {
 748      getDispatch()->glTexParameteriv(target, pname, params);
 749 }
 750
 751 void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
 752 {
 753      getDispatch()->glTexParameterxv(target, pname, params);
 754 }
 755
 756 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 757 {
 758      getDispatch()->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 759 }
 760
 761 void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
 762 {
 763      getDispatch()->glTranslatex(x, y, z);
 764 }
 765
 766 void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 767 {
 768      getDispatch()->glVertexPointer(size, type, stride, pointer);
 769 }
 770
 771 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 772 {
 773      getDispatch()->glViewport(x, y, width, height);
 774 }
 775
 776 void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer)
 777 {
 778      getDispatch()->glPointSizePointerOES(type, stride, pointer);
 779 }
 780
 781 void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
 782 {
 783      getDispatch()->glBlendEquationSeparateOES(modeRGB, modeAlpha);
 784 }
 785
 786 void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 787 {
 788      getDispatch()->glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
 789 }
 790
 791 void glBlendEquationOES(GLenum mode)
 792 {
 793      getDispatch()->glBlendEquationOES(mode);
 794 }
 795
 796 void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
 797 {
 798      getDispatch()->glDrawTexsOES(x, y, z, width, height);
 799 }
 800
 801 void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
 802 {
 803      getDispatch()->glDrawTexiOES(x, y, z, width, height);
 804 }
 805
 806 void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
 807 {
 808      getDispatch()->glDrawTexxOES(x, y, z, width, height);
 809 }
 810
 811 void glDrawTexsvOES(const GLshort *coords)
 812 {
 813      getDispatch()->glDrawTexsvOES(coords);
 814 }
 815
 816 void glDrawTexivOES(const GLint *coords)
 817 {
 818      getDispatch()->glDrawTexivOES(coords);
 819 }
 820
 821 void glDrawTexxvOES(const GLfixed *coords)
 822 {
 823      getDispatch()->glDrawTexxvOES(coords);
 824 }
 825
 826 void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
 827 {
 828      getDispatch()->glDrawTexfOES(x, y, z, width, height);
 829 }
 830
 831 void glDrawTexfvOES(const GLfloat *coords)
 832 {
 833      getDispatch()->glDrawTexfvOES(coords);
 834 }
 835
 836 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 837 {
 838      getDispatch()->glEGLImageTargetTexture2DOES(target, image);
 839 }
 840
 841 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 842 {
 843      getDispatch()->glEGLImageTargetRenderbufferStorageOES(target, image);
 844 }
 845
 846 void glAlphaFuncxOES(GLenum func, GLclampx ref)
 847 {
 848      getDispatch()->glAlphaFuncxOES(func, ref);
 849 }
 850
 851 void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 852 {
 853      getDispatch()->glClearColorxOES(red, green, blue, alpha);
 854 }
 855
 856 void glClearDepthxOES(GLclampx depth)
 857 {
 858      getDispatch()->glClearDepthxOES(depth);
 859 }
 860
 861 void glClipPlanexOES(GLenum plane, const GLfixed *equation)
 862 {
 863      getDispatch()->glClipPlanexOES(plane, equation);
 864 }
 865
 866 void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 867 {
 868      getDispatch()->glColor4xOES(red, green, blue, alpha);
 869 }
 870
 871 void glDepthRangexOES(GLclampx zNear, GLclampx zFar)
 872 {
 873      getDispatch()->glDepthRangexOES(zNear, zFar);
 874 }
 875
 876 void glFogxOES(GLenum pname, GLfixed param)
 877 {
 878      getDispatch()->glFogxOES(pname, param);
 879 }
 880
 881 void glFogxvOES(GLenum pname, const GLfixed *params)
 882 {
 883      getDispatch()->glFogxvOES(pname, params);
 884 }
 885
 886 void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 887 {
 888      getDispatch()->glFrustumxOES(left, right, bottom, top, zNear, zFar);
 889 }
 890
 891 void glGetClipPlanexOES(GLenum pname, GLfixed eqn[4])
 892 {
 893      getDispatch()->glGetClipPlanexOES(pname, eqn);
 894 }
 895
 896 void glGetFixedvOES(GLenum pname, GLfixed *params)
 897 {
 898      getDispatch()->glGetFixedvOES(pname, params);
 899 }
 900
 901 void glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params)
 902 {
 903      getDispatch()->glGetLightxvOES(light, pname, params);
 904 }
 905
 906 void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params)
 907 {
 908      getDispatch()->glGetMaterialxvOES(face, pname, params);
 909 }
 910
 911 void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params)
 912 {
 913      getDispatch()->glGetTexEnvxvOES(env, pname, params);
 914 }
 915
 916 void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
 917 {
 918      getDispatch()->glGetTexParameterxvOES(target, pname, params);
 919 }
 920
 921 void glLightModelxOES(GLenum pname, GLfixed param)
 922 {
 923      getDispatch()->glLightModelxOES(pname, param);
 924 }
 925
 926 void glLightModelxvOES(GLenum pname, const GLfixed *params)
 927 {
 928      getDispatch()->glLightModelxvOES(pname, params);
 929 }
 930
 931 void glLightxOES(GLenum light, GLenum pname, GLfixed param)
 932 {
 933      getDispatch()->glLightxOES(light, pname, param);
 934 }
 935
 936 void glLightxvOES(GLenum light, GLenum pname, const GLfixed *params)
 937 {
 938      getDispatch()->glLightxvOES(light, pname, params);
 939 }
 940
 941 void glLineWidthxOES(GLfixed width)
 942 {
 943      getDispatch()->glLineWidthxOES(width);
 944 }
 945
 946 void glLoadMatrixxOES(const GLfixed *m)
 947 {
 948      getDispatch()->glLoadMatrixxOES(m);
 949 }
 950
 951 void glMaterialxOES(GLenum face, GLenum pname, GLfixed param)
 952 {
 953      getDispatch()->glMaterialxOES(face, pname, param);
 954 }
 955
 956 void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params)
 957 {
 958      getDispatch()->glMaterialxvOES(face, pname, params);
 959 }
 960
 961 void glMultMatrixxOES(const GLfixed *m)
 962 {
 963      getDispatch()->glMultMatrixxOES(m);
 964 }
 965
 966 void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 967 {
 968      getDispatch()->glMultiTexCoord4xOES(target, s, t, r, q);
 969 }
 970
 971 void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
 972 {
 973      getDispatch()->glNormal3xOES(nx, ny, nz);
 974 }
 975
 976 void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 977 {
 978      getDispatch()->glOrthoxOES(left, right, bottom, top, zNear, zFar);
 979 }
 980
 981 void glPointParameterxOES(GLenum pname, GLfixed param)
 982 {
 983      getDispatch()->glPointParameterxOES(pname, param);
 984 }
 985
 986 void glPointParameterxvOES(GLenum pname, const GLfixed *params)
 987 {
 988      getDispatch()->glPointParameterxvOES(pname, params);
 989 }
 990
 991 void glPointSizexOES(GLfixed size)
 992 {
 993      getDispatch()->glPointSizexOES(size);
 994 }
 995
 996 void glPolygonOffsetxOES(GLfixed factor, GLfixed units)
 997 {
 998      getDispatch()->glPolygonOffsetxOES(factor, units);
 999 }
1000
1001 void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
1002 {
1003      getDispatch()->glRotatexOES(angle, x, y, z);
1004 }
1005
1006 void glSampleCoveragexOES(GLclampx value, GLboolean invert)
1007 {
1008      getDispatch()->glSampleCoveragexOES(value, invert);
1009 }
1010
1011 void glScalexOES(GLfixed x, GLfixed y, GLfixed z)
1012 {
1013      getDispatch()->glScalexOES(x, y, z);
1014 }
1015
1016 void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
1017 {
1018      getDispatch()->glTexEnvxOES(target, pname, param);
1019 }
1020
1021 void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params)
1022 {
1023      getDispatch()->glTexEnvxvOES(target, pname, params);
1024 }
1025
1026 void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
1027 {
1028      getDispatch()->glTexParameterxOES(target, pname, param);
1029 }
1030
1031 void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params)
1032 {
1033      getDispatch()->glTexParameterxvOES(target, pname, params);
1034 }
1035
1036 void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
1037 {
1038      getDispatch()->glTranslatexOES(x, y, z);
1039 }
1040
1041 GLboolean glIsRenderbufferOES(GLuint renderbuffer)
1042 {
1043      return getDispatch()->glIsRenderbufferOES(renderbuffer);
1044 }
1045
1046 void glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
1047 {
1048      getDispatch()->glBindRenderbufferOES(target, renderbuffer);
1049 }
1050
1051 void glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
1052 {
1053      getDispatch()->glDeleteRenderbuffersOES(n, renderbuffers);
1054 }
1055
1056 void glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
1057 {
1058      getDispatch()->glGenRenderbuffersOES(n, renderbuffers);
1059 }
1060
1061 void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1062 {
1063      getDispatch()->glRenderbufferStorageOES(target, internalformat, width, height);
1064 }
1065
1066 void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
1067 {
1068      getDispatch()->glGetRenderbufferParameterivOES(target, pname, params);
1069 }
1070
1071 GLboolean glIsFramebufferOES(GLuint framebuffer)
1072 {
1073      return getDispatch()->glIsFramebufferOES(framebuffer);
1074 }
1075
1076 void glBindFramebufferOES(GLenum target, GLuint framebuffer)
1077 {
1078      getDispatch()->glBindFramebufferOES(target, framebuffer);
1079 }
1080
1081 void glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
1082 {
1083      getDispatch()->glDeleteFramebuffersOES(n, framebuffers);
1084 }
1085
1086 void glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
1087 {
1088      getDispatch()->glGenFramebuffersOES(n, framebuffers);
1089 }
1090
1091 GLenum glCheckFramebufferStatusOES(GLenum target)
1092 {
1093      return getDispatch()->glCheckFramebufferStatusOES(target);
1094 }
1095
1096 void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1097 {
1098      getDispatch()->glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
1099 }
1100
1101 void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1102 {
1103      getDispatch()->glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
1104 }
1105
1106 void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params)
1107 {
1108      getDispatch()->glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
1109 }
1110
1111 void glGenerateMipmapOES(GLenum target)
1112 {
1113      getDispatch()->glGenerateMipmapOES(target);
1114 }
1115
1116 void* glMapBufferOES(GLenum target, GLenum access)
1117 {
1118      return getDispatch()->glMapBufferOES(target, access);
1119 }
1120
1121 GLboolean glUnmapBufferOES(GLenum target)
1122 {
1123      return getDispatch()->glUnmapBufferOES(target);
1124 }
1125
1126 void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid **ptr)
1127 {
1128      getDispatch()->glGetBufferPointervOES(target, pname, ptr);
1129 }
1130
1131 void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
1132 {
1133      getDispatch()->glCurrentPaletteMatrixOES(matrixpaletteindex);
1134 }
1135
1136 void glLoadPaletteFromModelViewMatrixOES()
1137 {
1138      getDispatch()->glLoadPaletteFromModelViewMatrixOES();
1139 }
1140
1141 void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1142 {
1143      getDispatch()->glMatrixIndexPointerOES(size, type, stride, pointer);
1144 }
1145
1146 void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1147 {
1148      getDispatch()->glWeightPointerOES(size, type, stride, pointer);
1149 }
1150
1151 GLbitfield glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16])
1152 {
1153      return getDispatch()->glQueryMatrixxOES(mantissa, exponent);
1154 }
1155
1156 void glDepthRangefOES(GLclampf zNear, GLclampf zFar)
1157 {
1158      getDispatch()->glDepthRangefOES(zNear, zFar);
1159 }
1160
1161 void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1162 {
1163      getDispatch()->glFrustumfOES(left, right, bottom, top, zNear, zFar);
1164 }
1165
1166 void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
1167 {
1168      getDispatch()->glOrthofOES(left, right, bottom, top, zNear, zFar);
1169 }
1170
1171 void glClipPlanefOES(GLenum plane, const GLfloat *equation)
1172 {
1173      getDispatch()->glClipPlanefOES(plane, equation);
1174 }
1175
1176 void glGetClipPlanefOES(GLenum pname, GLfloat eqn[4])
1177 {
1178      getDispatch()->glGetClipPlanefOES(pname, eqn);
1179 }
1180
1181 void glClearDepthfOES(GLclampf depth)
1182 {
1183      getDispatch()->glClearDepthfOES(depth);
1184 }
1185
1186 void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
1187 {
1188      getDispatch()->glTexGenfOES(coord, pname, param);
1189 }
1190
1191 void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
1192 {
1193      getDispatch()->glTexGenfvOES(coord, pname, params);
1194 }
1195
1196 void glTexGeniOES(GLenum coord, GLenum pname, GLint param)
1197 {
1198      getDispatch()->glTexGeniOES(coord, pname, param);
1199 }
1200
1201 void glTexGenivOES(GLenum coord, GLenum pname, const GLint *params)
1202 {
1203      getDispatch()->glTexGenivOES(coord, pname, params);
1204 }
1205
1206 void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
1207 {
1208      getDispatch()->glTexGenxOES(coord, pname, param);
1209 }
1210
1211 void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
1212 {
1213      getDispatch()->glTexGenxvOES(coord, pname, params);
1214 }
1215
1216 void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
1217 {
1218      getDispatch()->glGetTexGenfvOES(coord, pname, params);
1219 }
1220
1221 void glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
1222 {
1223      getDispatch()->glGetTexGenivOES(coord, pname, params);
1224 }
1225
1226 void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
1227 {
1228      getDispatch()->glGetTexGenxvOES(coord, pname, params);
1229 }
1230
1231 void glBindVertexArrayOES(GLuint array)
1232 {
1233      getDispatch()->glBindVertexArrayOES(array);
1234 }
1235
1236 void glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
1237 {
1238      getDispatch()->glDeleteVertexArraysOES(n, arrays);
1239 }
1240
1241 void glGenVertexArraysOES(GLsizei n, GLuint *arrays)
1242 {
1243      getDispatch()->glGenVertexArraysOES(n, arrays);
1244 }
1245
1246 GLboolean glIsVertexArrayOES(GLuint array)
1247 {
1248      return getDispatch()->glIsVertexArrayOES(array);
1249 }
1250
1251 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
1252 {
1253      getDispatch()->glDiscardFramebufferEXT(target, numAttachments, attachments);
1254 }
1255
1256 void glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount)
1257 {
1258      getDispatch()->glMultiDrawArraysEXT(mode, first, count, primcount);
1259 }
1260
1261 void glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)
1262 {
1263      getDispatch()->glMultiDrawElementsEXT(mode, count, type, indices, primcount);
1264 }
1265
1266 void glClipPlanefIMG(GLenum p, const GLfloat *eqn)
1267 {
1268      getDispatch()->glClipPlanefIMG(p, eqn);
1269 }
1270
1271 void glClipPlanexIMG(GLenum p, const GLfixed *eqn)
1272 {
1273      getDispatch()->glClipPlanexIMG(p, eqn);
1274 }
1275
1276 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1277 {
1278      getDispatch()->glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
1279 }
1280
1281 void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
1282 {
1283      getDispatch()->glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
1284 }
1285
1286 void glDeleteFencesNV(GLsizei n, const GLuint *fences)
1287 {
1288      getDispatch()->glDeleteFencesNV(n, fences);
1289 }
1290
1291 void glGenFencesNV(GLsizei n, GLuint *fences)
1292 {
1293      getDispatch()->glGenFencesNV(n, fences);
1294 }
1295
1296 GLboolean glIsFenceNV(GLuint fence)
1297 {
1298      return getDispatch()->glIsFenceNV(fence);
1299 }
1300
1301 GLboolean glTestFenceNV(GLuint fence)
1302 {
1303      return getDispatch()->glTestFenceNV(fence);
1304 }
1305
1306 void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
1307 {
1308      getDispatch()->glGetFenceivNV(fence, pname, params);
1309 }
1310
1311 void glFinishFenceNV(GLuint fence)
1312 {
1313      getDispatch()->glFinishFenceNV(fence);
1314 }
1315
1316 void glSetFenceNV(GLuint fence, GLenum condition)
1317 {
1318      getDispatch()->glSetFenceNV(fence, condition);
1319 }
1320
1321 void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls)
1322 {
1323      getDispatch()->glGetDriverControlsQCOM(num, size, driverControls);
1324 }
1325
1326 void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString)
1327 {
1328      getDispatch()->glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
1329 }
1330
1331 void glEnableDriverControlQCOM(GLuint driverControl)
1332 {
1333      getDispatch()->glEnableDriverControlQCOM(driverControl);
1334 }
1335
1336 void glDisableDriverControlQCOM(GLuint driverControl)
1337 {
1338      getDispatch()->glDisableDriverControlQCOM(driverControl);
1339 }
1340
1341 void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures)
1342 {
1343      getDispatch()->glExtGetTexturesQCOM(textures, maxTextures, numTextures);
1344 }
1345
1346 void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers)
1347 {
1348      getDispatch()->glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
1349 }
1350
1351 void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers)
1352 {
1353      getDispatch()->glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
1354 }
1355
1356 void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers)
1357 {
1358      getDispatch()->glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
1359 }
1360
1361 void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params)
1362 {
1363      getDispatch()->glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
1364 }
1365
1366 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
1367 {
1368      getDispatch()->glExtTexObjectStateOverrideiQCOM(target, pname, param);
1369 }
1370
1371 void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels)
1372 {
1373      getDispatch()->glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
1374 }
1375
1376 void glExtGetBufferPointervQCOM(GLenum target, GLvoid **params)
1377 {
1378      getDispatch()->glExtGetBufferPointervQCOM(target, params);
1379 }
1380
1381 void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders)
1382 {
1383      getDispatch()->glExtGetShadersQCOM(shaders, maxShaders, numShaders);
1384 }
1385
1386 void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms)
1387 {
1388      getDispatch()->glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
1389 }
1390
1391 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
1392 {
1393      return getDispatch()->glExtIsProgramBinaryQCOM(program);
1394 }
1395
1396 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length)
1397 {
1398      getDispatch()->glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
1399 }
1400
1401 void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
1402 {
1403      getDispatch()->glStartTilingQCOM(x, y, width, height, preserveMask);
1404 }
1405
1406 void glEndTilingQCOM(GLbitfield preserveMask)
1407 {
1408      getDispatch()->glEndTilingQCOM(preserveMask);
1409 }
1410