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(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 void
 562 glClearNamedBufferSubDataEXT (GLuint buffer, GLenum internalformat,
 563                               GLenum format, GLenum type, GLsizeiptr offset,
 564                               GLsizeiptr size, const void *data)
 565 {
 566         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 567
 568         GLWRAP_DEFER (glClearNamedBufferSubDataEXT, buffer,
 569                       internalformat, format, type, offset, size, data);
 570
 571         RESTORE_METRICS_OP ();
 572 }
 573
 574 /* METRICS_OP_CLEAR_TEX_IMAGE */
 575
 576
 577 /* METRICS_OP_COPY_PIXELS */
 578 void
 579 glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
 580 {
 581         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_PIXELS);
 582
 583         GLWRAP_DEFER (glCopyPixels, x, y, width, height, type);
 584
 585         RESTORE_METRICS_OP ();
 586 }
 587
 588 /* METRICS_OP_COPY_TEX_IMAGE */
 589 void
 590 glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat,
 591                   GLint x, GLint y, GLsizei width, GLint border)
 592 {
 593         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 594
 595         GLWRAP_DEFER (glCopyTexImage1D, target, level, internalformat,
 596                       x, y, width, border);
 597
 598         RESTORE_METRICS_OP ();
 599 }
 600
 601 void
 602 glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat,
 603                      GLint x, GLint y, GLsizei width, GLint border)
 604 {
 605         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 606
 607         GLWRAP_DEFER (glCopyTexImage1DEXT, target, level, internalformat,
 608                       x, y, width, border);
 609
 610         RESTORE_METRICS_OP ();
 611 }
 612
 613 void
 614 glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat,
 615                   GLint x, GLint y, GLsizei width, GLsizei height,
 616                   GLint border)
 617 {
 618         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 619
 620         GLWRAP_DEFER (glCopyTexImage2D, target, level, internalformat,
 621                       x, y, width, height, border);
 622
 623         RESTORE_METRICS_OP ();
 624 }
 625
 626 void
 627 glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat,
 628                      GLint x, GLint y, GLsizei width, GLsizei height,
 629                      GLint border)
 630 {
 631         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 632
 633         GLWRAP_DEFER (glCopyTexImage2DEXT, target, level, internalformat,
 634                       x, y, width, height, border);
 635
 636         RESTORE_METRICS_OP ();
 637 }
 638
 639 void
 640 glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset,
 641                      GLint x, GLint y, GLsizei width)
 642 {
 643         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 644
 645         GLWRAP_DEFER (glCopyTexSubImage1D, target, level, xoffset,
 646                       x, y, width);
 647
 648         RESTORE_METRICS_OP ();
 649 }
 650
 651 void
 652 glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset,
 653                         GLint x, GLint y, GLsizei width)
 654 {
 655         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 656
 657         GLWRAP_DEFER (glCopyTexSubImage1DEXT, target, level, xoffset,
 658                       x, y, width);
 659
 660         RESTORE_METRICS_OP ();
 661 }
 662
 663 void
 664 glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset,
 665                      GLint yoffset, GLint x, GLint y, GLsizei width,
 666                      GLsizei height)
 667 {
 668         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 669
 670         GLWRAP_DEFER (glCopyTexSubImage2D, target, level, xoffset, yoffset,
 671                       x, y, width, height);
 672
 673         RESTORE_METRICS_OP ();
 674 }
 675
 676 void
 677 glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset,
 678                         GLint yoffset, GLint x, GLint y, GLsizei width,
 679                         GLsizei height)
 680 {
 681         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 682
 683         GLWRAP_DEFER (glCopyTexSubImage2DEXT, target, level, xoffset, yoffset,
 684                       x, y, width, height);
 685
 686         RESTORE_METRICS_OP ();
 687 }
 688
 689 void
 690 glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset,
 691                      GLint yoffset, GLint zoffset, GLint x, GLint y,
 692                      GLsizei width, GLsizei height)
 693 {
 694         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 695
 696         GLWRAP_DEFER (glCopyTexSubImage3D, target, level, xoffset, yoffset,
 697                       zoffset, x, y, width, height);
 698
 699         RESTORE_METRICS_OP ();
 700 }
 701
 702 void
 703 glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset,
 704                         GLint yoffset, GLint zoffset, GLint x, GLint y,
 705                         GLsizei width, GLsizei height)
 706 {
 707         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 708
 709         GLWRAP_DEFER (glCopyTexSubImage3DEXT, target, level, xoffset, yoffset,
 710                       zoffset, x, y, width, height);
 711
 712         RESTORE_METRICS_OP ();
 713 }
 714
 715 void
 716 glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level,
 717                          GLenum internalformat, GLint x, GLint y,
 718                          GLsizei width, GLint border)
 719 {
 720         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 721
 722         GLWRAP_DEFER (glCopyTextureImage1DEXT, texture, target, level,
 723                       internalformat, x, y, width, border);
 724
 725         RESTORE_METRICS_OP ();
 726 }
 727
 728 void
 729 glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level,
 730                          GLenum internalformat, GLint x, GLint y, GLsizei width,
 731                          GLsizei height, GLint border)
 732 {
 733         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 734
 735         GLWRAP_DEFER (glCopyTextureImage2DEXT, texture, target,
 736                       level, internalformat, x, y, width, height, border);
 737
 738         RESTORE_METRICS_OP ();
 739 }
 740
 741 void
 742 glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level,
 743                             GLint xoffset, GLint x, GLint y, GLsizei width)
 744 {
 745         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 746
 747         GLWRAP_DEFER (glCopyTextureSubImage1DEXT, texture, target, level,
 748                       xoffset, x, y, width);
 749
 750         RESTORE_METRICS_OP ();
 751 }
 752
 753 void
 754 glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level,
 755                             GLint xoffset, GLint yoffset, GLint x, GLint y,
 756                             GLsizei width, GLsizei height)
 757 {
 758         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 759
 760         GLWRAP_DEFER (glCopyTextureSubImage2DEXT, texture, target, level,
 761                       xoffset, yoffset, x, y, width, height);
 762
 763         RESTORE_METRICS_OP ();
 764 }
 765
 766 void
 767 glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level,
 768                             GLint xoffset, GLint yoffset, GLint zoffset,
 769                             GLint x, GLint y, GLsizei width, GLsizei height)
 770 {
 771         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 772
 773         GLWRAP_DEFER (glCopyTextureSubImage3DEXT, texture, target, level,
 774                       xoffset, yoffset, zoffset, x, y, width, height);
 775
 776         RESTORE_METRICS_OP ();
 777 }
 778
 779 void
 780 glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
 781                           GLenum internalformat, GLint x, GLint y,
 782                           GLsizei width, GLint border)
 783 {
 784         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 785
 786         GLWRAP_DEFER (glCopyMultiTexImage1DEXT, texunit, target, level,
 787                       internalformat, x, y, width, border);
 788
 789         RESTORE_METRICS_OP ();
 790 }
 791
 792 void
 793 glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
 794                           GLenum internalformat, GLint x, GLint y,
 795                           GLsizei width, GLsizei height, GLint border)
 796 {
 797         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 798
 799         GLWRAP_DEFER (glCopyMultiTexImage2DEXT, texunit, target, level,
 800                       internalformat, x, y, width, height, border);
 801
 802         RESTORE_METRICS_OP ();
 803 }
 804
 805 void
 806 glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
 807                              GLint xoffset, GLint x, GLint y, GLsizei width)
 808 {
 809         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 810
 811         GLWRAP_DEFER (glCopyMultiTexSubImage1DEXT, texunit, target, level,
 812                       xoffset, x, y, width);
 813
 814         RESTORE_METRICS_OP ();
 815 }
 816
 817 void
 818 glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
 819                              GLint xoffset, GLint yoffset, GLint x, GLint y,
 820                              GLsizei width, GLsizei height)
 821 {
 822         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 823
 824         GLWRAP_DEFER (glCopyMultiTexSubImage2DEXT, texunit, target, level,
 825                       xoffset, yoffset, x, y, width, height);
 826
 827         RESTORE_METRICS_OP ();
 828 }
 829
 830 void
 831 glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
 832                              GLint xoffset, GLint yoffset, GLint zoffset,
 833                              GLint x, GLint y, GLsizei width, GLsizei height)
 834 {
 835         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 836
 837         GLWRAP_DEFER (glCopyMultiTexSubImage3DEXT, texunit, target, level,
 838                       xoffset, yoffset, zoffset, x, y, width, height);
 839
 840         RESTORE_METRICS_OP ();
 841 }
 842
 843 /* METRICS_OP_DRAW_PIXELS */
 844 void
 845 glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type,
 846               const GLvoid *pixels)
 847 {
 848         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_DRAW_PIXELS);
 849
 850         GLWRAP_DEFER (glDrawPixels, width, height, format, type, pixels);
 851
 852         RESTORE_METRICS_OP ();
 853 }
 854
 855 /* METRICS_OP_GET_TEX_IMAGE */
 856
 857 void
 858 glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target,
 859                                  GLint lod, GLvoid *img)
 860 {
 861         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 862
 863         GLWRAP_DEFER (glGetCompressedMultiTexImageEXT, texunit,
 864                       target, lod, img);
 865
 866         RESTORE_METRICS_OP ();
 867 }
 868
 869 void
 870 glGetCompressedTexImage (GLenum target, GLint level, GLvoid *img)
 871 {
 872         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 873
 874         GLWRAP_DEFER (glGetCompressedTexImage, target, level, img);
 875
 876         RESTORE_METRICS_OP ();
 877 }
 878
 879 void
 880 glGetCompressedTexImageARB (GLenum target, GLint level, GLvoid *img)
 881 {
 882         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 883
 884         GLWRAP_DEFER (glGetCompressedTexImageARB, target, level, img);
 885
 886         RESTORE_METRICS_OP ();
 887 }
 888
 889 void
 890 glGetCompressedTextureImageEXT (GLuint texture, GLenum target,
 891                                 GLint lod, GLvoid *img)
 892 {
 893         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 894
 895         GLWRAP_DEFER (glGetCompressedTextureImageEXT, texture,
 896                       target, lod, img);
 897
 898         RESTORE_METRICS_OP ();
 899 }
 900
 901 void
 902 glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level,
 903                        GLenum format, GLenum type, GLvoid *pixels)
 904 {
 905         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 906
 907         GLWRAP_DEFER (glGetMultiTexImageEXT, texunit,
 908                       target, level, format, type, pixels);
 909
 910         RESTORE_METRICS_OP ();
 911 }
 912
 913 void
 914 glGetnCompressedTexImageARB (GLenum target, GLint lod,
 915                              GLsizei bufSize, GLvoid *img)
 916 {
 917         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 918
 919         GLWRAP_DEFER (glGetnCompressedTexImageARB, target, lod, bufSize, img);
 920
 921         RESTORE_METRICS_OP ();
 922 }
 923
 924 void
 925 glGetnTexImageARB (GLenum target, GLint level, GLenum format,
 926                    GLenum type, GLsizei bufSize, GLvoid *img)
 927 {
 928         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 929
 930         GLWRAP_DEFER (glGetnTexImageARB, target, level,
 931                       format, type, bufSize, img);
 932
 933         RESTORE_METRICS_OP ();
 934 }
 935
 936 void
 937 glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type,
 938                GLvoid *pixels )
 939 {
 940         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 941
 942         GLWRAP_DEFER (glGetTexImage, target, level, format, type, pixels);
 943
 944         RESTORE_METRICS_OP ();
 945 }
 946
 947 /* METRICS_OP_READ_PIXELS */
 948 void
 949 glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height,
 950               GLenum format, GLenum type, GLvoid *pixels )
 951 {
 952         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS);
 953
 954         GLWRAP_DEFER (glReadPixels, x, y, width, height, format, type, pixels);
 955
 956         RESTORE_METRICS_OP ();
 957 }
 958
 959 void
 960 glReadnPixelsARB (GLint x, GLint y, GLsizei width, GLsizei height,
 961                   GLenum format, GLenum type, GLsizei bufSize, GLvoid *data)
 962 {
 963         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS);
 964
 965         GLWRAP_DEFER (glReadnPixelsARB, x, y, width, height,
 966                       format, type, bufSize, data);
 967
 968         RESTORE_METRICS_OP ();
 969 }
 970
 971 /* METRICS_OP_TEX_IMAGE */
 972 void
 973 glTexImage1D (GLenum target, GLint level, GLint internalFormat,
 974               GLsizei width, GLint border, GLenum format, GLenum type,
 975               const GLvoid *pixels)
 976 {
 977         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 978
 979         GLWRAP_DEFER (glTexImage1D, target, level, internalFormat, width,
 980                       border, format, type, pixels);
 981
 982         RESTORE_METRICS_OP ();
 983 }
 984
 985 void
 986 glTexImage2D (GLenum target, GLint level, GLint internalFormat,
 987               GLsizei width, GLsizei height, GLint border, GLenum format,
 988               GLenum type, const GLvoid *pixels )
 989 {
 990         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 991
 992         GLWRAP_DEFER (glTexImage2D, target, level, internalFormat,
 993                       width, height, border, format, type, pixels);
 994
 995         RESTORE_METRICS_OP ();
 996 }
 997
 998
 999 void
