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

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