git.cworth.org Git - fips/blob - glwrap.c

   1 /* Copyright © 2013, Intel Corporation
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 #include "dlwrap.h"
  23
  24 /* The prototypes for some OpenGL functions changed at one point from:
  25  *
  26  *      const void* *indices
  27  * to:
  28  *      const void* const coist *indices
  29  *
  30  * This makes it difficult for us to provide an implementation of
  31  * these functions that is consistent with the locally-available gl.h
  32  * since we don't know if the extra const will be present or not.
  33  *
  34  * To workaround this problem, we simply #define away const altogether
  35  * before including gl.h.
  36  *
  37  * Kudos to Keith Packard for suggesting this kludge.
  38  */
  39 #define const
  40
  41 #define GL_GLEXT_PROTOTYPES
  42 #include <GL/gl.h>
  43
  44 #include "fips.h"
  45
  46 #include "glwrap.h"
  47
  48 #include "metrics.h"
  49
  50 static void *gl_handle;
  51
  52 /* Switch metrics operation persistently, (until next SWITCH) */
  53 #define SWITCH_METRICS_OP(op)                   \
  54         metrics_counter_stop ();                \
  55         metrics_set_current_op (op);            \
  56         metrics_counter_start ();
  57
  58 /* Switch metrics operation temporarily, see RESTORE_METRICS_OP */
  59 #define SAVE_THEN_SWITCH_METRICS_OP(op)                 \
  60         metrics_op_t save = metrics_get_current_op ();  \
  61         SWITCH_METRICS_OP (op);
  62
  63 /* Switch back to metrics operation saved by SAVE_THEN_SWITCH_METRICS_OP */
  64 #define RESTORE_METRICS_OP(op)                          \
  65         SWITCH_METRICS_OP (save);
  66
  67 void
  68 glwrap_set_gl_handle (void *handle)
  69 {
  70         if (gl_handle == NULL)
  71                 gl_handle = handle;
  72 }
  73
  74 void *
  75 glwrap_lookup (char *name)
  76 {
  77         void *ret;
  78
  79         /* We don't call dlopen here to find the library in which to
  80          * perform a dlsym lookup. That's because the application may
  81          * be loading libGL.so or libGLESv2.so for its OpenGL symbols.
  82          *
  83          * So we instead watch for one of those filenames to go by in
  84          * our dlopen wrapper, which will then call
  85          * glwrap_set_gl_handle to give us the handle to use here.
  86          *
  87          * If the application hasn't called dlopen on a "libGL"
  88          * library, then presumably the application is linked directly
  89          * to an OpenGL implementation. In this case, we can use
  90          * RTLD_NEXT to find the symbol.
  91          *
  92          * But just in case, we also let the user override that by
  93          * specifying the FIPS_LIBGL environment variable to the path
  94          * of the real libGL.so library that fips should dlopen here.
  95          */
  96         if (gl_handle == NULL) {
  97                 const char *path;
  98
  99                 path = getenv ("FIPS_LIBGL");
 100                 if (path) {
 101                         gl_handle = dlopen (path, RTLD_LAZY);
 102
 103                         if (gl_handle == NULL) {
 104                                 fprintf (stderr, "Failed to dlopen FIPS_LIBGL: "
 105                                          "%s\n", path);
 106                                 exit (1);
 107                         }
 108                 } else {
 109                         gl_handle = RTLD_NEXT;
 110                 }
 111         }
 112
 113         ret = dlwrap_real_dlsym (gl_handle, name);
 114
 115         if (ret == NULL) {
 116                 fprintf (stderr, "Error: glwrap_lookup failed to dlsym %s\n",
 117                          name);
 118                 exit (1);
 119         }
 120
 121         return ret;
 122 }
 123
 124 /* With a program change, we stop the counter, update the
 125  * active program, then start the counter up again. */
 126 void
 127 glUseProgram (GLuint program)
 128 {
 129         SWITCH_METRICS_OP (METRICS_OP_SHADER + program);
 130
 131         GLWRAP_DEFER(glUseProgram, program);
 132 }
 133
 134 void
 135 glUseProgramObjectARB (GLhandleARB programObj)
 136 {
 137         SWITCH_METRICS_OP (METRICS_OP_SHADER + programObj);
 138
 139         GLWRAP_DEFER(glUseProgramObjectARB, programObj);
 140 }
 141
 142 /* METRICS_OP_ACCUM */
 143 void
 144 glAccum (GLenum op, GLfloat value)
 145 {
 146         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_ACCUM);
 147
 148         GLWRAP_DEFER (glAccum, op, value);
 149
 150         RESTORE_METRICS_OP ();
 151 }
 152
 153 void
 154 glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 155 {
 156         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_ACCUM);
 157
 158         GLWRAP_DEFER (glClearAccum, red, green, blue, alpha);
 159
 160         RESTORE_METRICS_OP ();
 161 }
 162
 163 void
 164 glClearAccumxOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 165 {
 166         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_ACCUM);
 167
 168         GLWRAP_DEFER (glClearAccumxOES, red, green, blue, alpha);
 169
 170         RESTORE_METRICS_OP ();
 171 }
 172
 173 /* METRICS_OP_BUFFER_DATA */
 174 void
 175 glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 176 {
 177         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 178
 179         GLWRAP_DEFER (glBufferData, target, size, data, usage);
 180
 181         RESTORE_METRICS_OP ();
 182 }
 183
 184 void
 185 glNamedBufferDataEXT (GLuint buffer, GLsizeiptr size, const GLvoid *data,
 186                       GLenum usage)
 187 {
 188         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 189
 190         GLWRAP_DEFER (glNamedBufferDataEXT, buffer, size, data, usage);
 191
 192         RESTORE_METRICS_OP ();
 193 }
 194
 195 void
 196 glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size,
 197                  const GLvoid *data)
 198 {
 199         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 200
 201         GLWRAP_DEFER (glBufferSubData, target, offset, size, data);
 202
 203         RESTORE_METRICS_OP ();
 204 }
 205
 206 void
 207 glNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size,
 208                          const GLvoid *data)
 209 {
 210         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 211
 212         GLWRAP_DEFER (glNamedBufferSubDataEXT, buffer, offset, size, data);
 213
 214         RESTORE_METRICS_OP ();
 215 }
 216
 217 void *
 218 glMapBuffer (GLenum target, GLenum access)
 219 {
 220         void *ret;
 221
 222         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 223
 224         GLWRAP_DEFER_WITH_RETURN (ret, glMapBuffer, target, access);
 225
 226         RESTORE_METRICS_OP ();
 227
 228         return ret;
 229 }
 230
 231 void *
 232 glMapBufferARB (GLenum target, GLenum access)
 233 {
 234         void *ret;
 235
 236         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 237
 238         GLWRAP_DEFER_WITH_RETURN (ret, glMapBufferARB, target, access);
 239
 240         RESTORE_METRICS_OP ();
 241
 242         return ret;
 243 }
 244
 245 void *
 246 glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length,
 247                   GLbitfield access)
 248 {
 249         void *ret;
 250
 251         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 252
 253         GLWRAP_DEFER_WITH_RETURN (ret, glMapBufferRange, target, offset,
 254                                   length, access);
 255
 256         RESTORE_METRICS_OP ();
 257
 258         return ret;
 259 }
 260
 261 GLboolean
 262 glUnmapBuffer (GLenum target)
 263 {
 264         GLboolean ret;
 265
 266         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 267
 268         GLWRAP_DEFER_WITH_RETURN (ret, glUnmapBuffer, target);
 269
 270         RESTORE_METRICS_OP ();
 271
 272         return ret;
 273 }
 274
 275 GLboolean
 276 glUnmapNamedBufferEXT (GLuint buffer)
 277 {
 278         GLboolean ret;
 279
 280         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 281
 282         GLWRAP_DEFER_WITH_RETURN (ret, glUnmapNamedBufferEXT, buffer);
 283
 284         RESTORE_METRICS_OP ();
 285
 286         return ret;
 287 }
 288
 289 GLboolean
 290 glUnmapBufferARB (GLenum target)
 291 {
 292         GLboolean ret;
 293
 294         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 295
 296         GLWRAP_DEFER_WITH_RETURN (ret, glUnmapBufferARB, target);
 297
 298         RESTORE_METRICS_OP ();
 299
 300         return ret;
 301 }
 302
 303 void
 304 glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length)
 305 {
 306         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 307
 308         GLWRAP_DEFER (glFlushMappedBufferRange, target, offset, length);
 309
 310         RESTORE_METRICS_OP ();
 311 }
 312
 313 void
 314 glFlushMappedBufferRangeAPPLE (GLenum target, GLintptr offset, GLsizeiptr size)
 315 {
 316         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 317
 318         GLWRAP_DEFER (glFlushMappedBufferRangeAPPLE, target, offset, size);
 319
 320         RESTORE_METRICS_OP ();
 321 }
 322
 323 void
 324 glFlushMappedNamedBufferRangeEXT (GLuint buffer, GLintptr offset,
 325                                   GLsizeiptr length)
 326 {
 327         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 328
 329         GLWRAP_DEFER (glFlushMappedNamedBufferRangeEXT, buffer, offset, length);
 330
 331         RESTORE_METRICS_OP ();
 332 }
 333
 334 void *
 335 glMapNamedBufferEXT (GLuint buffer, GLenum access)
 336 {
 337         void *ret;
 338
 339         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 340
 341         GLWRAP_DEFER_WITH_RETURN (ret, glMapNamedBufferEXT, buffer, access);
 342
 343         RESTORE_METRICS_OP ();
 344
 345         return ret;
 346 }
 347
 348 void *
 349 glMapNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length,
 350                           GLbitfield access)
 351 {
 352         void *ret;
 353
 354         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 355
 356         GLWRAP_DEFER_WITH_RETURN (ret, glMapNamedBufferRangeEXT, buffer,
 357                                   offset, length, access);
 358
 359         RESTORE_METRICS_OP ();
 360
 361         return ret;
 362 }
 363
 364 /* METRICS_OP_BUFFER_SUB_DATA */
 365 void
 366 glCopyBufferSubData (GLenum readTarget, GLenum writeTarget,
 367                      GLintptr readOffset, GLintptr writeOffset,
 368                      GLsizeiptr size)
 369 {
 370         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_SUB_DATA);
 371
 372         GLWRAP_DEFER (glCopyBufferSubData, readTarget, writeTarget,
 373                       readOffset, writeOffset, size);
 374
 375         RESTORE_METRICS_OP ();
 376 }
 377
 378 void
 379 glNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer,
 380                              GLintptr readOffset, GLintptr writeOffset,
 381                              GLsizeiptr size)
 382 {
 383         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_SUB_DATA);
 384
 385         GLWRAP_DEFER (glNamedCopyBufferSubDataEXT, readBuffer,
 386                       writeBuffer, readOffset, writeOffset, size);
 387
 388         RESTORE_METRICS_OP ();
 389 }
 390
 391 /* METRICS_OP_BITMAP */
 392 void
 393 glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
 394           GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 395 {
 396         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BITMAP);
 397
 398         GLWRAP_DEFER (glBitmap, width, height, xorig, yorig,
 399                       xmove, ymove, bitmap);
 400
 401         RESTORE_METRICS_OP ();
 402 }
 403
 404 void
 405 glBitmapxOES (GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig,
 406               GLfixed xmove, GLfixed ymove, const GLubyte *bitmap)
 407 {
 408         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BITMAP);
 409
 410         GLWRAP_DEFER (glBitmapxOES, width, height, xorig, yorig,
 411                       xmove, ymove, bitmap);
 412
 413         RESTORE_METRICS_OP ();
 414 }
 415
 416 /* METRICS_OP_BLIT_FRAMEBUFFER */
 417 void
 418 glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 419                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 420                    GLbitfield mask, GLenum filter)
 421 {
 422         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BLIT_FRAMEBUFFER);
 423
 424         GLWRAP_DEFER (glBlitFramebuffer, srcX0, srcY0, srcX1, srcY1,
 425                       dstX0, dstY0, dstX1, dstY1, mask, filter);
 426
 427         RESTORE_METRICS_OP ();
 428 }
 429
 430 void
 431 glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 432                       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 433                       GLbitfield mask, GLenum filter)
 434 {
 435         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BLIT_FRAMEBUFFER);
 436
 437         GLWRAP_DEFER (glBlitFramebufferEXT, srcX0, srcY0, srcX1, srcY1,
 438                       dstX0, dstY0, dstX1, dstY1, mask, filter);
 439
 440         RESTORE_METRICS_OP ();
 441 }
 442
 443 /* METRICS_OP_CLEAR */
 444 void
 445 glClear (GLbitfield mask)
 446 {
 447         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 448
 449         GLWRAP_DEFER (glClear, mask);
 450
 451         RESTORE_METRICS_OP ();
 452 }
 453
 454 void
 455 glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 456 {
 457         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 458
 459         GLWRAP_DEFER (glClearBufferfi, buffer, drawbuffer, depth, stencil);
 460
 461         RESTORE_METRICS_OP ();
 462 }
 463
 464 void
 465 glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value)
 466 {
 467         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 468
 469         GLWRAP_DEFER (glClearBufferfv, buffer, drawbuffer, value);
 470
 471         RESTORE_METRICS_OP ();
 472 }
 473
 474 void
 475 glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value)
 476 {
 477         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 478
 479         GLWRAP_DEFER (glClearBufferiv, buffer, drawbuffer, value);
 480
 481         RESTORE_METRICS_OP ();
 482 }
 483
 484 void
 485 glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value)
 486 {
 487         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 488
 489         GLWRAP_DEFER (glClearBufferuiv, buffer, drawbuffer, value);
 490
 491         RESTORE_METRICS_OP ();
 492 }
 493
 494 /* METRICS_OP_CLEAR_BUFFER_DATA */
 495
 496 void
 497 glClearBufferData (GLenum target, GLenum internalformat, GLenum format,
 498                    GLenum type, const void *data)
 499 {
 500         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 501
 502         GLWRAP_DEFER (glClearBufferData, target, internalformat, format,
 503                       type, data);
 504
 505         RESTORE_METRICS_OP ();
 506 }
 507
 508 void
 509 glClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset,
 510                       GLsizeiptr size, GLenum format, GLenum type,
 511                       const void *data)
 512 {
 513         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 514
 515         GLWRAP_DEFER (glClearBufferSubData, target, internalformat,
 516                       offset, size, format, type, data);
 517
 518         RESTORE_METRICS_OP ();
 519 }
 520
 521 void
 522 glClearNamedBufferDataEXT (GLuint buffer, GLenum internalformat, GLenum format,
 523                            GLenum type, const void *data)
 524 {
 525         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 526
 527         GLWRAP_DEFER (glClearNamedBufferDataEXT, buffer, internalformat,
 528                       format, type, data);
 529
 530         RESTORE_METRICS_OP ();
 531 }
 532
 533 void
 534 glClearNamedBufferSubDataEXT (GLuint buffer, GLenum internalformat,
 535                               GLenum format, GLenum type, GLsizeiptr offset,
 536                               GLsizeiptr size, const void *data)
 537 {
 538         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 539
 540         GLWRAP_DEFER (glClearNamedBufferSubDataEXT, buffer,
 541                       internalformat, format, type, offset, size, data);
 542
 543         RESTORE_METRICS_OP ();
 544 }
 545
 546 /* METRICS_OP_CLEAR_TEX_IMAGE */
 547
 548
 549 /* METRICS_OP_COPY_PIXELS */
 550 void
 551 glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
 552 {
 553         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_PIXELS);
 554
 555         GLWRAP_DEFER (glCopyPixels, x, y, width, height, type);
 556
 557         RESTORE_METRICS_OP ();
 558 }
 559
 560 /* METRICS_OP_COPY_TEX_IMAGE */
 561 void
 562 glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat,
 563                   GLint x, GLint y, GLsizei width, GLint border)
 564 {
 565         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 566
 567         GLWRAP_DEFER (glCopyTexImage1D, target, level, internalformat,
 568                       x, y, width, border);
 569
 570         RESTORE_METRICS_OP ();
 571 }
 572
 573 void
 574 glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat,
 575                      GLint x, GLint y, GLsizei width, GLint border)
 576 {
 577         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 578
 579         GLWRAP_DEFER (glCopyTexImage1DEXT, target, level, internalformat,
 580                       x, y, width, border);
 581
 582         RESTORE_METRICS_OP ();
 583 }
 584
 585 void
 586 glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat,
 587                   GLint x, GLint y, GLsizei width, GLsizei height,
 588                   GLint border)
 589 {
 590         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 591
 592         GLWRAP_DEFER (glCopyTexImage2D, target, level, internalformat,
 593                       x, y, width, height, border);
 594
 595         RESTORE_METRICS_OP ();
 596 }
 597
 598 void
 599 glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat,
 600                      GLint x, GLint y, GLsizei width, GLsizei height,
 601                      GLint border)
 602 {
 603         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 604
 605         GLWRAP_DEFER (glCopyTexImage2DEXT, target, level, internalformat,
 606                       x, y, width, height, border);
 607
 608         RESTORE_METRICS_OP ();
 609 }
 610
 611 void
 612 glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset,
 613                      GLint x, GLint y, GLsizei width)
 614 {
 615         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 616
 617         GLWRAP_DEFER (glCopyTexSubImage1D, target, level, xoffset,
 618                       x, y, width);
 619
 620         RESTORE_METRICS_OP ();
 621 }
 622
 623 void
 624 glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset,
 625                         GLint x, GLint y, GLsizei width)
 626 {
 627         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 628
 629         GLWRAP_DEFER (glCopyTexSubImage1DEXT, target, level, xoffset,
 630                       x, y, width);
 631
 632         RESTORE_METRICS_OP ();
 633 }
 634
 635 void
 636 glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset,
 637                      GLint yoffset, GLint x, GLint y, GLsizei width,
 638                      GLsizei height)
 639 {
 640         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 641
 642         GLWRAP_DEFER (glCopyTexSubImage2D, target, level, xoffset, yoffset,
 643                       x, y, width, height);
 644
 645         RESTORE_METRICS_OP ();
 646 }
 647
 648 void
 649 glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset,
 650                         GLint yoffset, GLint x, GLint y, GLsizei width,
 651                         GLsizei height)
 652 {
 653         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 654
 655         GLWRAP_DEFER (glCopyTexSubImage2DEXT, target, level, xoffset, yoffset,
 656                       x, y, width, height);
 657
 658         RESTORE_METRICS_OP ();
 659 }
 660
 661 void
 662 glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset,
 663                      GLint yoffset, GLint zoffset, GLint x, GLint y,
 664                      GLsizei width, GLsizei height)
 665 {
 666         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 667
 668         GLWRAP_DEFER (glCopyTexSubImage3D, target, level, xoffset, yoffset,
 669                       zoffset, x, y, width, height);
 670
 671         RESTORE_METRICS_OP ();
 672 }
 673
 674 void
 675 glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset,
 676                         GLint yoffset, GLint zoffset, GLint x, GLint y,
 677                         GLsizei width, GLsizei height)
 678 {
 679         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 680
 681         GLWRAP_DEFER (glCopyTexSubImage3DEXT, target, level, xoffset, yoffset,
 682                       zoffset, x, y, width, height);
 683
 684         RESTORE_METRICS_OP ();
 685 }
 686
 687 void
 688 glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level,
 689                          GLenum internalformat, GLint x, GLint y,
 690                          GLsizei width, GLint border)
 691 {
 692         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 693
 694         GLWRAP_DEFER (glCopyTextureImage1DEXT, texture, target, level,
 695                       internalformat, x, y, width, border);
 696
 697         RESTORE_METRICS_OP ();
 698 }
 699
 700 void
 701 glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level,
 702                          GLenum internalformat, GLint x, GLint y, GLsizei width,
 703                          GLsizei height, GLint border)
 704 {
 705         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 706
 707         GLWRAP_DEFER (glCopyTextureImage2DEXT, texture, target,
 708                       level, internalformat, x, y, width, height, border);
 709
 710         RESTORE_METRICS_OP ();
 711 }
 712
 713 void
 714 glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level,
 715                             GLint xoffset, GLint x, GLint y, GLsizei width)
 716 {
 717         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 718
 719         GLWRAP_DEFER (glCopyTextureSubImage1DEXT, texture, target, level,
 720                       xoffset, x, y, width);
 721
 722         RESTORE_METRICS_OP ();
 723 }
 724
 725 void
 726 glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level,
 727                             GLint xoffset, GLint yoffset, GLint x, GLint y,
 728                             GLsizei width, GLsizei height)
 729 {
 730         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 731
 732         GLWRAP_DEFER (glCopyTextureSubImage2DEXT, texture, target, level,
 733                       xoffset, yoffset, x, y, width, height);
 734
 735         RESTORE_METRICS_OP ();
 736 }
 737
 738 void
 739 glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level,
 740                             GLint xoffset, GLint yoffset, GLint zoffset,
 741                             GLint x, GLint y, GLsizei width, GLsizei height)
 742 {
 743         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 744
 745         GLWRAP_DEFER (glCopyTextureSubImage3DEXT, texture, target, level,
 746                       xoffset, yoffset, zoffset, x, y, width, height);
 747
 748         RESTORE_METRICS_OP ();
 749 }
 750
 751 void
 752 glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
 753                           GLenum internalformat, GLint x, GLint y,
 754                           GLsizei width, GLint border)
 755 {
 756         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 757
 758         GLWRAP_DEFER (glCopyMultiTexImage1DEXT, texunit, target, level,
 759                       internalformat, x, y, width, border);
 760
 761         RESTORE_METRICS_OP ();
 762 }
 763
 764 void
 765 glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
 766                           GLenum internalformat, GLint x, GLint y,
 767                           GLsizei width, GLsizei height, GLint border)
 768 {
 769         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 770
 771         GLWRAP_DEFER (glCopyMultiTexImage2DEXT, texunit, target, level,
 772                       internalformat, x, y, width, height, border);
 773
 774         RESTORE_METRICS_OP ();
 775 }
 776
 777 void
 778 glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
 779                              GLint xoffset, GLint x, GLint y, GLsizei width)
 780 {
 781         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 782
 783         GLWRAP_DEFER (glCopyMultiTexSubImage1DEXT, texunit, target, level,
 784                       xoffset, x, y, width);
 785
 786         RESTORE_METRICS_OP ();
 787 }
 788
 789 void
 790 glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
 791                              GLint xoffset, GLint yoffset, GLint x, GLint y,
 792                              GLsizei width, GLsizei height)
 793 {
 794         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 795
 796         GLWRAP_DEFER (glCopyMultiTexSubImage2DEXT, texunit, target, level,
 797                       xoffset, yoffset, x, y, width, height);
 798
 799         RESTORE_METRICS_OP ();
 800 }
 801
 802 void
 803 glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
 804                              GLint xoffset, GLint yoffset, GLint zoffset,
 805                              GLint x, GLint y, GLsizei width, GLsizei height)
 806 {
 807         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 808
 809         GLWRAP_DEFER (glCopyMultiTexSubImage3DEXT, texunit, target, level,
 810                       xoffset, yoffset, zoffset, x, y, width, height);
 811
 812         RESTORE_METRICS_OP ();
 813 }
 814
 815 /* METRICS_OP_DRAW_PIXELS */
 816 void
 817 glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type,
 818               const GLvoid *pixels)
 819 {
 820         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_DRAW_PIXELS);
 821
 822         GLWRAP_DEFER (glDrawPixels, width, height, format, type, pixels);
 823
 824         RESTORE_METRICS_OP ();
 825 }
 826
 827 /* METRICS_OP_GET_TEX_IMAGE */
 828
 829 void
 830 glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target,
 831                                  GLint lod, GLvoid *img)
 832 {
 833         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 834
 835         GLWRAP_DEFER (glGetCompressedMultiTexImageEXT, texunit,
 836                       target, lod, img);
 837
 838         RESTORE_METRICS_OP ();
 839 }
 840
 841 void
 842 glGetCompressedTexImage (GLenum target, GLint level, GLvoid *img)
 843 {
 844         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 845
 846         GLWRAP_DEFER (glGetCompressedTexImage, target, level, img);
 847
 848         RESTORE_METRICS_OP ();
 849 }
 850
 851 void
 852 glGetCompressedTexImageARB (GLenum target, GLint level, GLvoid *img)
 853 {
 854         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 855
 856         GLWRAP_DEFER (glGetCompressedTexImageARB, target, level, img);
 857
 858         RESTORE_METRICS_OP ();
 859 }
 860
 861 void
 862 glGetCompressedTextureImageEXT (GLuint texture, GLenum target,
 863                                 GLint lod, GLvoid *img)
 864 {
 865         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 866
 867         GLWRAP_DEFER (glGetCompressedTextureImageEXT, texture,
 868                       target, lod, img);
 869
 870         RESTORE_METRICS_OP ();
 871 }
 872
 873 void
 874 glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level,
 875                        GLenum format, GLenum type, GLvoid *pixels)
 876 {
 877         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 878
 879         GLWRAP_DEFER (glGetMultiTexImageEXT, texunit,
 880                       target, level, format, type, pixels);
 881
 882         RESTORE_METRICS_OP ();
 883 }
 884
 885 void
 886 glGetnCompressedTexImageARB (GLenum target, GLint lod,
 887                              GLsizei bufSize, GLvoid *img)
 888 {
 889         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 890
 891         GLWRAP_DEFER (glGetnCompressedTexImageARB, target, lod, bufSize, img);
 892
 893         RESTORE_METRICS_OP ();
 894 }
 895
 896 void
 897 glGetnTexImageARB (GLenum target, GLint level, GLenum format,
 898                    GLenum type, GLsizei bufSize, GLvoid *img)
 899 {
 900         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 901
 902         GLWRAP_DEFER (glGetnTexImageARB, target, level,
 903                       format, type, bufSize, img);
 904
 905         RESTORE_METRICS_OP ();
 906 }
 907
 908 void
 909 glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type,
 910                GLvoid *pixels )
 911 {
 912         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 913
 914         GLWRAP_DEFER (glGetTexImage, target, level, format, type, pixels);
 915
 916         RESTORE_METRICS_OP ();
 917 }
 918
 919 /* METRICS_OP_READ_PIXELS */
 920 void
 921 glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height,
 922               GLenum format, GLenum type, GLvoid *pixels )
 923 {
 924         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS);
 925
 926         GLWRAP_DEFER (glReadPixels, x, y, width, height, format, type, pixels);
 927
 928         RESTORE_METRICS_OP ();
 929 }
 930
 931 void
 932 glReadnPixelsARB (GLint x, GLint y, GLsizei width, GLsizei height,
 933                   GLenum format, GLenum type, GLsizei bufSize, GLvoid *data)
 934 {
 935         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS);
 936
 937         GLWRAP_DEFER (glReadnPixelsARB, x, y, width, height,
 938                       format, type, bufSize, data);
 939
 940         RESTORE_METRICS_OP ();
 941 }
 942
 943 /* METRICS_OP_TEX_IMAGE */
 944 void
 945 glTexImage1D (GLenum target, GLint level, GLint internalFormat,
 946               GLsizei width, GLint border, GLenum format, GLenum type,
 947               const GLvoid *pixels)
 948 {
 949         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 950
 951         GLWRAP_DEFER (glTexImage1D, target, level, internalFormat, width,
 952                       border, format, type, pixels);
 953
 954         RESTORE_METRICS_OP ();
 955 }
 956
 957 void
 958 glTexImage2D (GLenum target, GLint level, GLint internalFormat,
 959               GLsizei width, GLsizei height, GLint border, GLenum format,
 960               GLenum type, const GLvoid *pixels )
 961 {
 962         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 963
 964         GLWRAP_DEFER (glTexImage2D, target, level, internalFormat,
 965                       width, height, border, format, type, pixels);
 966
 967         RESTORE_METRICS_OP ();
 968 }
 969
 970
 971 void
 972 glTexImage2DMultisample (GLenum target, GLsizei samples,
 973                          GLint internalformat, GLsizei width, GLsizei height,
 974                          GLboolean fixedsamplelocations)
 975 {
 976         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 977
 978         GLWRAP_DEFER (glTexImage2DMultisample, target, samples,
 979                       internalformat, width, height, fixedsamplelocations);
 980
 981         RESTORE_METRICS_OP ();
 982 }
 983
 984 void
 985 glTexImage2DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples,
 986                                    GLsizei colorSamples, GLint internalFormat,
 987                                    GLsizei width, GLsizei height,
 988                                    GLboolean fixedSampleLocations)
 989 {
 990         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 991
 992         GLWRAP_DEFER (glTexImage2DMultisampleCoverageNV, target,
 993                       coverageSamples, colorSamples, internalFormat,
 994                       width, height, fixedSampleLocations);
 995
 996         RESTORE_METRICS_OP ();
 997 }
 998
 999 void