1000 glTexImage2DMultisample (GLenum target, GLsizei samples,
1001                          GLint_or_enum internalformat,
1002                          GLsizei width, GLsizei height,
1003                          GLboolean fixedsamplelocations)
1004 {
1005         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1006
1007         GLWRAP_DEFER (glTexImage2DMultisample, target, samples,
1008                       internalformat, width, height, fixedsamplelocations);
1009
1010         RESTORE_METRICS_OP ();
1011 }
1012
1013 void
1014 glTexImage2DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples,
1015                                    GLsizei colorSamples, GLint internalFormat,
1016                                    GLsizei width, GLsizei height,
1017                                    GLboolean fixedSampleLocations)
1018 {
1019         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1020
1021         GLWRAP_DEFER (glTexImage2DMultisampleCoverageNV, target,
1022                       coverageSamples, colorSamples, internalFormat,
1023                       width, height, fixedSampleLocations);
1024
1025         RESTORE_METRICS_OP ();
1026 }
1027
1028 void
1029 glTexImage3D (GLenum target, GLint level, GLint internalformat,
1030               GLsizei width, GLsizei height, GLsizei depth, GLint border,
1031               GLenum format, GLenum type, const GLvoid *pixels)
1032 {
1033         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1034
1035         GLWRAP_DEFER (glTexImage3D, target, level, internalformat,
1036                       width, height, depth, border, format, type, pixels);
1037
1038         RESTORE_METRICS_OP ();
1039 }
1040
1041 void
1042 glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat,
1043                  GLsizei width, GLsizei height, GLsizei depth, GLint border,
1044                  GLenum format, GLenum type, const GLvoid *pixels)
1045 {
1046         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1047
1048         GLWRAP_DEFER (glTexImage3DEXT, target, level, internalformat,
1049                       width, height, depth, border, format, type, pixels);
1050
1051         RESTORE_METRICS_OP ();
1052 }
1053
1054 void
1055 glTexImage3DMultisample (GLenum target, GLsizei samples,
1056                          GLint_or_enum internalformat,
1057                          GLsizei width, GLsizei height, GLsizei depth,
1058                          GLboolean fixedsamplelocations)
1059 {
1060         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1061
1062         GLWRAP_DEFER (glTexImage3DMultisample, target, samples,
1063                       internalformat, width, height, depth,
1064                       fixedsamplelocations);
1065
1066         RESTORE_METRICS_OP ();
1067 }
1068
1069 void
1070 glTexImage3DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples,
1071                                    GLsizei colorSamples, GLint internalFormat,
1072                                    GLsizei width, GLsizei height, GLsizei depth,
1073                                    GLboolean fixedSampleLocations)
1074 {
1075         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1076
1077         GLWRAP_DEFER (glTexImage3DMultisampleCoverageNV, target,
1078                       coverageSamples, colorSamples, internalFormat,
1079                       width, height, depth, fixedSampleLocations);
1080
1081         RESTORE_METRICS_OP ();
1082 }
1083
1084 void
1085 glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat,
1086                   GLsizei width, GLsizei height, GLsizei depth,
1087                   GLsizei size4d, GLint border, GLenum format,
1088                   GLenum type, const GLvoid *pixels)
1089 {
1090         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1091
1092         GLWRAP_DEFER (glTexImage4DSGIS, target, level,
1093                       internalformat, width, height, depth,
1094                       size4d, border, format, type, pixels);
1095
1096         RESTORE_METRICS_OP ();
1097 }
1098
1099 void
1100 glTexSubImage1D (GLenum target, GLint level, GLint xoffset,
1101                  GLsizei width, GLenum format, GLenum type,
1102                  const GLvoid *pixels)
1103 {
1104         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1105
1106         GLWRAP_DEFER (glTexSubImage1D, target, level, xoffset,
1107                       width, format, type, pixels);
1108
1109         RESTORE_METRICS_OP ();
1110 }
1111
1112 void
1113 glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset,
1114                     GLsizei width, GLenum format, GLenum type,
1115                     const GLvoid *pixels)
1116 {
1117         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1118
1119         GLWRAP_DEFER (glTexSubImage1DEXT, target, level, xoffset,
1120                       width, format, type, pixels);
1121
1122         RESTORE_METRICS_OP ();
1123 }
1124
1125 void
1126 glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1127                  GLsizei width, GLsizei height, GLenum format, GLenum type,
1128                  const GLvoid *pixels)
1129 {
1130         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1131
1132         GLWRAP_DEFER (glTexSubImage2D, target, level, xoffset, yoffset,
1133                       width, height, format, type, pixels);
1134
1135         RESTORE_METRICS_OP ();
1136 }
1137
1138 void
1139 glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1140                     GLsizei width, GLsizei height, GLenum format, GLenum type,
1141                     const GLvoid *pixels)
1142 {
1143         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1144
1145         GLWRAP_DEFER (glTexSubImage2DEXT, target, level, xoffset, yoffset,
1146                       width, height, format, type, pixels);
1147
1148         RESTORE_METRICS_OP ();
1149 }
1150
1151 void
1152 glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1153                  GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
1154                  GLenum format, GLenum type, const GLvoid *pixels)
1155 {
1156         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1157
1158         GLWRAP_DEFER (glTexSubImage3D, target, level, xoffset, yoffset,
1159                       zoffset, width, height, depth, format, type, pixels);
1160
1161         RESTORE_METRICS_OP ();
1162 }
1163
1164 void
1165 glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1166                     GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
1167                     GLenum format, GLenum type, const GLvoid *pixels)
1168 {
1169         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1170
1171         GLWRAP_DEFER (glTexSubImage3DEXT, target, level, xoffset, yoffset,
1172                       zoffset, width, height, depth, format, type, pixels);
1173
1174         RESTORE_METRICS_OP ();
1175 }
1176
1177 void
1178 glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1179                      GLint zoffset, GLint woffset, GLsizei width,
1180                      GLsizei height, GLsizei depth, GLsizei size4d,
1181                      GLenum format, GLenum type, const GLvoid *pixels)
1182 {
1183         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1184
1185         GLWRAP_DEFER (glTexSubImage4DSGIS, target, level, xoffset,
1186                       yoffset, zoffset, woffset, width, height,
1187                       depth, size4d, format, type, pixels);
1188
1189         RESTORE_METRICS_OP ();
1190 }
1191
1192 void
1193 glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
1194                                 GLenum internalformat, GLsizei width,
1195                                 GLint border, GLsizei imageSize,
1196                                 const GLvoid *bits)
1197 {
1198         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1199
1200         GLWRAP_DEFER (glCompressedMultiTexImage1DEXT, texunit, target,
1201                       level, internalformat, width, border, imageSize, bits);
1202
1203         RESTORE_METRICS_OP ();
1204 }
1205
1206 void
1207 glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
1208                                 GLenum internalformat, GLsizei width,
1209                                 GLsizei height, GLint border,
1210                                 GLsizei imageSize, const GLvoid *bits)
1211 {
1212         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1213
1214         GLWRAP_DEFER (glCompressedMultiTexImage2DEXT, texunit, target, level,
1215                       internalformat, width, height, border, imageSize, bits);
1216
1217         RESTORE_METRICS_OP ();
1218 }
1219
1220 void
1221 glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level,
1222                                 GLenum internalformat, GLsizei width,
1223                                 GLsizei height, GLsizei depth, GLint border,
1224                                 GLsizei imageSize, const GLvoid *bits)
1225 {
1226         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1227
1228         GLWRAP_DEFER (glCompressedMultiTexImage3DEXT, texunit, target,
1229                       level, internalformat, width, height, depth,
1230                       border, imageSize, bits);
1231
1232         RESTORE_METRICS_OP ();
1233 }
1234
1235 void
1236 glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
1237                                    GLint xoffset, GLsizei width, GLenum format,
1238                                    GLsizei imageSize, const GLvoid *bits)
1239 {
1240         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1241
1242         GLWRAP_DEFER (glCompressedMultiTexSubImage1DEXT, texunit, target,
1243                       level, xoffset, width, format, imageSize, bits);
1244
1245         RESTORE_METRICS_OP ();
1246 }
1247
1248 void
1249 glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
1250                                    GLint xoffset, GLint yoffset, GLsizei width,
1251                                    GLsizei height, GLenum format,
1252                                    GLsizei imageSize, const GLvoid *bits)
1253 {
1254         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1255
1256         GLWRAP_DEFER (glCompressedMultiTexSubImage2DEXT, texunit, target, level,
1257                       xoffset, yoffset, width, height, format, imageSize, bits);
1258
1259         RESTORE_METRICS_OP ();
1260 }
1261
1262 void
1263 glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
1264                                    GLint xoffset, GLint yoffset, GLint zoffset,
1265                                    GLsizei width, GLsizei height, GLsizei depth,
1266                                    GLenum format, GLsizei imageSize,
1267                                    const GLvoid *bits)
1268 {
1269         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1270
1271         GLWRAP_DEFER (glCompressedMultiTexSubImage3DEXT, texunit, target,
1272                       level, xoffset, yoffset, zoffset, width, height,
1273                       depth, format, imageSize, bits);
1274
1275         RESTORE_METRICS_OP ();
1276 }
1277
1278 void
1279 glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat,
1280                         GLsizei width, GLint border, GLsizei imageSize,
1281                         const GLvoid *data)
1282 {
1283         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1284
1285         GLWRAP_DEFER (glCompressedTexImage1D, target, level,
1286                       internalformat, width, border, imageSize, data);
1287
1288         RESTORE_METRICS_OP ();
1289 }
1290
1291 void
1292 glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat,
1293                            GLsizei width, GLint border, GLsizei imageSize,
1294                            const GLvoid *data)
1295 {
1296         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1297
1298         GLWRAP_DEFER (glCompressedTexImage1DARB, target, level, internalformat,
1299                       width, border, imageSize, data);
1300
1301         RESTORE_METRICS_OP ();
1302 }
1303
1304 void
1305 glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat,
1306                         GLsizei width, GLsizei height, GLint border,
1307                         GLsizei imageSize, const GLvoid *data)
1308 {
1309         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1310
1311         GLWRAP_DEFER (glCompressedTexImage2D, target, level, internalformat,
1312                       width, height, border, imageSize, data);
1313
1314         RESTORE_METRICS_OP ();
1315 }
1316
1317 void
1318 glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat,
1319                            GLsizei width, GLsizei height, GLint border,
1320                            GLsizei imageSize, const GLvoid *data)
1321 {
1322         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1323
1324         GLWRAP_DEFER (glCompressedTexImage2DARB, target, level, internalformat,
1325                       width, height, border, imageSize, data);
1326
1327         RESTORE_METRICS_OP ();
1328 }
1329
1330 void
1331 glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat,
1332                         GLsizei width, GLsizei height, GLsizei depth,
1333                         GLint border, GLsizei imageSize, const GLvoid *data)
1334 {
1335         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1336
1337         GLWRAP_DEFER (glCompressedTexImage3D, target, level, internalformat,
1338                       width, height, depth, border, imageSize, data);
1339
1340         RESTORE_METRICS_OP ();
1341 }
1342
1343 void
1344 glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat,
1345                            GLsizei width, GLsizei height, GLsizei depth,
1346                            GLint border, GLsizei imageSize, const GLvoid *data)
1347 {
1348         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1349
1350         GLWRAP_DEFER (glCompressedTexImage3DARB, target, level, internalformat,
1351                       width, height, depth, border, imageSize, data);
1352
1353         RESTORE_METRICS_OP ();
1354 }
1355
1356 void
1357 glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset,
1358                            GLsizei width, GLenum format, GLsizei imageSize,
1359                            const GLvoid *data)
1360 {
1361         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1362
1363         GLWRAP_DEFER (glCompressedTexSubImage1D, target, level, xoffset,
1364                       width, format, imageSize, data);
1365
1366         RESTORE_METRICS_OP ();
1367 }
1368
1369 void
1370 glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset,
1371                               GLsizei width, GLenum format, GLsizei imageSize,
1372                               const GLvoid *data)
1373 {
1374         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1375
1376         GLWRAP_DEFER (glCompressedTexSubImage1DARB, target, level, xoffset,
1377                       width, format, imageSize, data);
1378
1379         RESTORE_METRICS_OP ();
1380 }
1381
1382 void
1383 glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset,
1384                            GLint yoffset, GLsizei width, GLsizei height,
1385                            GLenum format, GLsizei imageSize, const GLvoid *data)
1386 {
1387         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1388
1389         GLWRAP_DEFER (glCompressedTexSubImage2D, target, level, xoffset,
1390                       yoffset, width, height, format, imageSize, data);
1391
1392         RESTORE_METRICS_OP ();
1393 }
1394
1395 void
1396 glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset,
1397                               GLint yoffset, GLsizei width, GLsizei height,
1398                               GLenum format, GLsizei imageSize,
1399                               const GLvoid *data)
1400 {
1401         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1402
1403         GLWRAP_DEFER (glCompressedTexSubImage2DARB, target, level, xoffset,
1404                       yoffset, width, height, format, imageSize, data);
1405
1406         RESTORE_METRICS_OP ();
1407 }
1408
1409 void
1410 glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset,
1411                            GLint yoffset, GLint zoffset, GLsizei width,
1412                            GLsizei height, GLsizei depth, GLenum format,
1413                            GLsizei imageSize, const GLvoid *data)
1414 {
1415         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1416
1417         GLWRAP_DEFER (glCompressedTexSubImage3D, target, level, xoffset,
1418                       yoffset, zoffset, width, height, depth, format,
1419                       imageSize, data);
1420
1421         RESTORE_METRICS_OP ();
1422 }
1423
1424 void
1425 glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset,
1426                               GLint yoffset, GLint zoffset, GLsizei width,
1427                               GLsizei height, GLsizei depth, GLenum format,
1428                               GLsizei imageSize, const GLvoid *data)
1429 {
1430         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1431
1432         GLWRAP_DEFER (glCompressedTexSubImage3DARB, target, level, xoffset,
1433                       yoffset, zoffset, width, height, depth, format,
1434                       imageSize, data);
1435
1436         RESTORE_METRICS_OP ();
1437 }
1438
1439 void
1440 glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level,
1441                                GLenum internalformat, GLsizei width,
1442                                GLint border, GLsizei imageSize,
1443                                const GLvoid *bits)
1444 {
1445         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1446
1447         GLWRAP_DEFER (glCompressedTextureImage1DEXT, texture, target, level,
1448                       internalformat, width, border, imageSize, bits);
1449
1450         RESTORE_METRICS_OP ();
1451 }
1452
1453 void
1454 glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level,
1455                                GLenum internalformat, GLsizei width,
1456                                GLsizei height, GLint border,
1457                                GLsizei imageSize, const GLvoid *bits)
1458 {
1459         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1460
1461         GLWRAP_DEFER (glCompressedTextureImage2DEXT, texture, target, level,
1462                       internalformat, width, height, border, imageSize, bits);
1463
1464         RESTORE_METRICS_OP ();
1465 }
1466
1467 void
1468 glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level,
1469                                GLenum internalformat, GLsizei width,
1470                                GLsizei height, GLsizei depth, GLint border,
1471                                GLsizei imageSize, const GLvoid *bits)
1472 {
1473         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1474
1475         GLWRAP_DEFER (glCompressedTextureImage3DEXT, texture, target,
1476                       level, internalformat, width, height, depth,
1477                       border, imageSize, bits);
1478
1479         RESTORE_METRICS_OP ();
1480 }
1481
1482 void
1483 glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level,
1484                                   GLint xoffset, GLsizei width, GLenum format,
1485                                   GLsizei imageSize, const GLvoid *bits)
1486 {
1487         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1488
1489         GLWRAP_DEFER (glCompressedTextureSubImage1DEXT, texture, target,
1490                       level, xoffset, width, format, imageSize, bits);
1491
1492         RESTORE_METRICS_OP ();
1493 }
1494
1495 void
1496 glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level,
1497                                   GLint xoffset, GLint yoffset, GLsizei width,
1498                                   GLsizei height, GLenum format,
1499                                   GLsizei imageSize, const GLvoid *bits)
1500 {
1501         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1502
1503         GLWRAP_DEFER (glCompressedTextureSubImage2DEXT, texture, target, level,
1504                       xoffset, yoffset, width, height, format, imageSize, bits);
1505
1506         RESTORE_METRICS_OP ();
1507 }
1508
1509 void
1510 glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level,
1511                                   GLint xoffset, GLint yoffset, GLint zoffset,
1512                                   GLsizei width, GLsizei height, GLsizei depth,
1513                                   GLenum format, GLsizei imageSize,
1514                                   const GLvoid *bits)
1515 {
1516         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1517
1518         GLWRAP_DEFER (glCompressedTextureSubImage3DEXT, texture, target,
1519                       level, xoffset, yoffset, zoffset, width, height,
1520                       depth, format, imageSize, bits);
1521
1522         RESTORE_METRICS_OP ();
1523 }
1524
1525 void
1526 glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
1527                       GLenum_or_int internalformat,
1528                       GLsizei width, GLint border,
1529                       GLenum format, GLenum type, const GLvoid *pixels)
1530 {
1531         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1532
1533         GLWRAP_DEFER (glMultiTexImage1DEXT, texunit, target, level,
1534                       internalformat, width, border, format, type, pixels);
1535
1536         RESTORE_METRICS_OP ();
1537 }
1538
1539 void
1540 glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
1541                       GLenum_or_int internalformat,
1542                       GLsizei width, GLsizei height,
1543                       GLint border, GLenum format, GLenum type,
1544                       const GLvoid *pixels)
1545 {
1546         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1547
1548         GLWRAP_DEFER (glMultiTexImage2DEXT, texunit, target, level,
1549                       internalformat, width, height, border, format,
1550                       type, pixels);
1551
1552         RESTORE_METRICS_OP ();
1553 }
1554
1555 void
1556 glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level,
1557                       GLenum_or_int internalformat,
1558                       GLsizei width, GLsizei height,
1559                       GLsizei depth, GLint border, GLenum format,
1560                       GLenum type, const GLvoid *pixels)
1561 {
1562         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1563
1564         GLWRAP_DEFER (glMultiTexImage3DEXT, texunit, target, level,
1565                       internalformat, width, height, depth, border,
1566                       format, type, pixels);
1567
1568         RESTORE_METRICS_OP ();
1569 }
1570
1571 void
1572 glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
1573                          GLint xoffset, GLsizei width, GLenum format,
1574                          GLenum type, const GLvoid *pixels)
1575 {
1576         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1577
1578         GLWRAP_DEFER (glMultiTexSubImage1DEXT, texunit, target, level,
1579                       xoffset, width, format, type, pixels);
1580
1581         RESTORE_METRICS_OP ();
1582 }
1583
1584 void
1585 glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
1586                          GLint xoffset, GLint yoffset, GLsizei width,
1587                          GLsizei height, GLenum format, GLenum type,
1588                          const GLvoid *pixels)
1589 {
1590         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1591
1592         GLWRAP_DEFER (glMultiTexSubImage2DEXT, texunit, target, level, xoffset,
1593                       yoffset, width, height, format, type, pixels);
1594
1595         RESTORE_METRICS_OP ();
1596 }
1597
1598 void
1599 glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
1600                          GLint xoffset, GLint yoffset, GLint zoffset,
1601                          GLsizei width, GLsizei height, GLsizei depth,
1602                          GLenum format, GLenum type, const GLvoid *pixels)
1603 {
1604         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1605
1606         GLWRAP_DEFER (glMultiTexSubImage3DEXT, texunit, target, level,
1607                       xoffset, yoffset, zoffset, width, height, depth,
1608                       format, type, pixels);
1609
1610         RESTORE_METRICS_OP ();
1611 }