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