1000 glTexImage3D (GLenum target, GLint level, GLint internalformat,
1001               GLsizei width, GLsizei height, GLsizei depth, GLint border,
1002               GLenum format, GLenum type, const GLvoid *pixels)
1003 {
1004         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1005
1006         GLWRAP_DEFER (glTexImage3D, target, level, internalformat,
1007                       width, height, depth, border, format, type, pixels);
1008
1009         RESTORE_METRICS_OP ();
1010 }
1011
1012 void
1013 glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat,
1014                  GLsizei width, GLsizei height, GLsizei depth, GLint border,
1015                  GLenum format, GLenum type, const GLvoid *pixels)
1016 {
1017         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1018
1019         GLWRAP_DEFER (glTexImage3DEXT, target, level, internalformat,
1020                       width, height, depth, border, format, type, pixels);
1021
1022         RESTORE_METRICS_OP ();
1023 }
1024
1025 void
1026 glTexImage3DMultisample (GLenum target, GLsizei samples, GLint internalformat,
1027                          GLsizei width, GLsizei height, GLsizei depth,
1028                          GLboolean fixedsamplelocations)
1029 {
1030         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1031
1032         GLWRAP_DEFER (glTexImage3DMultisample, target, samples,
1033                       internalformat, width, height, depth,
1034                       fixedsamplelocations);
1035
1036         RESTORE_METRICS_OP ();
1037 }
1038
1039 void
1040 glTexImage3DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples,
1041                                    GLsizei colorSamples, GLint internalFormat,
1042                                    GLsizei width, GLsizei height, GLsizei depth,
1043                                    GLboolean fixedSampleLocations)
1044 {
1045         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1046
1047         GLWRAP_DEFER (glTexImage3DMultisampleCoverageNV, target,
1048                       coverageSamples, colorSamples, internalFormat,
1049                       width, height, depth, fixedSampleLocations);
1050
1051         RESTORE_METRICS_OP ();
1052 }
1053
1054 void
1055 glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat,
1056                   GLsizei width, GLsizei height, GLsizei depth,
1057                   GLsizei size4d, GLint border, GLenum format,
1058                   GLenum type, const GLvoid *pixels)
1059 {
1060         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1061
1062         GLWRAP_DEFER (glTexImage4DSGIS, target, level,
1063                       internalformat, width, height, depth,
1064                       size4d, border, format, type, pixels);
1065
1066         RESTORE_METRICS_OP ();
1067 }
1068
1069 void
1070 glTexSubImage1D (GLenum target, GLint level, GLint xoffset,
1071                  GLsizei width, GLenum format, GLenum type,
1072                  const GLvoid *pixels)
1073 {
1074         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1075
1076         GLWRAP_DEFER (glTexSubImage1D, target, level, xoffset,
1077                       width, format, type, pixels);
1078
1079         RESTORE_METRICS_OP ();
1080 }
1081
1082 void
1083 glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset,
1084                     GLsizei width, GLenum format, GLenum type,
1085                     const GLvoid *pixels)
1086 {
1087         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1088
1089         GLWRAP_DEFER (glTexSubImage1DEXT, target, level, xoffset,
1090                       width, format, type, pixels);
1091
1092         RESTORE_METRICS_OP ();
1093 }
1094
1095 void
1096 glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1097                  GLsizei width, GLsizei height, GLenum format, GLenum type,
1098                  const GLvoid *pixels)
1099 {
1100         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1101
1102         GLWRAP_DEFER (glTexSubImage2D, target, level, xoffset, yoffset,
1103                       width, height, format, type, pixels);
1104
1105         RESTORE_METRICS_OP ();
1106 }
1107
1108 void
1109 glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1110                     GLsizei width, GLsizei height, GLenum format, GLenum type,
1111                     const GLvoid *pixels)
1112 {
1113         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1114
1115         GLWRAP_DEFER (glTexSubImage2DEXT, target, level, xoffset, yoffset,
1116                       width, height, format, type, pixels);
1117
1118         RESTORE_METRICS_OP ();
1119 }
1120
1121 void
1122 glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1123                  GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
1124                  GLenum format, GLenum type, const GLvoid *pixels)
1125 {
1126         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1127
1128         GLWRAP_DEFER (glTexSubImage3D, target, level, xoffset, yoffset,
1129                       zoffset, width, height, depth, format, type, pixels);
1130
1131         RESTORE_METRICS_OP ();
1132 }
1133
1134 void
1135 glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1136                     GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
1137                     GLenum format, GLenum type, const GLvoid *pixels)
1138 {
1139         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1140
1141         GLWRAP_DEFER (glTexSubImage3DEXT, target, level, xoffset, yoffset,
1142                       zoffset, width, height, depth, format, type, pixels);
1143
1144         RESTORE_METRICS_OP ();
1145 }
1146
1147 void
1148 glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1149                      GLint zoffset, GLint woffset, GLsizei width,
1150                      GLsizei height, GLsizei depth, GLsizei size4d,
1151                      GLenum format, GLenum type, const GLvoid *pixels)
1152 {
1153         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1154
1155         GLWRAP_DEFER (glTexSubImage4DSGIS, target, level, xoffset,
1156                       yoffset, zoffset, woffset, width, height,
1157                       depth, size4d, format, type, pixels);
1158
1159         RESTORE_METRICS_OP ();
1160 }
1161
1162 void
1163 glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
1164                                 GLenum internalformat, GLsizei width,
1165                                 GLint border, GLsizei imageSize,
1166                                 const GLvoid *bits)
1167 {
1168         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1169
1170         GLWRAP_DEFER (glCompressedMultiTexImage1DEXT, texunit, target,
1171                       level, internalformat, width, border, imageSize, bits);
1172
1173         RESTORE_METRICS_OP ();
1174 }
1175
1176 void
1177 glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
1178                                 GLenum internalformat, GLsizei width,
1179                                 GLsizei height, GLint border,
1180                                 GLsizei imageSize, const GLvoid *bits)
1181 {
1182         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1183
1184         GLWRAP_DEFER (glCompressedMultiTexImage2DEXT, texunit, target, level,
1185                       internalformat, width, height, border, imageSize, bits);
1186
1187         RESTORE_METRICS_OP ();
1188 }
1189
1190 void
1191 glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level,
1192                                 GLenum internalformat, GLsizei width,
1193                                 GLsizei height, GLsizei depth, GLint border,
1194                                 GLsizei imageSize, const GLvoid *bits)
1195 {
1196         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1197
1198         GLWRAP_DEFER (glCompressedMultiTexImage3DEXT, texunit, target,
1199                       level, internalformat, width, height, depth,
1200                       border, imageSize, bits);
1201
1202         RESTORE_METRICS_OP ();
1203 }
1204
1205 void
1206 glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
1207                                    GLint xoffset, GLsizei width, GLenum format,
1208                                    GLsizei imageSize, const GLvoid *bits)
1209 {
1210         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1211
1212         GLWRAP_DEFER (glCompressedMultiTexSubImage1DEXT, texunit, target,
1213                       level, xoffset, width, format, imageSize, bits);
1214
1215         RESTORE_METRICS_OP ();
1216 }
1217
1218 void
1219 glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
1220                                    GLint xoffset, GLint yoffset, GLsizei width,
1221                                    GLsizei height, GLenum format,
1222                                    GLsizei imageSize, const GLvoid *bits)
1223 {
1224         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1225
1226         GLWRAP_DEFER (glCompressedMultiTexSubImage2DEXT, texunit, target, level,
1227                       xoffset, yoffset, width, height, format, imageSize, bits);
1228
1229         RESTORE_METRICS_OP ();
1230 }
1231
1232 void
1233 glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
1234                                    GLint xoffset, GLint yoffset, GLint zoffset,
1235                                    GLsizei width, GLsizei height, GLsizei depth,
1236                                    GLenum format, GLsizei imageSize,
1237                                    const GLvoid *bits)
1238 {
1239         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1240
1241         GLWRAP_DEFER (glCompressedMultiTexSubImage3DEXT, texunit, target,
1242                       level, xoffset, yoffset, zoffset, width, height,
1243                       depth, format, imageSize, bits);
1244
1245         RESTORE_METRICS_OP ();
1246 }
1247
1248 void
1249 glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat,
1250                         GLsizei width, GLint border, GLsizei imageSize,
1251                         const GLvoid *data)
1252 {
1253         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1254
1255         GLWRAP_DEFER (glCompressedTexImage1D, target, level,
1256                       internalformat, width, border, imageSize, data);
1257
1258         RESTORE_METRICS_OP ();
1259 }
1260
1261 void
1262 glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat,
1263                            GLsizei width, GLint border, GLsizei imageSize,
1264                            const GLvoid *data)
1265 {
1266         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1267
1268         GLWRAP_DEFER (glCompressedTexImage1DARB, target, level, internalformat,
1269                       width, border, imageSize, data);
1270
1271         RESTORE_METRICS_OP ();
1272 }
1273
1274 void
1275 glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat,
1276                         GLsizei width, GLsizei height, GLint border,
1277                         GLsizei imageSize, const GLvoid *data)
1278 {
1279         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1280
1281         GLWRAP_DEFER (glCompressedTexImage2D, target, level, internalformat,
1282                       width, height, border, imageSize, data);
1283
1284         RESTORE_METRICS_OP ();
1285 }
1286
1287 void
1288 glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat,
1289                            GLsizei width, GLsizei height, GLint border,
1290                            GLsizei imageSize, const GLvoid *data)
1291 {
1292         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1293
1294         GLWRAP_DEFER (glCompressedTexImage2DARB, target, level, internalformat,
1295                       width, height, border, imageSize, data);
1296
1297         RESTORE_METRICS_OP ();
1298 }
1299
1300 void
1301 glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat,
1302                         GLsizei width, GLsizei height, GLsizei depth,
1303                         GLint border, GLsizei imageSize, const GLvoid *data)
1304 {
1305         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1306
1307         GLWRAP_DEFER (glCompressedTexImage3D, target, level, internalformat,
1308                       width, height, depth, border, imageSize, data);
1309
1310         RESTORE_METRICS_OP ();
1311 }
1312
1313 void
1314 glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat,
1315                            GLsizei width, GLsizei height, GLsizei depth,
1316                            GLint border, GLsizei imageSize, const GLvoid *data)
1317 {
1318         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1319
1320         GLWRAP_DEFER (glCompressedTexImage3DARB, target, level, internalformat,
1321                       width, height, depth, border, imageSize, data);
1322
1323         RESTORE_METRICS_OP ();
1324 }
1325
1326 void
1327 glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset,
1328                            GLsizei width, GLenum format, GLsizei imageSize,
1329                            const GLvoid *data)
1330 {
1331         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1332
1333         GLWRAP_DEFER (glCompressedTexSubImage1D, target, level, xoffset,
1334                       width, format, imageSize, data);
1335
1336         RESTORE_METRICS_OP ();
1337 }
1338
1339 void
1340 glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset,
1341                               GLsizei width, GLenum format, GLsizei imageSize,
1342                               const GLvoid *data)
1343 {
1344         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1345
1346         GLWRAP_DEFER (glCompressedTexSubImage1DARB, target, level, xoffset,
1347                       width, format, imageSize, data);
1348
1349         RESTORE_METRICS_OP ();
1350 }
1351
1352 void
1353 glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset,
1354                            GLint yoffset, GLsizei width, GLsizei height,
1355                            GLenum format, GLsizei imageSize, const GLvoid *data)
1356 {
1357         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1358
1359         GLWRAP_DEFER (glCompressedTexSubImage2D, target, level, xoffset,
1360                       yoffset, width, height, format, imageSize, data);
1361
1362         RESTORE_METRICS_OP ();
1363 }
1364
1365 void
1366 glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset,
1367                               GLint yoffset, GLsizei width, GLsizei height,
1368                               GLenum format, GLsizei imageSize,
1369                               const GLvoid *data)
1370 {
1371         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1372
1373         GLWRAP_DEFER (glCompressedTexSubImage2DARB, target, level, xoffset,
1374                       yoffset, width, height, format, imageSize, data);
1375
1376         RESTORE_METRICS_OP ();
1377 }
1378
1379 void
1380 glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset,
1381                            GLint yoffset, GLint zoffset, GLsizei width,
1382                            GLsizei height, GLsizei depth, GLenum format,
1383                            GLsizei imageSize, const GLvoid *data)
1384 {
1385         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1386
1387         GLWRAP_DEFER (glCompressedTexSubImage3D, target, level, xoffset,
1388                       yoffset, zoffset, width, height, depth, format,
1389                       imageSize, data);
1390
1391         RESTORE_METRICS_OP ();
1392 }
1393
1394 void
1395 glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset,
1396                               GLint yoffset, GLint zoffset, GLsizei width,
1397                               GLsizei height, GLsizei depth, GLenum format,
1398                               GLsizei imageSize, const GLvoid *data)
1399 {
1400         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1401
1402         GLWRAP_DEFER (glCompressedTexSubImage3DARB, target, level, xoffset,
1403                       yoffset, zoffset, width, height, depth, format,
1404                       imageSize, data);
1405
1406         RESTORE_METRICS_OP ();
1407 }
1408
1409 void
1410 glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level,
1411                                GLenum internalformat, GLsizei width,
1412                                GLint border, GLsizei imageSize,
1413                                const GLvoid *bits)
1414 {
1415         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1416
1417         GLWRAP_DEFER (glCompressedTextureImage1DEXT, texture, target, level,
1418                       internalformat, width, border, imageSize, bits);
1419
1420         RESTORE_METRICS_OP ();
1421 }
1422
1423 void
1424 glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level,
1425                                GLenum internalformat, GLsizei width,
1426                                GLsizei height, GLint border,
1427                                GLsizei imageSize, const GLvoid *bits)
1428 {
1429         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1430
1431         GLWRAP_DEFER (glCompressedTextureImage2DEXT, texture, target, level,
1432                       internalformat, width, height, border, imageSize, bits);
1433
1434         RESTORE_METRICS_OP ();
1435 }
1436
1437 void
1438 glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level,
1439                                GLenum internalformat, GLsizei width,
1440                                GLsizei height, GLsizei depth, GLint border,
1441                                GLsizei imageSize, const GLvoid *bits)
1442 {
1443         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1444
1445         GLWRAP_DEFER (glCompressedTextureImage3DEXT, texture, target,
1446                       level, internalformat, width, height, depth,
1447                       border, imageSize, bits);
1448
1449         RESTORE_METRICS_OP ();
1450 }
1451
1452 void
1453 glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level,
1454                                   GLint xoffset, GLsizei width, GLenum format,
1455                                   GLsizei imageSize, const GLvoid *bits)
1456 {
1457         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1458
1459         GLWRAP_DEFER (glCompressedTextureSubImage1DEXT, texture, target,
1460                       level, xoffset, width, format, imageSize, bits);
1461
1462         RESTORE_METRICS_OP ();
1463 }
1464
1465 void
1466 glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level,
1467                                   GLint xoffset, GLint yoffset, GLsizei width,
1468                                   GLsizei height, GLenum format,
1469                                   GLsizei imageSize, const GLvoid *bits)
1470 {
1471         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1472
1473         GLWRAP_DEFER (glCompressedTextureSubImage2DEXT, texture, target, level,
1474                       xoffset, yoffset, width, height, format, imageSize, bits);
1475
1476         RESTORE_METRICS_OP ();
1477 }
1478
1479 void
1480 glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level,
1481                                   GLint xoffset, GLint yoffset, GLint zoffset,
1482                                   GLsizei width, GLsizei height, GLsizei depth,
1483                                   GLenum format, GLsizei imageSize,
1484                                   const GLvoid *bits)
1485 {
1486         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1487
1488         GLWRAP_DEFER (glCompressedTextureSubImage3DEXT, texture, target,
1489                       level, xoffset, yoffset, zoffset, width, height,
1490                       depth, format, imageSize, bits);
1491
1492         RESTORE_METRICS_OP ();
1493 }
1494
1495 void
1496 glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
1497                       GLenum internalformat, GLsizei width, GLint border,
1498                       GLenum format, GLenum type, const GLvoid *pixels)
1499 {
1500         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1501
1502         GLWRAP_DEFER (glMultiTexImage1DEXT, texunit, target, level,
1503                       internalformat, width, border, format, type, pixels);
1504
1505         RESTORE_METRICS_OP ();
1506 }
1507
1508 void
1509 glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
1510                       GLenum internalformat, GLsizei width, GLsizei height,
1511                       GLint border, GLenum format, GLenum type,
1512                       const GLvoid *pixels)
1513 {
1514         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1515
1516         GLWRAP_DEFER (glMultiTexImage2DEXT, texunit, target, level,
1517                       internalformat, width, height, border, format,
1518                       type, pixels);
1519
1520         RESTORE_METRICS_OP ();
1521 }
1522
1523 void
1524 glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level,
1525                       GLenum internalformat, GLsizei width, GLsizei height,
1526                       GLsizei depth, GLint border, GLenum format,
1527                       GLenum type, const GLvoid *pixels)
1528 {
1529         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1530
1531         GLWRAP_DEFER (glMultiTexImage3DEXT, texunit, target, level,
1532                       internalformat, width, height, depth, border,
1533                       format, type, pixels);
1534
1535         RESTORE_METRICS_OP ();
1536 }
1537
1538 void
1539 glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
1540                          GLint xoffset, GLsizei width, GLenum format,
1541                          GLenum type, const GLvoid *pixels)
1542 {
1543         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1544
1545         GLWRAP_DEFER (glMultiTexSubImage1DEXT, texunit, target, level,
1546                       xoffset, width, format, type, pixels);
1547
1548         RESTORE_METRICS_OP ();
1549 }
1550
1551 void
1552 glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
1553                          GLint xoffset, GLint yoffset, GLsizei width,
1554                          GLsizei height, GLenum format, GLenum type,
1555                          const GLvoid *pixels)
1556 {
1557         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1558
1559         GLWRAP_DEFER (glMultiTexSubImage2DEXT, texunit, target, level, xoffset,
1560                       yoffset, width, height, format, type, pixels);
1561
1562         RESTORE_METRICS_OP ();
1563 }
1564
1565 void
1566 glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
1567                          GLint xoffset, GLint yoffset, GLint zoffset,
1568                          GLsizei width, GLsizei height, GLsizei depth,
1569                          GLenum format, GLenum type, const GLvoid *pixels)
1570 {
1571         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1572
1573         GLWRAP_DEFER (glMultiTexSubImage3DEXT, texunit, target, level,
1574                       xoffset, yoffset, zoffset, width, height, depth,
1575                       format, type, pixels);
1576
1577         RESTORE_METRICS_OP ();
1578 }