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