src/modules/coregl_tracepath_gl.c

   1 #include "coregl_tracepath.h"
   2
   3
   4 #include <stdlib.h>
   5
   6 struct _Glbuf_Data {
   7         int obj_idx;
   8         int width;
   9         int height;
  10         int bpp;
  11         char format[80];
  12
  13         struct _Glbuf_Data *next;
  14 };
  15
  16 static struct _Glbuf_Data
  17 _get_glbuf_data(GLenum pname, GLenum internalformat)
  18 {
  19         struct _Glbuf_Data data;
  20
  21         data.obj_idx = _COREGL_INT_INIT_VALUE;
  22         _orig_tracepath_glGetIntegerv(pname, &(data.obj_idx));
  23         AST(data.obj_idx != _COREGL_INT_INIT_VALUE);
  24
  25         switch (internalformat) {
  26         case GL_ALPHA:
  27                 snprintf(data.format, sizeof(data.format), "ALPHA");
  28                 data.bpp = 1;
  29                 break;
  30         case GL_LUMINANCE:
  31                 snprintf(data.format, sizeof(data.format), "LUMINANCE");
  32                 data.bpp = 1;
  33                 break;
  34         case GL_LUMINANCE_ALPHA:
  35                 snprintf(data.format, sizeof(data.format), "LUMINANCE_ALPHA");
  36                 data.bpp = 1;
  37                 break;
  38         case GL_RGB:
  39                 snprintf(data.format, sizeof(data.format), "RGB");
  40                 data.bpp = 2;
  41                 break;
  42         case GL_RGBA:
  43                 snprintf(data.format, sizeof(data.format), "RGBA");
  44                 data.bpp = 4;
  45                 break;
  46         case 0x80E1:
  47                 snprintf(data.format, sizeof(data.format), "BGRA_EXT");
  48                 data.bpp = 4;
  49                 break;
  50         case 0x84F9:
  51                 snprintf(data.format, sizeof(data.format), "DEPTH_STENCIL_OES");
  52                 data.bpp = 4;
  53                 break;
  54         case GL_DEPTH_COMPONENT:
  55                 snprintf(data.format, sizeof(data.format), "DEPTH_COMPONENT");
  56                 data.bpp = 1;
  57                 break;
  58         case 0x81A5:
  59                 snprintf(data.format, sizeof(data.format), "DEPTH_COMPONENT16_ARB");
  60                 data.bpp = 2;
  61                 break;
  62         case 0x81A6:
  63                 snprintf(data.format, sizeof(data.format), "DEPTH_COMPONENT24_ARB");
  64                 data.bpp = 3;
  65                 break;
  66         case 0x81A7:
  67                 snprintf(data.format, sizeof(data.format), "DEPTH_COMPONENT32_ARB");
  68                 data.bpp = 4;
  69                 break;
  70         case 0x8D46:
  71                 snprintf(data.format, sizeof(data.format), "STENCIL_INDEX1_OES");
  72                 data.bpp = 1;
  73                 break;
  74         case 0x8D47:
  75                 snprintf(data.format, sizeof(data.format), "STENCIL_INDEX4_OES");
  76                 data.bpp = 1;
  77                 break;
  78         case 0x8D48:
  79                 snprintf(data.format, sizeof(data.format), "STENCIL_INDEX8_OES");
  80                 data.bpp = 1;
  81                 break;
  82         default:
  83                 snprintf(data.format, sizeof(data.format), "0x%X", internalformat);
  84                 data.bpp = 0;
  85                 break;
  86         }
  87
  88         return data;
  89 }
  90
  91 static int
  92 _get_channel_by_format(GLenum internalformat)
  93 {
  94         int channel = 0;
  95         switch (internalformat) {
  96         case GL_ALPHA:
  97         case GL_LUMINANCE:
  98         case GL_DEPTH_COMPONENT:
  99         case 0x81A5:
 100         case 0x81A6:
 101         case 0x81A7:
 102         case 0x8D46:
 103         case 0x8D47:
 104         case 0x8D48:
 105                 channel = 1;
 106                 break;
 107         case GL_LUMINANCE_ALPHA:
 108         case 0x84F9:
 109                 channel = 2;
 110                 break;
 111         case GL_RGB:
 112                 channel = 3;
 113                 break;
 114         case GL_RGBA:
 115         case 0x80E1:
 116                 channel = 4;
 117                 break;
 118         }
 119         return channel;
 120 }
 121
 122 static MY_MODULE_TSTATE*
 123 _get_my_state()
 124 {
 125         MY_MODULE_TSTATE* tstate = NULL;
 126
 127         GET_MY_TSTATE(tstate, get_current_thread_state());
 128         AST(tstate != NULL);
 129
 130         return tstate;
 131 }
 132
 133 static void
 134 __addhash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data *target)
 135 {
 136         Glbuf_Data *data = glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY];
 137         if (data == NULL) {
 138                 glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY] = target;
 139         } else {
 140                 while (data->next != NULL) {
 141                         AST(data->obj_idx != target->obj_idx);
 142                         data = data->next;
 143                 }
 144                 AST(data->obj_idx != target->obj_idx);
 145                 data->next = target;
 146         }
 147         goto finish;
 148
 149 finish:
 150         return;
 151 }
 152
 153 static void
 154 __removehash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data **target)
 155 {
 156         Glbuf_Data *data = glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY];
 157         Glbuf_Data *prev = NULL;
 158         while (data != NULL) {
 159                 if (data->obj_idx == (*target)->obj_idx) {
 160                         if (prev != NULL)
 161                                 prev->next = data->next;
 162                         else
 163                                 glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY] = data->next;
 164
 165                         free(*target);
 166                         *target = NULL;
 167                         break;
 168                 }
 169                 prev = data;
 170                 data = data->next;
 171         }
 172         goto finish;
 173
 174 finish:
 175         return;
 176 }
 177
 178 static Glbuf_Data *
 179 __findhash_glbuf_object(Glbuf_Data **glbuf, int obj_idx)
 180 {
 181         Glbuf_Data *data = glbuf[obj_idx % MTD_GLBUF_HASH_ARRAY];
 182         while (data != NULL) {
 183                 if (data->obj_idx == obj_idx)
 184                         break;
 185                 data = data->next;
 186         }
 187         goto finish;
 188
 189 finish:
 190         return data;
 191 }
 192
 193 void
 194 tracepath_glbuf_clear(Glbuf_Data **glbuf)
 195 {
 196         int i;
 197
 198         for (i = 0; i < MTD_GLBUF_HASH_ARRAY; i++) {
 199                 Glbuf_Data *data = glbuf[i];
 200
 201                 while (data) {
 202                         Glbuf_Data *delitm = data;
 203                         data = data->next;
 204                         free(delitm);
 205                         delitm = NULL;
 206                 }
 207         }
 208 }
 209
 210 static void
 211 _add_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type,
 212                                   int width, int height, int bpp, const char *format)
 213 {
 214         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 215         if (data == NULL) {
 216                 data = (Glbuf_Data *)calloc(1, sizeof(Glbuf_Data));
 217                 if (data == NULL) goto finish;
 218
 219                 data->obj_idx = obj_idx;
 220                 __addhash_glbuf_object(glbuf, data);
 221         } else {
 222                 // Update
 223                 char ment[MAX_TRACE_NAME_LENGTH];
 224                 snprintf(ment, MAX_TRACE_NAME_LENGTH, "%s(%4dx%4d %s)", obj_type, data->width,
 225                                  data->height,
 226                                  data->format);
 227                 _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 228         }
 229
 230         data->width = width;
 231         data->height = height;
 232         data->bpp = bpp;
 233         snprintf(data->format, 80, "%s", format);
 234         {
 235                 char ment[MAX_TRACE_NAME_LENGTH];
 236                 snprintf(ment, MAX_TRACE_NAME_LENGTH, "%s(%4dx%4d %s)", obj_type, data->width,
 237                                  data->height,
 238                                  data->format);
 239                 _COREGL_TRACE_MEM_ADD(ment, data->width * data->height * data->bpp);
 240         }
 241         goto finish;
 242
 243 finish:
 244         return;
 245 }
 246
 247 static void
 248 _remove_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type)
 249 {
 250         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 251         if (data == NULL) {
 252                 COREGL_WARN("Error deleting %s object %d. (is not created)",
 253                                         obj_type, obj_idx);
 254                 return;
 255         }
 256
 257         {
 258                 char ment[MAX_TRACE_NAME_LENGTH];
 259                 snprintf(ment, MAX_TRACE_NAME_LENGTH, "%s(%4dx%4d %s)", obj_type, data->width,
 260                                  data->height,
 261                                  data->format);
 262                 _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 263         }
 264
 265         __removehash_glbuf_object(glbuf, &data);
 266         goto finish;
 267
 268 finish:
 269         return;
 270 }
 271
 272
 273 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 274 void
 275 _surface_trace_set(int set, GLint fbname, GLenum attachment,
 276                                    MY_MODULE_TSTATE *tstate)
 277 {
 278         int atttype = _COREGL_INT_INIT_VALUE;
 279         _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
 280                         attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &atttype);
 281         AST(atttype != _COREGL_INT_INIT_VALUE);
 282         int attname = _COREGL_INT_INIT_VALUE;
 283         _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
 284                         attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &attname);
 285         AST(attname != _COREGL_INT_INIT_VALUE);
 286         if (set == 1) {
 287                 switch (atttype) {
 288                 case GL_TEXTURE:
 289                 {
 290                         char name[256];
 291                         snprintf(name, sizeof(name), "FBOTEX_0x%X", attname);
 292                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 293                                                                                 tstate->surf_draw, fbname, attname, 0, -1, -1, -1, NULL);
 294                 }
 295                 break;
 296                 case GL_RENDERBUFFER:
 297                 {
 298                         char name[256];
 299                         snprintf(name, sizeof(name), "FBORB_0x%X", attname);
 300                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 301                                                                                 tstate->surf_draw, fbname, 0, attname, -1, -1, -1, NULL);
 302                 }
 303                 break;
 304                 }
 305         } else {
 306                 switch (atttype) {
 307                 case GL_TEXTURE:
 308                 {
 309                         char name[256];
 310                         snprintf(name, sizeof(name), "FBOTEX_0x%X", attname);
 311                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 312                                                                                 tstate->surf_draw, 0, attname, 0, -1, -1, -1, NULL);
 313                 }
 314                 break;
 315                 case GL_RENDERBUFFER:
 316                 {
 317                         char name[256];
 318                         snprintf(name, sizeof(name), "FBORB_0x%X", attname);
 319                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 320                                                                                 tstate->surf_draw, 0, 0, attname, -1, -1, -1, NULL);
 321                 }
 322                 break;
 323                 }
 324         }
 325 }
 326
 327 void
 328 tracepath_fbdump_update(GLint set)
 329 {
 330         if (get_trace_surface_flag() == 1) {
 331                 GLint fbname = _COREGL_INT_INIT_VALUE;
 332                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 333                 AST(fbname != _COREGL_INT_INIT_VALUE);
 334                 if (fbname != 0) {
 335                         MY_MODULE_TSTATE* tstate = _get_my_state();
 336                         if (tstate && tstate->ctx != NULL) {
 337                                 _surface_trace_set(set, fbname, GL_COLOR_ATTACHMENT0, tstate);
 338 //                              _surface_trace_set(set, fbname, GL_DEPTH_ATTACHMENT, tstate);
 339 //                              _surface_trace_set(set, fbname, GL_STENCIL_ATTACHMENT, tstate);
 340                         }
 341                 }
 342         }
 343 }
 344 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 345
 346 /* GLES 1.1 */
 347 void
 348 tracepath_glAlphaFunc(GLenum func, GLclampf ref)
 349 {
 350         _COREGL_TRACEPATH_FUNC_BEGIN();
 351         _orig_tracepath_glAlphaFunc(func, ref);
 352         goto finish;
 353
 354 finish:
 355         _COREGL_TRACEPATH_FUNC_END();
 356 }
 357
 358 void
 359 tracepath_glClipPlanef(GLenum plane, const GLfloat *equation)
 360 {
 361         _COREGL_TRACEPATH_FUNC_BEGIN();
 362         _orig_tracepath_glClipPlanef(plane, equation);
 363         goto finish;
 364
 365 finish:
 366         _COREGL_TRACEPATH_FUNC_END();
 367 }
 368
 369 void
 370 tracepath_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 371 {
 372         _COREGL_TRACEPATH_FUNC_BEGIN();
 373         _orig_tracepath_glColor4f(red, green, blue, alpha);
 374         goto finish;
 375
 376 finish:
 377         _COREGL_TRACEPATH_FUNC_END();
 378 }
 379
 380 void
 381 tracepath_glFogf(GLenum pname, GLfloat param)
 382 {
 383         _COREGL_TRACEPATH_FUNC_BEGIN();
 384         _orig_tracepath_glFogf(pname, param);
 385         goto finish;
 386
 387 finish:
 388         _COREGL_TRACEPATH_FUNC_END();
 389 }
 390
 391 void
 392 tracepath_glFogfv(GLenum pname, const GLfloat *params)
 393 {
 394         _COREGL_TRACEPATH_FUNC_BEGIN();
 395         _orig_tracepath_glFogfv(pname, params);
 396         goto finish;
 397
 398 finish:
 399         _COREGL_TRACEPATH_FUNC_END();
 400 }
 401
 402 void
 403 tracepath_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
 404                                          GLfloat zNear, GLfloat zFar)
 405 {
 406         _COREGL_TRACEPATH_FUNC_BEGIN();
 407         _orig_tracepath_glFrustumf(left, right, bottom, top, zNear, zFar);
 408         goto finish;
 409
 410 finish:
 411         _COREGL_TRACEPATH_FUNC_END();
 412 }
 413
 414 void
 415 tracepath_glGetClipPlanef(GLenum pname, GLfloat eqn[4])
 416 {
 417         _COREGL_TRACEPATH_FUNC_BEGIN();
 418         _orig_tracepath_glGetClipPlanef(pname, eqn);
 419         goto finish;
 420
 421 finish:
 422         _COREGL_TRACEPATH_FUNC_END();
 423 }
 424
 425 void
 426 tracepath_glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 427 {
 428         _COREGL_TRACEPATH_FUNC_BEGIN();
 429         _orig_tracepath_glGetLightfv(light, pname, params);
 430         goto finish;
 431
 432 finish:
 433         _COREGL_TRACEPATH_FUNC_END();
 434 }
 435
 436 void
 437 tracepath_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 438 {
 439         _COREGL_TRACEPATH_FUNC_BEGIN();
 440         _orig_tracepath_glGetMaterialfv(face, pname, params);
 441         goto finish;
 442
 443 finish:
 444         _COREGL_TRACEPATH_FUNC_END();
 445 }
 446
 447 void
 448 tracepath_glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params)
 449 {
 450         _COREGL_TRACEPATH_FUNC_BEGIN();
 451         _orig_tracepath_glGetTexEnvfv(env, pname, params);
 452         goto finish;
 453
 454 finish:
 455         _COREGL_TRACEPATH_FUNC_END();
 456 }
 457
 458 void
 459 tracepath_glLightModelf(GLenum pname, GLfloat param)
 460 {
 461         _COREGL_TRACEPATH_FUNC_BEGIN();
 462         _orig_tracepath_glLightModelf(pname, param);
 463         goto finish;
 464
 465 finish:
 466         _COREGL_TRACEPATH_FUNC_END();
 467 }
 468
 469 void
 470 tracepath_glLightModelfv(GLenum pname, const GLfloat *params)
 471 {
 472         _COREGL_TRACEPATH_FUNC_BEGIN();
 473         _orig_tracepath_glLightModelfv(pname, params);
 474         goto finish;
 475
 476 finish:
 477         _COREGL_TRACEPATH_FUNC_END();
 478 }
 479
 480 void
 481 tracepath_glLightf(GLenum light, GLenum pname, GLfloat param)
 482 {
 483         _COREGL_TRACEPATH_FUNC_BEGIN();
 484         _orig_tracepath_glLightf(light, pname, param);
 485         goto finish;
 486
 487 finish:
 488         _COREGL_TRACEPATH_FUNC_END();
 489 }
 490
 491 void
 492 tracepath_glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 493 {
 494         _COREGL_TRACEPATH_FUNC_BEGIN();
 495         _orig_tracepath_glLightfv(light, pname, params);
 496         goto finish;
 497
 498 finish:
 499         _COREGL_TRACEPATH_FUNC_END();
 500 }
 501
 502 void
 503 tracepath_glLoadMatrixf(const GLfloat *m)
 504 {
 505         _COREGL_TRACEPATH_FUNC_BEGIN();
 506         _orig_tracepath_glLoadMatrixf(m);
 507         goto finish;
 508
 509 finish:
 510         _COREGL_TRACEPATH_FUNC_END();
 511 }
 512
 513 void
 514 tracepath_glMaterialf(GLenum face, GLenum pname, GLfloat param)
 515 {
 516         _COREGL_TRACEPATH_FUNC_BEGIN();
 517         _orig_tracepath_glMaterialf(face, pname, param);
 518         goto finish;
 519
 520 finish:
 521         _COREGL_TRACEPATH_FUNC_END();
 522 }
 523
 524 void
 525 tracepath_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 526 {
 527         _COREGL_TRACEPATH_FUNC_BEGIN();
 528         _orig_tracepath_glMaterialfv(face, pname, params);
 529         goto finish;
 530
 531 finish:
 532         _COREGL_TRACEPATH_FUNC_END();
 533 }
 534
 535 void
 536 tracepath_glMultMatrixf(const GLfloat *m)
 537 {
 538         _COREGL_TRACEPATH_FUNC_BEGIN();
 539         _orig_tracepath_glMultMatrixf(m);
 540         goto finish;
 541
 542 finish:
 543         _COREGL_TRACEPATH_FUNC_END();
 544 }
 545
 546 void
 547 tracepath_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r,
 548                                                         GLfloat q)
 549 {
 550         _COREGL_TRACEPATH_FUNC_BEGIN();
 551         _orig_tracepath_glMultiTexCoord4f(target, s, t, r, q);
 552         goto finish;
 553
 554 finish:
 555         _COREGL_TRACEPATH_FUNC_END();
 556 }
 557
 558 void
 559 tracepath_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 560 {
 561         _COREGL_TRACEPATH_FUNC_BEGIN();
 562         _orig_tracepath_glNormal3f(nx, ny, nz);
 563         goto finish;
 564
 565 finish:
 566         _COREGL_TRACEPATH_FUNC_END();
 567 }
 568
 569 void
 570 tracepath_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
 571                                    GLfloat zNear, GLfloat zFar)
 572 {
 573         _COREGL_TRACEPATH_FUNC_BEGIN();
 574         _orig_tracepath_glOrthof(left, right, bottom, top, zNear, zFar);
 575         goto finish;
 576
 577 finish:
 578         _COREGL_TRACEPATH_FUNC_END();
 579 }
 580
 581 void
 582 tracepath_glPointParameterf(GLenum pname, GLfloat param)
 583 {
 584         _COREGL_TRACEPATH_FUNC_BEGIN();
 585         _orig_tracepath_glPointParameterf(pname, param);
 586         goto finish;
 587
 588 finish:
 589         _COREGL_TRACEPATH_FUNC_END();
 590 }
 591
 592 void
 593 tracepath_glPointParameterfv(GLenum pname, const GLfloat *params)
 594 {
 595         _COREGL_TRACEPATH_FUNC_BEGIN();
 596         _orig_tracepath_glPointParameterfv(pname, params);
 597         goto finish;
 598
 599 finish:
 600         _COREGL_TRACEPATH_FUNC_END();
 601 }
 602
 603 void
 604 tracepath_glPointSize(GLfloat size)
 605 {
 606         _COREGL_TRACEPATH_FUNC_BEGIN();
 607         _orig_tracepath_glPointSize(size);
 608         goto finish;
 609
 610 finish:
 611         _COREGL_TRACEPATH_FUNC_END();
 612 }
 613
 614 void
 615 tracepath_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 616 {
 617         _COREGL_TRACEPATH_FUNC_BEGIN();
 618         _orig_tracepath_glRotatef(angle, x, y, z);
 619         goto finish;
 620
 621 finish:
 622         _COREGL_TRACEPATH_FUNC_END();
 623 }
 624
 625 void
 626 tracepath_glScalef(GLfloat x, GLfloat y, GLfloat z)
 627 {
 628         _COREGL_TRACEPATH_FUNC_BEGIN();
 629         _orig_tracepath_glScalef(x, y, z);
 630         goto finish;
 631
 632 finish:
 633         _COREGL_TRACEPATH_FUNC_END();
 634 }
 635
 636 void
 637 tracepath_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 638 {
 639         _COREGL_TRACEPATH_FUNC_BEGIN();
 640         _orig_tracepath_glTexEnvf(target, pname, param);
 641         goto finish;
 642
 643 finish:
 644         _COREGL_TRACEPATH_FUNC_END();
 645 }
 646
 647 void
 648 tracepath_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 649 {
 650         _COREGL_TRACEPATH_FUNC_BEGIN();
 651         _orig_tracepath_glTexEnvfv(target, pname, params);
 652         goto finish;
 653
 654 finish:
 655         _COREGL_TRACEPATH_FUNC_END();
 656 }
 657
 658 void
 659 tracepath_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 660 {
 661         _COREGL_TRACEPATH_FUNC_BEGIN();
 662         _orig_tracepath_glTranslatef(x, y, z);
 663         goto finish;
 664
 665 finish:
 666         _COREGL_TRACEPATH_FUNC_END();
 667 }
 668
 669 void
 670 tracepath_glAlphaFuncx(GLenum func, GLclampx ref)
 671 {
 672         _COREGL_TRACEPATH_FUNC_BEGIN();
 673         _orig_tracepath_glAlphaFuncx(func, ref);
 674         goto finish;
 675
 676 finish:
 677         _COREGL_TRACEPATH_FUNC_END();
 678 }
 679
 680 void
 681 tracepath_glClearColorx(GLclampx red, GLclampx green, GLclampx blue,
 682                                                 GLclampx alpha)
 683 {
 684         _COREGL_TRACEPATH_FUNC_BEGIN();
 685         _orig_tracepath_glClearColorx(red, green, blue, alpha);
 686         goto finish;
 687
 688 finish:
 689         _COREGL_TRACEPATH_FUNC_END();
 690 }
 691
 692 void
 693 tracepath_glClearDepthx(GLclampx depth)
 694 {
 695         _COREGL_TRACEPATH_FUNC_BEGIN();
 696         _orig_tracepath_glClearDepthx(depth);
 697         goto finish;
 698
 699 finish:
 700         _COREGL_TRACEPATH_FUNC_END();
 701 }
 702
 703 void
 704 tracepath_glClientActiveTexture(GLenum texture)
 705 {
 706         _COREGL_TRACEPATH_FUNC_BEGIN();
 707         _orig_tracepath_glClientActiveTexture(texture);
 708         goto finish;
 709
 710 finish:
 711         _COREGL_TRACEPATH_FUNC_END();
 712 }
 713
 714 void
 715 tracepath_glClipPlanex(GLenum plane, const GLfixed *equation)
 716 {
 717         _COREGL_TRACEPATH_FUNC_BEGIN();
 718         _orig_tracepath_glClipPlanex(plane, equation);
 719         goto finish;
 720
 721 finish:
 722         _COREGL_TRACEPATH_FUNC_END();
 723 }
 724
 725 void
 726 tracepath_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 727 {
 728         _COREGL_TRACEPATH_FUNC_BEGIN();
 729         _orig_tracepath_glColor4ub(red, green, blue, alpha);
 730         goto finish;
 731
 732 finish:
 733         _COREGL_TRACEPATH_FUNC_END();
 734 }
 735
 736 void
 737 tracepath_glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 738 {
 739         _COREGL_TRACEPATH_FUNC_BEGIN();
 740         _orig_tracepath_glColor4x(red, green, blue, alpha);
 741         goto finish;
 742
 743 finish:
 744         _COREGL_TRACEPATH_FUNC_END();
 745 }
 746
 747 void
 748 tracepath_glColorPointer(GLint size, GLenum type, GLsizei stride,
 749                                                  const GLvoid *pointer)
 750 {
 751         _COREGL_TRACEPATH_FUNC_BEGIN();
 752         _orig_tracepath_glColorPointer(size, type, stride, pointer);
 753         goto finish;
 754
 755 finish:
 756         _COREGL_TRACEPATH_FUNC_END();
 757 }
 758
 759 void
 760 tracepath_glDepthRangex(GLclampx zNear, GLclampx zFar)
 761 {
 762         _COREGL_TRACEPATH_FUNC_BEGIN();
 763         _orig_tracepath_glDepthRangex(zNear, zFar);
 764         goto finish;
 765
 766 finish:
 767         _COREGL_TRACEPATH_FUNC_END();
 768 }
 769
 770 void
 771 tracepath_glDisableClientState(GLenum array)
 772 {
 773         _COREGL_TRACEPATH_FUNC_BEGIN();
 774         _orig_tracepath_glDisableClientState(array);
 775         goto finish;
 776
 777 finish:
 778         _COREGL_TRACEPATH_FUNC_END();
 779 }
 780
 781 void
 782 tracepath_glEnableClientState(GLenum array)
 783 {
 784         _COREGL_TRACEPATH_FUNC_BEGIN();
 785         _orig_tracepath_glEnableClientState(array);
 786         goto finish;
 787
 788 finish:
 789         _COREGL_TRACEPATH_FUNC_END();
 790 }
 791
 792 void
 793 tracepath_glFogx(GLenum pname, GLfixed param)
 794 {
 795         _COREGL_TRACEPATH_FUNC_BEGIN();
 796         _orig_tracepath_glFogx(pname, param);
 797         goto finish;
 798
 799 finish:
 800         _COREGL_TRACEPATH_FUNC_END();
 801 }
 802
 803 void
 804 tracepath_glFogxv(GLenum pname, const GLfixed *params)
 805 {
 806         _COREGL_TRACEPATH_FUNC_BEGIN();
 807         _orig_tracepath_glFogxv(pname, params);
 808         goto finish;
 809
 810 finish:
 811         _COREGL_TRACEPATH_FUNC_END();
 812 }
 813
 814 void
 815 tracepath_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
 816                                          GLfixed zNear, GLfixed zFar)
 817 {
 818         _COREGL_TRACEPATH_FUNC_BEGIN();
 819         _orig_tracepath_glFrustumx(left, right, bottom, top, zNear, zFar);
 820         goto finish;
 821
 822 finish:
 823         _COREGL_TRACEPATH_FUNC_END();
 824 }
 825
 826 void
 827 tracepath_glGetClipPlanex(GLenum pname, GLfixed eqn[4])
 828 {
 829         _COREGL_TRACEPATH_FUNC_BEGIN();
 830         _orig_tracepath_glGetClipPlanex(pname, eqn);
 831         goto finish;
 832
 833 finish:
 834         _COREGL_TRACEPATH_FUNC_END();
 835 }
 836
 837 void
 838 tracepath_glGetFixedv(GLenum pname, GLfixed *params)
 839 {
 840         _COREGL_TRACEPATH_FUNC_BEGIN();
 841         _orig_tracepath_glGetFixedv(pname, params);
 842         goto finish;
 843
 844 finish:
 845         _COREGL_TRACEPATH_FUNC_END();
 846 }
 847
 848 void
 849 tracepath_glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
 850 {
 851         _COREGL_TRACEPATH_FUNC_BEGIN();
 852         _orig_tracepath_glGetLightxv(light, pname, params);
 853         goto finish;
 854
 855 finish:
 856         _COREGL_TRACEPATH_FUNC_END();
 857 }
 858
 859 void
 860 tracepath_glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
 861 {
 862         _COREGL_TRACEPATH_FUNC_BEGIN();
 863         _orig_tracepath_glGetMaterialxv(face, pname, params);
 864         goto finish;
 865
 866 finish:
 867         _COREGL_TRACEPATH_FUNC_END();
 868 }
 869
 870 void
 871 tracepath_glGetTexEnviv(GLenum env, GLenum pname, GLint *params)
 872 {
 873         _COREGL_TRACEPATH_FUNC_BEGIN();
 874         _orig_tracepath_glGetTexEnviv(env, pname, params);
 875         goto finish;
 876
 877 finish:
 878         _COREGL_TRACEPATH_FUNC_END();
 879 }
 880
 881 void
 882 tracepath_glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params)
 883 {
 884         _COREGL_TRACEPATH_FUNC_BEGIN();
 885         _orig_tracepath_glGetTexEnvxv(env, pname, params);
 886         goto finish;
 887
 888 finish:
 889         _COREGL_TRACEPATH_FUNC_END();
 890 }
 891
 892 void
 893 tracepath_glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
 894 {
 895         _COREGL_TRACEPATH_FUNC_BEGIN();
 896         _orig_tracepath_glGetTexParameterxv(target, pname, params);
 897         goto finish;
 898
 899 finish:
 900         _COREGL_TRACEPATH_FUNC_END();
 901 }
 902
 903 void
 904 tracepath_glLightModelx(GLenum pname, GLfixed param)
 905 {
 906         _COREGL_TRACEPATH_FUNC_BEGIN();
 907         _orig_tracepath_glLightModelx(pname, param);
 908         goto finish;
 909
 910 finish:
 911         _COREGL_TRACEPATH_FUNC_END();
 912 }
 913
 914 void
 915 tracepath_glLightModelxv(GLenum pname, const GLfixed *params)
 916 {
 917         _COREGL_TRACEPATH_FUNC_BEGIN();
 918         _orig_tracepath_glLightModelxv(pname, params);
 919         goto finish;
 920
 921 finish:
 922         _COREGL_TRACEPATH_FUNC_END();
 923 }
 924
 925 void
 926 tracepath_glLightx(GLenum light, GLenum pname, GLfixed param)
 927 {
 928         _COREGL_TRACEPATH_FUNC_BEGIN();
 929         _orig_tracepath_glLightx(light, pname, param);
 930         goto finish;
 931
 932 finish:
 933         _COREGL_TRACEPATH_FUNC_END();
 934 }
 935
 936 void
 937 tracepath_glLightxv(GLenum light, GLenum pname, const GLfixed *params)
 938 {
 939         _COREGL_TRACEPATH_FUNC_BEGIN();
 940         _orig_tracepath_glLightxv(light, pname, params);
 941         goto finish;
 942
 943 finish:
 944         _COREGL_TRACEPATH_FUNC_END();
 945 }
 946
 947 void
 948 tracepath_glLineWidthx(GLfixed width)
 949 {
 950         _COREGL_TRACEPATH_FUNC_BEGIN();
 951         _orig_tracepath_glLineWidthx(width);
 952         goto finish;
 953
 954 finish:
 955         _COREGL_TRACEPATH_FUNC_END();
 956 }
 957
 958 void
 959 tracepath_glLoadIdentity(void)
 960 {
 961         _COREGL_TRACEPATH_FUNC_BEGIN();
 962         _orig_tracepath_glLoadIdentity();
 963         goto finish;
 964
 965 finish:
 966         _COREGL_TRACEPATH_FUNC_END();
 967 }
 968
 969 void
 970 tracepath_glLoadMatrixx(const GLfixed *m)
 971 {
 972         _COREGL_TRACEPATH_FUNC_BEGIN();
 973         _orig_tracepath_glLoadMatrixx(m);
 974         goto finish;
 975
 976 finish:
 977         _COREGL_TRACEPATH_FUNC_END();
 978 }
 979
 980 void
 981 tracepath_glLogicOp(GLenum opcode)
 982 {
 983         _COREGL_TRACEPATH_FUNC_BEGIN();
 984         _orig_tracepath_glLogicOp(opcode);
 985         goto finish;
 986
 987 finish:
 988         _COREGL_TRACEPATH_FUNC_END();
 989 }
 990
 991 void
 992 tracepath_glMaterialx(GLenum face, GLenum pname, GLfixed param)
 993 {
 994         _COREGL_TRACEPATH_FUNC_BEGIN();
 995         _orig_tracepath_glMaterialx(face, pname, param);
 996         goto finish;
 997
 998 finish:
 999         _COREGL_TRACEPATH_FUNC_END();
1000 }
1001
1002 void
1003 tracepath_glMaterialxv(GLenum face, GLenum pname, const GLfixed *params)
1004 {
1005         _COREGL_TRACEPATH_FUNC_BEGIN();
1006         _orig_tracepath_glMaterialxv(face, pname, params);
1007         goto finish;
1008
1009 finish:
1010         _COREGL_TRACEPATH_FUNC_END();
1011 }
1012
1013 void
1014 tracepath_glMatrixMode(GLenum mode)
1015 {
1016         _COREGL_TRACEPATH_FUNC_BEGIN();
1017         _orig_tracepath_glMatrixMode(mode);
1018         goto finish;
1019
1020 finish:
1021         _COREGL_TRACEPATH_FUNC_END();
1022 }
1023
1024 void
1025 tracepath_glMultMatrixx(const GLfixed *m)
1026 {
1027         _COREGL_TRACEPATH_FUNC_BEGIN();
1028         _orig_tracepath_glMultMatrixx(m);
1029         goto finish;
1030
1031 finish:
1032         _COREGL_TRACEPATH_FUNC_END();
1033 }
1034
1035 void
1036 tracepath_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r,
1037                                                         GLfixed q)
1038 {
1039         _COREGL_TRACEPATH_FUNC_BEGIN();
1040         _orig_tracepath_glMultiTexCoord4x(target, s, t, r, q);
1041         goto finish;
1042
1043 finish:
1044         _COREGL_TRACEPATH_FUNC_END();
1045 }
1046
1047 void
1048 tracepath_glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
1049 {
1050         _COREGL_TRACEPATH_FUNC_BEGIN();
1051         _orig_tracepath_glNormal3x(nx, ny, nz);
1052         goto finish;
1053
1054 finish:
1055         _COREGL_TRACEPATH_FUNC_END();
1056 }
1057
1058 void
1059 tracepath_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
1060 {
1061         _COREGL_TRACEPATH_FUNC_BEGIN();
1062         _orig_tracepath_glNormalPointer(type, stride, pointer);
1063         goto finish;
1064
1065 finish:
1066         _COREGL_TRACEPATH_FUNC_END();
1067 }
1068
1069 void
1070 tracepath_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
1071                                    GLfixed zNear, GLfixed zFar)
1072 {
1073         _COREGL_TRACEPATH_FUNC_BEGIN();
1074         _orig_tracepath_glOrthox(left, right, bottom, top, zNear, zFar);
1075         goto finish;
1076
1077 finish:
1078         _COREGL_TRACEPATH_FUNC_END();
1079 }
1080
1081 void
1082 tracepath_glPointParameterx(GLenum pname, GLfixed param)
1083 {
1084         _COREGL_TRACEPATH_FUNC_BEGIN();
1085         _orig_tracepath_glPointParameterx(pname, param);
1086         goto finish;
1087
1088 finish:
1089         _COREGL_TRACEPATH_FUNC_END();
1090 }
1091
1092 void
1093 tracepath_glPointParameterxv(GLenum pname, const GLfixed *params)
1094 {
1095         _COREGL_TRACEPATH_FUNC_BEGIN();
1096         _orig_tracepath_glPointParameterxv(pname, params);
1097         goto finish;
1098
1099 finish:
1100         _COREGL_TRACEPATH_FUNC_END();
1101 }
1102
1103 void
1104 tracepath_glPointSizex(GLfixed size)
1105 {
1106         _COREGL_TRACEPATH_FUNC_BEGIN();
1107         _orig_tracepath_glPointSizex(size);
1108         goto finish;
1109
1110 finish:
1111         _COREGL_TRACEPATH_FUNC_END();
1112 }
1113
1114 void
1115 tracepath_glPolygonOffsetx(GLfixed factor, GLfixed units)
1116 {
1117         _COREGL_TRACEPATH_FUNC_BEGIN();
1118         _orig_tracepath_glPolygonOffsetx(factor, units);
1119         goto finish;
1120
1121 finish:
1122         _COREGL_TRACEPATH_FUNC_END();
1123 }
1124
1125 void
1126 tracepath_glPopMatrix(void)
1127 {
1128         _COREGL_TRACEPATH_FUNC_BEGIN();
1129         _orig_tracepath_glPopMatrix();
1130         goto finish;
1131
1132 finish:
1133         _COREGL_TRACEPATH_FUNC_END();
1134 }
1135
1136 void
1137 tracepath_glPushMatrix(void)
1138 {
1139         _COREGL_TRACEPATH_FUNC_BEGIN();
1140         _orig_tracepath_glPushMatrix();
1141         goto finish;
1142
1143 finish:
1144         _COREGL_TRACEPATH_FUNC_END();
1145 }
1146
1147 void
1148 tracepath_glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
1149 {
1150         _COREGL_TRACEPATH_FUNC_BEGIN();
1151         _orig_tracepath_glRotatex (angle, x, y, z);
1152         goto finish;
1153
1154 finish:
1155         _COREGL_TRACEPATH_FUNC_END();
1156 }
1157
1158 void
1159 tracepath_glSampleCoveragex(GLclampx value, GLboolean invert)
1160 {
1161         _COREGL_TRACEPATH_FUNC_BEGIN();
1162         _orig_tracepath_glSampleCoveragex(value, invert);
1163         goto finish;
1164
1165 finish:
1166         _COREGL_TRACEPATH_FUNC_END();
1167 }
1168
1169 void
1170 tracepath_glScalex(GLfixed x, GLfixed y, GLfixed z)
1171 {
1172         _COREGL_TRACEPATH_FUNC_BEGIN();
1173         _orig_tracepath_glScalex (x, y, z);
1174         goto finish;
1175
1176 finish:
1177         _COREGL_TRACEPATH_FUNC_END();
1178 }
1179
1180 void
1181 tracepath_glShadeModel(GLenum mode)
1182 {
1183         _COREGL_TRACEPATH_FUNC_BEGIN();
1184         _orig_tracepath_glShadeModel(mode);
1185         goto finish;
1186
1187 finish:
1188         _COREGL_TRACEPATH_FUNC_END();
1189 }
1190
1191 void
1192 tracepath_glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
1193                                                         const GLvoid *pointer)
1194 {
1195         _COREGL_TRACEPATH_FUNC_BEGIN();
1196         _orig_tracepath_glTexCoordPointer(size, type, stride, pointer);
1197         goto finish;
1198
1199 finish:
1200         _COREGL_TRACEPATH_FUNC_END();
1201 }
1202
1203 void
1204 tracepath_glTexEnvi(GLenum target, GLenum pname, GLint param)
1205 {
1206         _COREGL_TRACEPATH_FUNC_BEGIN();
1207         _orig_tracepath_glTexEnvi(target, pname, param);
1208         goto finish;
1209
1210 finish:
1211         _COREGL_TRACEPATH_FUNC_END();
1212 }
1213
1214 void
1215 tracepath_glTexEnvx(GLenum target, GLenum pname, GLfixed param)
1216 {
1217         _COREGL_TRACEPATH_FUNC_BEGIN();
1218         _orig_tracepath_glTexEnvx(target, pname, param);
1219         goto finish;
1220
1221 finish:
1222         _COREGL_TRACEPATH_FUNC_END();
1223 }
1224
1225 void
1226 tracepath_glTexEnviv(GLenum target, GLenum pname, const GLint *params)
1227 {
1228         _COREGL_TRACEPATH_FUNC_BEGIN();
1229         _orig_tracepath_glTexEnviv(target, pname, params);
1230         goto finish;
1231
1232 finish:
1233         _COREGL_TRACEPATH_FUNC_END();
1234 }
1235
1236 void
1237 tracepath_glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
1238 {
1239         _COREGL_TRACEPATH_FUNC_BEGIN();
1240         _orig_tracepath_glTexEnvxv(target, pname, params);
1241         goto finish;
1242
1243 finish:
1244         _COREGL_TRACEPATH_FUNC_END();
1245 }
1246
1247 void
1248 tracepath_glTexParameterx(GLenum target, GLenum pname, GLfixed param)
1249 {
1250         _COREGL_TRACEPATH_FUNC_BEGIN();
1251         _orig_tracepath_glTexParameterx(target, pname, param);
1252         goto finish;
1253
1254 finish:
1255         _COREGL_TRACEPATH_FUNC_END();
1256 }
1257
1258 void
1259 tracepath_glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
1260 {
1261         _COREGL_TRACEPATH_FUNC_BEGIN();
1262         _orig_tracepath_glTexParameterxv(target, pname, params);
1263         goto finish;
1264
1265 finish:
1266         _COREGL_TRACEPATH_FUNC_END();
1267 }
1268
1269 void
1270 tracepath_glTranslatex(GLfixed x, GLfixed y, GLfixed z)
1271 {
1272         _COREGL_TRACEPATH_FUNC_BEGIN();
1273         _orig_tracepath_glTranslatex(x, y, z);
1274         goto finish;
1275
1276 finish:
1277         _COREGL_TRACEPATH_FUNC_END();
1278 }
1279
1280 void
1281 tracepath_glVertexPointer(GLint size, GLenum type, GLsizei stride,
1282                                                   const GLvoid *pointer)
1283 {
1284         _COREGL_TRACEPATH_FUNC_BEGIN();
1285         _orig_tracepath_glVertexPointer(size, type, stride, pointer);
1286         goto finish;
1287
1288 finish:
1289         _COREGL_TRACEPATH_FUNC_END();
1290 }
1291
1292 /* Khronos GLES 1.1 CTS requires glPointSizePointerOES as shared library symbol.*/
1293 void
1294 tracepath_glPointSizePointerOES(GLenum type, GLsizei stride,
1295                                                                 const GLvoid *pointer)
1296 {
1297         _COREGL_TRACEPATH_FUNC_BEGIN();
1298         _orig_tracepath_glPointSizePointerOES(type, stride, pointer);
1299         goto finish;
1300
1301 finish:
1302         _COREGL_TRACEPATH_FUNC_END();
1303 }
1304
1305 /* end of GLES 1.1*/
1306
1307 /* GLES 1.1 extensions */
1308 void
1309 tracepath_glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width,
1310                                                 GLshort height)
1311 {
1312         _COREGL_TRACEPATH_FUNC_BEGIN();
1313         _orig_tracepath_glDrawTexsOES(x, y, z, width, height);
1314
1315         goto finish;
1316
1317 finish:
1318         _COREGL_TRACEPATH_FUNC_END();
1319 }
1320
1321 void
1322 tracepath_glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
1323 {
1324         _COREGL_TRACEPATH_FUNC_BEGIN();
1325         _orig_tracepath_glDrawTexiOES(x, y, z, width, height);
1326
1327         goto finish;
1328
1329 finish:
1330         _COREGL_TRACEPATH_FUNC_END();
1331 }
1332
1333 void
1334 tracepath_glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width,
1335                                                 GLfixed height)
1336 {
1337         _COREGL_TRACEPATH_FUNC_BEGIN();
1338         _orig_tracepath_glDrawTexxOES(x, y, z, width, height);
1339
1340         goto finish;
1341
1342 finish:
1343         _COREGL_TRACEPATH_FUNC_END();
1344 }
1345
1346 void
1347 tracepath_glDrawTexsvOES(const GLshort *coords)
1348 {
1349         _COREGL_TRACEPATH_FUNC_BEGIN();
1350         _orig_tracepath_glDrawTexsvOES(coords);
1351
1352         goto finish;
1353
1354 finish:
1355         _COREGL_TRACEPATH_FUNC_END();
1356 }
1357
1358 void
1359 tracepath_glDrawTexivOES(const GLint *coords)
1360 {
1361         _COREGL_TRACEPATH_FUNC_BEGIN();
1362         _orig_tracepath_glDrawTexivOES(coords);
1363
1364         goto finish;
1365
1366 finish:
1367         _COREGL_TRACEPATH_FUNC_END();
1368 }
1369
1370 void
1371 tracepath_glDrawTexxvOES(const GLfixed *coords)
1372 {
1373         _COREGL_TRACEPATH_FUNC_BEGIN();
1374         _orig_tracepath_glDrawTexxvOES(coords);
1375
1376         goto finish;
1377
1378 finish:
1379         _COREGL_TRACEPATH_FUNC_END();
1380 }
1381
1382 void
1383 tracepath_glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width,
1384                                                 GLfloat height)
1385 {
1386         _COREGL_TRACEPATH_FUNC_BEGIN();
1387         _orig_tracepath_glDrawTexfOES(x, y, z, width, height);
1388
1389         goto finish;
1390
1391 finish:
1392         _COREGL_TRACEPATH_FUNC_END();
1393 }
1394
1395 void
1396 tracepath_glDrawTexfvOES(const GLfloat *coords)
1397 {
1398         _COREGL_TRACEPATH_FUNC_BEGIN();
1399         _orig_tracepath_glDrawTexfvOES(coords);
1400
1401         goto finish;
1402
1403 finish:
1404         _COREGL_TRACEPATH_FUNC_END();
1405 }
1406
1407 void
1408 tracepath_glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
1409 {
1410         _COREGL_TRACEPATH_FUNC_BEGIN();
1411         _orig_tracepath_glCurrentPaletteMatrixOES(matrixpaletteindex);
1412
1413         goto finish;
1414
1415 finish:
1416         _COREGL_TRACEPATH_FUNC_END();
1417 }
1418
1419 void
1420 tracepath_glLoadPaletteFromModelViewMatrixOES(void)
1421 {
1422         _COREGL_TRACEPATH_FUNC_BEGIN();
1423         _orig_tracepath_glLoadPaletteFromModelViewMatrixOES();
1424
1425         goto finish;
1426
1427 finish:
1428         _COREGL_TRACEPATH_FUNC_END();
1429 }
1430
1431 void
1432 tracepath_glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride,
1433                                                                   const GLvoid *pointer)
1434 {
1435         _COREGL_TRACEPATH_FUNC_BEGIN();
1436         _orig_tracepath_glMatrixIndexPointerOES(size, type, stride, pointer);
1437
1438         goto finish;
1439
1440 finish:
1441         _COREGL_TRACEPATH_FUNC_END();
1442 }
1443
1444 void
1445 tracepath_glWeightPointerOES(GLint size, GLenum type, GLsizei stride,
1446                                                          const GLvoid *pointer)
1447 {
1448         _COREGL_TRACEPATH_FUNC_BEGIN();
1449         _orig_tracepath_glWeightPointerOES(size, type, stride, pointer);
1450
1451         goto finish;
1452
1453 finish:
1454         _COREGL_TRACEPATH_FUNC_END();
1455 }
1456
1457 GLbitfield
1458 tracepath_glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16])
1459 {
1460         GLuint ret = _COREGL_INT_INIT_VALUE;
1461
1462         _COREGL_TRACEPATH_FUNC_BEGIN();
1463         ret = _orig_tracepath_glQueryMatrixxOES(mantissa, exponent);
1464
1465         goto finish;
1466
1467 finish:
1468         _COREGL_TRACEPATH_FUNC_END();
1469         return ret;
1470 }
1471
1472 void
1473 tracepath_glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
1474 {
1475         _COREGL_TRACEPATH_FUNC_BEGIN();
1476         _orig_tracepath_glTexGenfOES(coord, pname, param);
1477
1478         goto finish;
1479
1480 finish:
1481         _COREGL_TRACEPATH_FUNC_END();
1482 }
1483
1484 void
1485 tracepath_glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
1486 {
1487         _COREGL_TRACEPATH_FUNC_BEGIN();
1488         _orig_tracepath_glTexGenfvOES(coord, pname, params);
1489
1490         goto finish;
1491
1492 finish:
1493         _COREGL_TRACEPATH_FUNC_END();
1494 }
1495
1496 void
1497 tracepath_glTexGeniOES(GLenum coord, GLenum pname, GLint param)
1498 {
1499         _COREGL_TRACEPATH_FUNC_BEGIN();
1500         _orig_tracepath_glTexGeniOES(coord, pname, param);
1501
1502         goto finish;
1503
1504 finish:
1505         _COREGL_TRACEPATH_FUNC_END();
1506 }
1507
1508 void
1509 tracepath_glTexGenivOES(GLenum coord, GLenum pname, const GLint *params)
1510 {
1511         _COREGL_TRACEPATH_FUNC_BEGIN();
1512         _orig_tracepath_glTexGenivOES(coord, pname, params);
1513
1514         goto finish;
1515
1516 finish:
1517         _COREGL_TRACEPATH_FUNC_END();
1518 }
1519
1520 void
1521 tracepath_glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
1522 {
1523         _COREGL_TRACEPATH_FUNC_BEGIN();
1524         _orig_tracepath_glTexGenxOES(coord, pname, param);
1525
1526         goto finish;
1527
1528 finish:
1529         _COREGL_TRACEPATH_FUNC_END();
1530 }
1531
1532 void
1533 tracepath_glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
1534 {
1535         _COREGL_TRACEPATH_FUNC_BEGIN();
1536         _orig_tracepath_glTexGenxvOES(coord, pname, params);
1537
1538         goto finish;
1539
1540 finish:
1541         _COREGL_TRACEPATH_FUNC_END();
1542 }
1543
1544 void
1545 tracepath_glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
1546 {
1547         _COREGL_TRACEPATH_FUNC_BEGIN();
1548         _orig_tracepath_glGetTexGenfvOES(coord, pname, params);
1549
1550         goto finish;
1551
1552 finish:
1553         _COREGL_TRACEPATH_FUNC_END();
1554 }
1555
1556 void
1557 tracepath_glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
1558 {
1559         _COREGL_TRACEPATH_FUNC_BEGIN();
1560         _orig_tracepath_glGetTexGenivOES(coord, pname, params);
1561
1562         goto finish;
1563
1564 finish:
1565         _COREGL_TRACEPATH_FUNC_END();
1566 }
1567
1568 void
1569 tracepath_glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
1570 {
1571         _COREGL_TRACEPATH_FUNC_BEGIN();
1572         _orig_tracepath_glGetTexGenxvOES(coord, pname, params);
1573
1574         goto finish;
1575
1576 finish:
1577         _COREGL_TRACEPATH_FUNC_END();
1578 }
1579
1580 void
1581 tracepath_glClipPlanefIMG(GLenum plane, const GLfloat *equation)
1582 {
1583         _COREGL_TRACEPATH_FUNC_BEGIN();
1584         _orig_tracepath_glClipPlanefIMG(plane, equation);
1585
1586         goto finish;
1587
1588 finish:
1589         _COREGL_TRACEPATH_FUNC_END();
1590 }
1591
1592 void
1593 tracepath_glClipPlanexIMG(GLenum plane, const GLfixed *equation)
1594 {
1595         _COREGL_TRACEPATH_FUNC_BEGIN();
1596         _orig_tracepath_glClipPlanexIMG(plane, equation);
1597
1598         goto finish;
1599
1600 finish:
1601         _COREGL_TRACEPATH_FUNC_END();
1602 }
1603
1604 /* end of GLES 1.1 extensions */
1605
1606 /* common extensions in GLES1.1 and GLES2.0 */
1607 void
1608 tracepath_glRenderbufferStorageMultisampleAPPLE(GLenum target, GLsizei samples,
1609                 GLenum internalformat, GLsizei width, GLsizei height)
1610 {
1611         _COREGL_TRACEPATH_FUNC_BEGIN();
1612         _orig_tracepath_glRenderbufferStorageMultisampleAPPLE(target, samples,
1613                         internalformat, width, height);
1614
1615         goto finish;
1616
1617 finish:
1618         _COREGL_TRACEPATH_FUNC_END();
1619 }
1620
1621 void
1622 tracepath_glResolveMultisampleFramebufferAPPLE(void)
1623 {
1624         _COREGL_TRACEPATH_FUNC_BEGIN();
1625         _orig_tracepath_glResolveMultisampleFramebufferAPPLE();
1626
1627         goto finish;
1628
1629 finish:
1630         _COREGL_TRACEPATH_FUNC_END();
1631 }
1632
1633 void
1634 tracepath_glMultiDrawArraysEXT(GLenum mode, const GLint *first,
1635                                                            const GLsizei *count, GLsizei primcount)
1636 {
1637         _COREGL_TRACEPATH_FUNC_BEGIN();
1638         _orig_tracepath_glMultiDrawArraysEXT(mode, first, count, primcount);
1639
1640         goto finish;
1641
1642 finish:
1643         _COREGL_TRACEPATH_FUNC_END();
1644 }
1645
1646 void
1647 tracepath_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
1648                                                                  const void *const *indices, GLsizei primcount)
1649 {
1650         _COREGL_TRACEPATH_FUNC_BEGIN();
1651         _orig_tracepath_glMultiDrawElementsEXT(mode, count, type, indices, primcount);
1652
1653         goto finish;
1654
1655 finish:
1656         _COREGL_TRACEPATH_FUNC_END();
1657 }
1658
1659 void
1660 tracepath_glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples,
1661                 GLenum internalformat, GLsizei width, GLsizei height)
1662 {
1663         _COREGL_TRACEPATH_FUNC_BEGIN();
1664         _orig_tracepath_glRenderbufferStorageMultisampleIMG(target, samples,
1665                         internalformat, width, height);
1666
1667         goto finish;
1668
1669 finish:
1670         _COREGL_TRACEPATH_FUNC_END();
1671 }
1672
1673 void
1674 tracepath_glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment,
1675                 GLenum textarget, GLuint texture, GLint level, GLsizei samples)
1676 {
1677         _COREGL_TRACEPATH_FUNC_BEGIN();
1678         _orig_tracepath_glFramebufferTexture2DMultisampleIMG(target, attachment,
1679                         textarget, texture, level, samples);
1680
1681         goto finish;
1682
1683 finish:
1684         _COREGL_TRACEPATH_FUNC_END();
1685 }
1686 /* end of common extensions in GLES1.1 and GLES2.0 */
1687
1688 void
1689 tracepath_glActiveTexture(GLenum texture)
1690 {
1691         _COREGL_TRACEPATH_FUNC_BEGIN();
1692         _orig_tracepath_glActiveTexture(texture);
1693
1694         goto finish;
1695
1696 finish:
1697         _COREGL_TRACEPATH_FUNC_END();
1698 }
1699
1700 void
1701 tracepath_glAttachShader(GLuint program, GLuint shader)
1702 {
1703         _COREGL_TRACEPATH_FUNC_BEGIN();
1704         _orig_tracepath_glAttachShader(program, shader);
1705
1706         goto finish;
1707
1708 finish:
1709         _COREGL_TRACEPATH_FUNC_END();
1710 }
1711
1712 void
1713 tracepath_glBindAttribLocation(GLuint program, GLuint index, const char *name)
1714 {
1715         _COREGL_TRACEPATH_FUNC_BEGIN();
1716         _orig_tracepath_glBindAttribLocation(program, index, name);
1717
1718         goto finish;
1719
1720 finish:
1721         _COREGL_TRACEPATH_FUNC_END();
1722 }
1723
1724 void
1725 tracepath_glBindBuffer(GLenum target, GLuint buffer)
1726 {
1727         _COREGL_TRACEPATH_FUNC_BEGIN();
1728         _orig_tracepath_glBindBuffer(target, buffer);
1729
1730         goto finish;
1731
1732 finish:
1733         _COREGL_TRACEPATH_FUNC_END();
1734 }
1735
1736 static void
1737 _tp_glBindFramebuffer(GLenum target, GLuint framebuffer, TRACEPATH_FUNC_TYPE ftype)
1738 {
1739 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1740         if (unlikely(get_trace_surface_flag() == 1)) {
1741                 GLint oldfb;
1742                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb);
1743                 if (oldfb != 0) {
1744                         _COREGL_TRACE_SURFACE(0, 2, "GLBINDFBO");
1745                 }
1746
1747                 tracepath_fbdump_update(0);
1748         }
1749 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1750
1751         switch (ftype) {
1752         case TRACEPATH_FUNC_TYPE_STANDARD:
1753                 _orig_tracepath_glBindFramebuffer(target, framebuffer);
1754                 break;
1755         case TRACEPATH_FUNC_TYPE_OES:
1756                 _orig_tracepath_glBindFramebufferOES(target, framebuffer);
1757                 break;
1758         default:
1759                 goto finish;
1760         }
1761
1762 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1763         if (unlikely(get_trace_surface_flag() == 1)) {
1764                 tracepath_fbdump_update(1);
1765         }
1766 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1767
1768         goto finish;
1769
1770 finish:
1771         return;
1772 }
1773
1774 void
1775 tracepath_glBindFramebuffer(GLenum target, GLuint framebuffer)
1776 {
1777         _COREGL_TRACEPATH_FUNC_BEGIN();
1778
1779         _tp_glBindFramebuffer(target, framebuffer, TRACEPATH_FUNC_TYPE_STANDARD);
1780
1781         _COREGL_TRACEPATH_FUNC_END();
1782 }
1783
1784 void
1785 tracepath_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
1786 {
1787         _COREGL_TRACEPATH_FUNC_BEGIN();
1788         _orig_tracepath_glBindRenderbuffer(target, renderbuffer);
1789
1790         goto finish;
1791
1792 finish:
1793         _COREGL_TRACEPATH_FUNC_END();
1794 }
1795
1796 void
1797 tracepath_glBindTexture(GLenum target, GLuint texture)
1798 {
1799         _COREGL_TRACEPATH_FUNC_BEGIN();
1800
1801         _COREGL_TRACE_SURFACE(0, 1, "GLBINDTEXTURE");
1802         _orig_tracepath_glBindTexture(target, texture);
1803
1804         goto finish;
1805
1806 finish:
1807         _COREGL_TRACEPATH_FUNC_END();
1808 }
1809
1810 void
1811 tracepath_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
1812                                            GLclampf alpha)
1813 {
1814         _COREGL_TRACEPATH_FUNC_BEGIN();
1815         _orig_tracepath_glBlendColor(red, green, blue, alpha);
1816
1817         goto finish;
1818
1819 finish:
1820         _COREGL_TRACEPATH_FUNC_END();
1821 }
1822
1823 void
1824 tracepath_glBlendEquation(GLenum mode)
1825 {
1826         _COREGL_TRACEPATH_FUNC_BEGIN();
1827         _orig_tracepath_glBlendEquation(mode);
1828
1829         goto finish;
1830
1831 finish:
1832         _COREGL_TRACEPATH_FUNC_END();
1833 }
1834
1835 void
1836 tracepath_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
1837 {
1838         _COREGL_TRACEPATH_FUNC_BEGIN();
1839         _orig_tracepath_glBlendEquationSeparate(modeRGB, modeAlpha);
1840
1841         goto finish;
1842
1843 finish:
1844         _COREGL_TRACEPATH_FUNC_END();
1845 }
1846
1847 void
1848 tracepath_glBlendFunc(GLenum sfactor, GLenum dfactor)
1849 {
1850         _COREGL_TRACEPATH_FUNC_BEGIN();
1851         _orig_tracepath_glBlendFunc(sfactor, dfactor);
1852
1853         goto finish;
1854
1855 finish:
1856         _COREGL_TRACEPATH_FUNC_END();
1857 }
1858
1859 void
1860 tracepath_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
1861                                                           GLenum dstAlpha)
1862 {
1863         _COREGL_TRACEPATH_FUNC_BEGIN();
1864         _orig_tracepath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
1865
1866         goto finish;
1867
1868 finish:
1869         _COREGL_TRACEPATH_FUNC_END();
1870 }
1871
1872 void
1873 tracepath_glBufferData(GLenum target, GLsizeiptr size, const void *data,
1874                                            GLenum usage)
1875 {
1876         _COREGL_TRACEPATH_FUNC_BEGIN();
1877         _orig_tracepath_glBufferData(target, size, data, usage);
1878
1879         goto finish;
1880
1881 finish:
1882         _COREGL_TRACEPATH_FUNC_END();
1883 }
1884
1885 void
1886 tracepath_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
1887                                                   const void *data)
1888 {
1889         _COREGL_TRACEPATH_FUNC_BEGIN();
1890         _orig_tracepath_glBufferSubData(target, offset, size, data);
1891
1892         goto finish;
1893
1894 finish:
1895         _COREGL_TRACEPATH_FUNC_END();
1896 }
1897
1898 GLenum
1899 tracepath_glCheckFramebufferStatus(GLenum target)
1900 {
1901         GLenum ret = GL_NONE;
1902
1903         _COREGL_TRACEPATH_FUNC_BEGIN();
1904         ret = _orig_tracepath_glCheckFramebufferStatus(target);
1905
1906         goto finish;
1907
1908 finish:
1909         _COREGL_TRACEPATH_FUNC_END();
1910         return ret;
1911 }
1912
1913 void
1914 tracepath_glClear(GLbitfield mask)
1915 {
1916         _COREGL_TRACEPATH_FUNC_BEGIN();
1917         _orig_tracepath_glClear(mask);
1918
1919         goto finish;
1920
1921 finish:
1922         _COREGL_TRACEPATH_FUNC_END();
1923 }
1924
1925 void
1926 tracepath_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
1927                                            GLclampf alpha)
1928 {
1929         _COREGL_TRACEPATH_FUNC_BEGIN();
1930         _orig_tracepath_glClearColor(red, green, blue, alpha);
1931
1932         goto finish;
1933
1934 finish:
1935         _COREGL_TRACEPATH_FUNC_END();
1936 }
1937
1938 void
1939 tracepath_glClearDepthf(GLclampf depth)
1940 {
1941         _COREGL_TRACEPATH_FUNC_BEGIN();
1942         _orig_tracepath_glClearDepthf(depth);
1943
1944         goto finish;
1945
1946 finish:
1947         _COREGL_TRACEPATH_FUNC_END();
1948 }
1949
1950 void
1951 tracepath_glClearStencil(GLint s)
1952 {
1953         _COREGL_TRACEPATH_FUNC_BEGIN();
1954         _orig_tracepath_glClearStencil(s);
1955
1956         goto finish;
1957
1958 finish:
1959         _COREGL_TRACEPATH_FUNC_END();
1960 }
1961
1962 void
1963 tracepath_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
1964                                           GLboolean alpha)
1965 {
1966         _COREGL_TRACEPATH_FUNC_BEGIN();
1967         _orig_tracepath_glColorMask(red, green, blue, alpha);
1968
1969         goto finish;
1970
1971 finish:
1972         _COREGL_TRACEPATH_FUNC_END();
1973 }
1974
1975 void
1976 tracepath_glCompileShader(GLuint shader)
1977 {
1978         _COREGL_TRACEPATH_FUNC_BEGIN();
1979         _orig_tracepath_glCompileShader(shader);
1980
1981         goto finish;
1982
1983 finish:
1984         _COREGL_TRACEPATH_FUNC_END();
1985 }
1986
1987 void
1988 tracepath_glCompressedTexImage2D(GLenum target, GLint level,
1989                                                                  GLenum internalformat, GLsizei width, GLsizei height, GLint border,
1990                                                                  GLsizei imageSize, const void *data)
1991 {
1992         _COREGL_TRACEPATH_FUNC_BEGIN();
1993         _orig_tracepath_glCompressedTexImage2D(target, level, internalformat, width,
1994                                                                                    height, border, imageSize, data);
1995
1996         goto finish;
1997
1998 finish:
1999         _COREGL_TRACEPATH_FUNC_END();
2000 }
2001
2002 void
2003 tracepath_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
2004                                                                         GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
2005                                                                         const void *data)
2006 {
2007         _COREGL_TRACEPATH_FUNC_BEGIN();
2008         _orig_tracepath_glCompressedTexSubImage2D(target, level, xoffset, yoffset,
2009                         width, height, format, imageSize, data);
2010
2011         goto finish;
2012
2013 finish:
2014         _COREGL_TRACEPATH_FUNC_END();
2015 }
2016
2017 void
2018 tracepath_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
2019                                                    GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
2020 {
2021         _COREGL_TRACEPATH_FUNC_BEGIN();
2022         _orig_tracepath_glCopyTexImage2D(target, level, internalformat, x, y, width,
2023                                                                          height, border);
2024
2025         goto finish;
2026
2027 finish:
2028         _COREGL_TRACEPATH_FUNC_END();
2029 }
2030
2031 void
2032 tracepath_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
2033                                                           GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2034 {
2035         _COREGL_TRACEPATH_FUNC_BEGIN();
2036         _orig_tracepath_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y,
2037                                                                                 width, height);
2038
2039         goto finish;
2040
2041 finish:
2042         _COREGL_TRACEPATH_FUNC_END();
2043 }
2044
2045 GLuint
2046 tracepath_glCreateProgram(void)
2047 {
2048         GLuint ret = _COREGL_INT_INIT_VALUE;
2049
2050         _COREGL_TRACEPATH_FUNC_BEGIN();
2051         ret = _orig_tracepath_glCreateProgram();
2052
2053         goto finish;
2054
2055 finish:
2056         _COREGL_TRACEPATH_FUNC_END();
2057         return ret;
2058 }
2059
2060 GLuint
2061 tracepath_glCreateShader(GLenum type)
2062 {
2063         GLuint ret = _COREGL_INT_INIT_VALUE;
2064         _COREGL_TRACEPATH_FUNC_BEGIN();
2065         ret = _orig_tracepath_glCreateShader(type);
2066
2067         goto finish;
2068
2069 finish:
2070         _COREGL_TRACEPATH_FUNC_END();
2071         return ret;
2072 }
2073
2074 void
2075 tracepath_glCullFace(GLenum mode)
2076 {
2077         _COREGL_TRACEPATH_FUNC_BEGIN();
2078         _orig_tracepath_glCullFace(mode);
2079
2080         goto finish;
2081
2082 finish:
2083         _COREGL_TRACEPATH_FUNC_END();
2084 }
2085
2086 void
2087 tracepath_glDeleteBuffers(GLsizei n, const GLuint *buffers)
2088 {
2089         _COREGL_TRACEPATH_FUNC_BEGIN();
2090         _orig_tracepath_glDeleteBuffers(n, buffers);
2091
2092         goto finish;
2093
2094 finish:
2095         _COREGL_TRACEPATH_FUNC_END();
2096 }
2097
2098 void
2099 tracepath_glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
2100 {
2101         _COREGL_TRACEPATH_FUNC_BEGIN();
2102
2103 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2104         tracepath_fbdump_update(0);
2105 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2106
2107         _orig_tracepath_glDeleteFramebuffers(n, framebuffers);
2108
2109 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2110         tracepath_fbdump_update(1);
2111 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2112
2113         goto finish;
2114
2115 finish:
2116         _COREGL_TRACEPATH_FUNC_END();
2117 }
2118
2119 void
2120 tracepath_glDeleteProgram(GLuint program)
2121 {
2122         _COREGL_TRACEPATH_FUNC_BEGIN();
2123         _orig_tracepath_glDeleteProgram(program);
2124
2125         goto finish;
2126
2127 finish:
2128         _COREGL_TRACEPATH_FUNC_END();
2129 }
2130
2131 static void
2132 _tp_glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers, TRACEPATH_FUNC_TYPE ftype)
2133 {
2134 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2135         tracepath_fbdump_update(0);
2136 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2137
2138         switch (ftype) {
2139         case TRACEPATH_FUNC_TYPE_STANDARD:
2140                 _orig_tracepath_glDeleteRenderbuffers(n, renderbuffers);
2141                 break;
2142         case TRACEPATH_FUNC_TYPE_OES:
2143                 _orig_tracepath_glDeleteRenderbuffersOES(n, renderbuffers);
2144                 break;
2145         default:
2146                 goto finish;
2147         }
2148
2149 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2150         tracepath_fbdump_update(1);
2151 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2152
2153         goto finish;
2154
2155 finish:
2156 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2157         if (get_trace_mem_flag() == 1) {
2158                 MY_MODULE_TSTATE* tstate = _get_my_state();
2159                 if (tstate && tstate->ctx != NULL) {
2160                         for (int i = 0; i < n; i++) {
2161                                 if (renderbuffers[i] == 0) continue;
2162                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
2163                                                                          "Renderbuffer");
2164                         }
2165                 }
2166         }
2167 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2168 }
2169
2170 void
2171 tracepath_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
2172 {
2173         _COREGL_TRACEPATH_FUNC_BEGIN();
2174
2175         _tp_glDeleteRenderbuffers(n, renderbuffers, TRACEPATH_FUNC_TYPE_STANDARD);
2176
2177         _COREGL_TRACEPATH_FUNC_END();
2178 }
2179
2180 void
2181 tracepath_glDeleteShader(GLuint shader)
2182 {
2183         _COREGL_TRACEPATH_FUNC_BEGIN();
2184         _orig_tracepath_glDeleteShader(shader);
2185
2186         goto finish;
2187
2188 finish:
2189         _COREGL_TRACEPATH_FUNC_END();
2190 }
2191
2192 void
2193 tracepath_glDeleteTextures(GLsizei n, const GLuint *textures)
2194 {
2195         _COREGL_TRACEPATH_FUNC_BEGIN();
2196
2197 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2198         tracepath_fbdump_update(0);
2199 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2200
2201         _orig_tracepath_glDeleteTextures(n, textures);
2202
2203 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2204         tracepath_fbdump_update(1);
2205 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2206
2207         goto finish;
2208
2209 finish:
2210         _COREGL_TRACEPATH_FUNC_END();
2211 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2212         if (get_trace_mem_flag() == 1) {
2213                 MY_MODULE_TSTATE* tstate = _get_my_state();
2214                 if (tstate && tstate->ctx != NULL) {
2215                         for (int i = 0; i < n; i++) {
2216                                 if (textures[i] == 0) continue;
2217                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture");
2218                         }
2219                 }
2220         }
2221 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2222 }
2223
2224 void
2225 tracepath_glDepthFunc(GLenum func)
2226 {
2227         _COREGL_TRACEPATH_FUNC_BEGIN();
2228         _orig_tracepath_glDepthFunc(func);
2229
2230         goto finish;
2231
2232 finish:
2233         _COREGL_TRACEPATH_FUNC_END();
2234 }
2235
2236 void
2237 tracepath_glDepthMask(GLboolean flag)
2238 {
2239         _COREGL_TRACEPATH_FUNC_BEGIN();
2240         _orig_tracepath_glDepthMask(flag);
2241
2242         goto finish;
2243
2244 finish:
2245         _COREGL_TRACEPATH_FUNC_END();
2246 }
2247
2248 void
2249 tracepath_glDepthRangef(GLclampf zNear, GLclampf zFar)
2250 {
2251         _COREGL_TRACEPATH_FUNC_BEGIN();
2252         _orig_tracepath_glDepthRangef(zNear, zFar);
2253
2254         goto finish;
2255
2256 finish:
2257         _COREGL_TRACEPATH_FUNC_END();
2258 }
2259
2260 void
2261 tracepath_glDetachShader(GLuint program, GLuint shader)
2262 {
2263         _COREGL_TRACEPATH_FUNC_BEGIN();
2264         _orig_tracepath_glDetachShader(program, shader);
2265
2266         goto finish;
2267
2268 finish:
2269         _COREGL_TRACEPATH_FUNC_END();
2270 }
2271
2272 void
2273 tracepath_glDisable(GLenum cap)
2274 {
2275         _COREGL_TRACEPATH_FUNC_BEGIN();
2276         _orig_tracepath_glDisable(cap);
2277
2278         goto finish;
2279
2280 finish:
2281         _COREGL_TRACEPATH_FUNC_END();
2282 }
2283
2284 void
2285 tracepath_glDisableVertexAttribArray(GLuint index)
2286 {
2287         _COREGL_TRACEPATH_FUNC_BEGIN();
2288         _orig_tracepath_glDisableVertexAttribArray(index);
2289
2290         goto finish;
2291
2292 finish:
2293         _COREGL_TRACEPATH_FUNC_END();
2294 }
2295
2296 void
2297 tracepath_glDrawArrays(GLenum mode, GLint first, GLsizei count)
2298 {
2299         _COREGL_TRACEPATH_FUNC_BEGIN();
2300         _orig_tracepath_glDrawArrays(mode, first, count);
2301
2302         goto finish;
2303
2304 finish:
2305         _COREGL_TRACEPATH_FUNC_END();
2306 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2307         if (get_trace_surface_flag() == 1) {
2308                 GLint fbname = _COREGL_INT_INIT_VALUE;
2309                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
2310                 AST(fbname != _COREGL_INT_INIT_VALUE);
2311                 if (fbname == 0) {
2312                         char name[256];
2313                         EGLint btype;
2314                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(),
2315                                                                                         _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
2316                         if (btype == EGL_SINGLE_BUFFER)
2317                                 snprintf(name, sizeof(name), "EGLPIXMAP_%p",
2318                                                  _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
2319                         else
2320                                 snprintf(name, sizeof(name), "EGLWINDOW_%p",
2321                                                  _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
2322                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(),
2323                                                                                 _orig_tracepath_eglGetCurrentContext(),
2324                                                                                 _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
2325                 }
2326         }
2327 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2328 }
2329
2330 void
2331 tracepath_glDrawElements(GLenum mode, GLsizei count, GLenum type,
2332                                                  const void *indices)
2333 {
2334         _COREGL_TRACEPATH_FUNC_BEGIN();
2335         _orig_tracepath_glDrawElements(mode, count, type, indices);
2336
2337         goto finish;
2338
2339 finish:
2340         _COREGL_TRACEPATH_FUNC_END();
2341 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2342         if (get_trace_surface_flag() == 1) {
2343                 GLint fbname = _COREGL_INT_INIT_VALUE;
2344                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
2345                 AST(fbname != _COREGL_INT_INIT_VALUE);
2346                 if (fbname == 0) {
2347                         char name[256];
2348                         EGLint btype;
2349                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(),
2350                                                                                         _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
2351                         if (btype == EGL_SINGLE_BUFFER)
2352                                 snprintf(name, sizeof(name), "EGLPIXMAP_%p",
2353                                                  _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
2354                         else
2355                                 snprintf(name, sizeof(name), "EGLWINDOW_%p",
2356                                                  _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
2357                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(),
2358                                                                                 _orig_tracepath_eglGetCurrentContext(),
2359                                                                                 _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
2360                 }
2361         }
2362 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2363 }
2364
2365 void
2366 tracepath_glEnable(GLenum cap)
2367 {
2368         _COREGL_TRACEPATH_FUNC_BEGIN();
2369         _orig_tracepath_glEnable(cap);
2370
2371         goto finish;
2372
2373 finish:
2374         _COREGL_TRACEPATH_FUNC_END();
2375 }
2376
2377 void
2378 tracepath_glEnableVertexAttribArray(GLuint index)
2379 {
2380         _COREGL_TRACEPATH_FUNC_BEGIN();
2381         _orig_tracepath_glEnableVertexAttribArray(index);
2382
2383         goto finish;
2384
2385 finish:
2386         _COREGL_TRACEPATH_FUNC_END();
2387 }
2388
2389 void
2390 tracepath_glFinish(void)
2391 {
2392         _COREGL_TRACEPATH_FUNC_BEGIN();
2393         _orig_tracepath_glFinish();
2394
2395         _COREGL_TRACE_SURFACE(0, 0, "GLFINISH");
2396
2397         goto finish;
2398
2399 finish:
2400         _COREGL_TRACEPATH_FUNC_END();
2401         _COREGL_TRACE_API_OUTPUT(0);
2402         _COREGL_TRACE_MEM_OUTPUT(0);
2403 }
2404
2405 void
2406 tracepath_glFlush(void)
2407 {
2408         _COREGL_TRACEPATH_FUNC_BEGIN();
2409         _orig_tracepath_glFlush();
2410
2411         _COREGL_TRACE_SURFACE(0, 0, "GLFLUSH");
2412
2413         goto finish;
2414
2415 finish:
2416         _COREGL_TRACEPATH_FUNC_END();
2417         _COREGL_TRACE_API_OUTPUT(0);
2418         _COREGL_TRACE_MEM_OUTPUT(0);
2419 }
2420
2421 void
2422 tracepath_glFramebufferRenderbuffer(GLenum target, GLenum attachment,
2423                                                                         GLenum renderbuffertarget, GLuint renderbuffer)
2424 {
2425         _COREGL_TRACEPATH_FUNC_BEGIN();
2426
2427 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2428         tracepath_fbdump_update(0);
2429 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2430
2431         _orig_tracepath_glFramebufferRenderbuffer(target, attachment,
2432                         renderbuffertarget, renderbuffer);
2433
2434 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2435         tracepath_fbdump_update(1);
2436 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2437
2438         goto finish;
2439
2440 finish:
2441         _COREGL_TRACEPATH_FUNC_END();
2442 }
2443
2444 void
2445 tracepath_glFramebufferTexture2D(GLenum target, GLenum attachment,
2446                                                                  GLenum textarget, GLuint texture, GLint level)
2447 {
2448         _COREGL_TRACEPATH_FUNC_BEGIN();
2449
2450 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2451         tracepath_fbdump_update(0);
2452 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2453
2454         _orig_tracepath_glFramebufferTexture2D(target, attachment, textarget, texture,
2455                                                                                    level);
2456
2457 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2458         tracepath_fbdump_update(1);
2459 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2460
2461         goto finish;
2462
2463 finish:
2464         _COREGL_TRACEPATH_FUNC_END();
2465 }
2466
2467 void
2468 tracepath_glFrontFace(GLenum mode)
2469 {
2470         _COREGL_TRACEPATH_FUNC_BEGIN();
2471         _orig_tracepath_glFrontFace(mode);
2472
2473         goto finish;
2474
2475 finish:
2476         _COREGL_TRACEPATH_FUNC_END();
2477 }
2478
2479 void
2480 tracepath_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
2481 {
2482         _COREGL_TRACEPATH_FUNC_BEGIN();
2483         _orig_tracepath_glGetVertexAttribfv(index, pname, params);
2484
2485
2486         goto finish;
2487
2488 finish:
2489         _COREGL_TRACEPATH_FUNC_END();
2490 }
2491
2492 void
2493 tracepath_glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
2494 {
2495         _COREGL_TRACEPATH_FUNC_BEGIN();
2496         _orig_tracepath_glGetVertexAttribiv(index, pname, params);
2497
2498
2499         goto finish;
2500
2501 finish:
2502         _COREGL_TRACEPATH_FUNC_END();
2503 }
2504
2505 void
2506 tracepath_glTexBufferOES(GLenum target, GLenum internalformat, GLuint buffer)
2507 {
2508         _COREGL_TRACEPATH_FUNC_BEGIN();
2509         _orig_tracepath_glTexBufferOES(target, internalformat, buffer);
2510
2511         goto finish;
2512
2513 finish:
2514         _COREGL_TRACEPATH_FUNC_END();
2515 }
2516
2517 void
2518 tracepath_glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
2519 {
2520         _COREGL_TRACEPATH_FUNC_BEGIN();
2521         _orig_tracepath_glGetVertexAttribPointerv(index, pname, pointer);
2522
2523
2524
2525         goto finish;
2526
2527 finish:
2528         _COREGL_TRACEPATH_FUNC_END();
2529 }
2530
2531 void
2532 tracepath_glHint(GLenum target, GLenum mode)
2533 {
2534         _COREGL_TRACEPATH_FUNC_BEGIN();
2535         _orig_tracepath_glHint(target, mode);
2536
2537         goto finish;
2538
2539 finish:
2540         _COREGL_TRACEPATH_FUNC_END();
2541 }
2542
2543 void
2544 tracepath_glGenBuffers(GLsizei n, GLuint *buffers)
2545 {
2546         _COREGL_TRACEPATH_FUNC_BEGIN();
2547         _orig_tracepath_glGenBuffers(n, buffers);
2548
2549         goto finish;
2550
2551 finish:
2552         _COREGL_TRACEPATH_FUNC_END();
2553 }
2554
2555 void
2556 tracepath_glGenerateMipmap(GLenum target)
2557 {
2558         _COREGL_TRACEPATH_FUNC_BEGIN();
2559         _orig_tracepath_glGenerateMipmap(target);
2560
2561         goto finish;
2562
2563 finish:
2564         _COREGL_TRACEPATH_FUNC_END();
2565 }
2566
2567 void
2568 tracepath_glGenFramebuffers(GLsizei n, GLuint *framebuffers)
2569 {
2570         _COREGL_TRACEPATH_FUNC_BEGIN();
2571         _orig_tracepath_glGenFramebuffers(n, framebuffers);
2572
2573         goto finish;
2574
2575 finish:
2576         _COREGL_TRACEPATH_FUNC_END();
2577 }
2578
2579 static void
2580 _tp_glGenRenderbuffers(GLsizei n, GLuint *renderbuffers, TRACEPATH_FUNC_TYPE ftype)
2581 {
2582         switch (ftype) {
2583         case TRACEPATH_FUNC_TYPE_STANDARD:
2584                 _orig_tracepath_glGenRenderbuffers(n, renderbuffers);
2585                 break;
2586         case TRACEPATH_FUNC_TYPE_OES:
2587                 _orig_tracepath_glGenRenderbuffersOES(n, renderbuffers);
2588                 break;
2589         }
2590
2591         goto finish;
2592
2593 finish:
2594 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2595         if (get_trace_mem_flag() == 1) {
2596                 MY_MODULE_TSTATE* tstate = _get_my_state();
2597                 if (tstate && tstate->ctx != NULL) {
2598                         for (int i = 0; i < n; i++) {
2599                                 if (renderbuffers[i] == 0) continue;
2600                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
2601                                                                   "Renderbuffer", 0, 0, 0, "Unknown");
2602                         }
2603                 }
2604         }
2605 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2606 }
2607
2608 void
2609 tracepath_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
2610 {
2611         _COREGL_TRACEPATH_FUNC_BEGIN();
2612
2613         _tp_glGenRenderbuffers(n, renderbuffers, TRACEPATH_FUNC_TYPE_STANDARD);
2614
2615         _COREGL_TRACEPATH_FUNC_END();
2616 }
2617
2618 void
2619 tracepath_glGenTextures(GLsizei n, GLuint *textures)
2620 {
2621         _COREGL_TRACEPATH_FUNC_BEGIN();
2622         _orig_tracepath_glGenTextures(n, textures);
2623
2624         goto finish;
2625
2626 finish:
2627         _COREGL_TRACEPATH_FUNC_END();
2628 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2629         if (get_trace_mem_flag() == 1) {
2630                 MY_MODULE_TSTATE* tstate = _get_my_state();
2631                 if (tstate && tstate->ctx != NULL) {
2632                         for (int i = 0; i < n; i++) {
2633                                 if (textures[i] == 0) continue;
2634                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture", 0, 0,
2635                                                                   0, "Unknown");
2636                         }
2637                 }
2638         }
2639 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2640 }
2641
2642 void
2643 tracepath_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
2644                                                         GLsizei *length, GLint *size, GLenum *type, char *name)
2645 {
2646         _COREGL_TRACEPATH_FUNC_BEGIN();
2647         _orig_tracepath_glGetActiveAttrib(program, index, bufsize, length, size, type,
2648                                                                           name);
2649
2650         goto finish;
2651
2652 finish:
2653         _COREGL_TRACEPATH_FUNC_END();
2654 }
2655
2656 void
2657 tracepath_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
2658                                                          GLsizei *length, GLint *size, GLenum *type, char *name)
2659 {
2660         _COREGL_TRACEPATH_FUNC_BEGIN();
2661         _orig_tracepath_glGetActiveUniform(program, index, bufsize, length, size, type,
2662                                                                            name);
2663
2664         goto finish;
2665
2666 finish:
2667         _COREGL_TRACEPATH_FUNC_END();
2668 }
2669
2670 void
2671 tracepath_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count,
2672                                                            GLuint *shaders)
2673 {
2674         _COREGL_TRACEPATH_FUNC_BEGIN();
2675         _orig_tracepath_glGetAttachedShaders(program, maxcount, count, shaders);
2676
2677         goto finish;
2678
2679 finish:
2680         _COREGL_TRACEPATH_FUNC_END();
2681 }
2682
2683 int
2684 tracepath_glGetAttribLocation(GLuint program, const char *name)
2685 {
2686         int ret = _COREGL_INT_INIT_VALUE;
2687         _COREGL_TRACEPATH_FUNC_BEGIN();
2688         ret = _orig_tracepath_glGetAttribLocation(program, name);
2689
2690         goto finish;
2691
2692 finish:
2693         _COREGL_TRACEPATH_FUNC_END();
2694         return ret;
2695 }
2696
2697 void
2698 tracepath_glGetBooleanv(GLenum pname, GLboolean *params)
2699 {
2700         _COREGL_TRACEPATH_FUNC_BEGIN();
2701         _orig_tracepath_glGetBooleanv(pname, params);
2702
2703         goto finish;
2704
2705 finish:
2706         _COREGL_TRACEPATH_FUNC_END();
2707 }
2708
2709 void
2710 tracepath_glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
2711 {
2712         _COREGL_TRACEPATH_FUNC_BEGIN();
2713         _orig_tracepath_glGetBufferParameteriv(target, pname, params);
2714
2715         goto finish;
2716
2717 finish:
2718         _COREGL_TRACEPATH_FUNC_END();
2719 }
2720
2721 GLenum
2722 tracepath_glGetError(void)
2723 {
2724         GLenum ret = GL_NONE;
2725
2726         _COREGL_TRACEPATH_FUNC_BEGIN();
2727         ret = _orig_tracepath_glGetError();
2728         goto finish;
2729
2730 finish:
2731         _COREGL_TRACEPATH_FUNC_END();
2732         return ret;
2733 }
2734
2735 void
2736 tracepath_glGetFloatv(GLenum pname, GLfloat *params)
2737 {
2738         _COREGL_TRACEPATH_FUNC_BEGIN();
2739         _orig_tracepath_glGetFloatv(pname, params);
2740
2741         goto finish;
2742
2743 finish:
2744         _COREGL_TRACEPATH_FUNC_END();
2745 }
2746
2747 void
2748 tracepath_glGetFramebufferAttachmentParameteriv(GLenum target,
2749                 GLenum attachment, GLenum pname, GLint *params)
2750 {
2751         _COREGL_TRACEPATH_FUNC_BEGIN();
2752         _orig_tracepath_glGetFramebufferAttachmentParameteriv(target, attachment, pname,
2753                         params);
2754
2755         goto finish;
2756
2757 finish:
2758         _COREGL_TRACEPATH_FUNC_END();
2759 }
2760
2761 void
2762 tracepath_glGetIntegerv(GLenum pname, GLint *params)
2763 {
2764         _COREGL_TRACEPATH_FUNC_BEGIN();
2765         _orig_tracepath_glGetIntegerv(pname, params);
2766
2767         goto finish;
2768
2769 finish:
2770         _COREGL_TRACEPATH_FUNC_END();
2771 }
2772
2773 void
2774 tracepath_glGetProgramiv(GLuint program, GLenum pname, GLint *params)
2775 {
2776         _COREGL_TRACEPATH_FUNC_BEGIN();
2777         _orig_tracepath_glGetProgramiv(program, pname, params);
2778
2779         goto finish;
2780
2781 finish:
2782         _COREGL_TRACEPATH_FUNC_END();
2783 }
2784
2785 void
2786 tracepath_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
2787                                                           char *infolog)
2788 {
2789         _COREGL_TRACEPATH_FUNC_BEGIN();
2790         _orig_tracepath_glGetProgramInfoLog(program, bufsize, length, infolog);
2791
2792         goto finish;
2793
2794 finish:
2795         _COREGL_TRACEPATH_FUNC_END();
2796 }
2797
2798 void
2799 tracepath_glGetRenderbufferParameteriv(GLenum target, GLenum pname,
2800                                                                            GLint *params)
2801 {
2802         _COREGL_TRACEPATH_FUNC_BEGIN();
2803         _orig_tracepath_glGetRenderbufferParameteriv(target, pname, params);
2804
2805         goto finish;
2806
2807 finish:
2808         _COREGL_TRACEPATH_FUNC_END();
2809 }
2810
2811 void
2812 tracepath_glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
2813 {
2814         _COREGL_TRACEPATH_FUNC_BEGIN();
2815         _orig_tracepath_glGetShaderiv(shader, pname, params);
2816
2817         goto finish;
2818
2819 finish:
2820         _COREGL_TRACEPATH_FUNC_END();
2821 }
2822
2823 void
2824 tracepath_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
2825                                                          char *infolog)
2826 {
2827         _COREGL_TRACEPATH_FUNC_BEGIN();
2828         _orig_tracepath_glGetShaderInfoLog(shader, bufsize, length, infolog);
2829
2830         goto finish;
2831
2832 finish:
2833         _COREGL_TRACEPATH_FUNC_END();
2834 }
2835
2836 void
2837 tracepath_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
2838                                                                          GLint *range, GLint *precision)
2839 {
2840         _COREGL_TRACEPATH_FUNC_BEGIN();
2841         _orig_tracepath_glGetShaderPrecisionFormat(shadertype, precisiontype, range,
2842                         precision);
2843
2844         goto finish;
2845
2846 finish:
2847         _COREGL_TRACEPATH_FUNC_END();
2848 }
2849
2850 void
2851 tracepath_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length,
2852                                                         char *source)
2853 {
2854         _COREGL_TRACEPATH_FUNC_BEGIN();
2855         _orig_tracepath_glGetShaderSource(shader, bufsize, length, source);
2856
2857         goto finish;
2858
2859 finish:
2860         _COREGL_TRACEPATH_FUNC_END();
2861 }
2862
2863 const GLubyte *
2864 tracepath_glGetString(GLenum name)
2865 {
2866         const GLubyte *ret = NULL;
2867
2868         _COREGL_TRACEPATH_FUNC_BEGIN();
2869         ret = _orig_tracepath_glGetString(name);
2870
2871         goto finish;
2872
2873 finish:
2874         _COREGL_TRACEPATH_FUNC_END();
2875         return ret;
2876 }
2877
2878 void
2879 tracepath_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
2880 {
2881         _COREGL_TRACEPATH_FUNC_BEGIN();
2882         _orig_tracepath_glGetTexParameterfv(target, pname, params);
2883
2884         goto finish;
2885
2886 finish:
2887         _COREGL_TRACEPATH_FUNC_END();
2888 }
2889
2890 void
2891 tracepath_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
2892 {
2893         _COREGL_TRACEPATH_FUNC_BEGIN();
2894         _orig_tracepath_glGetTexParameteriv(target, pname, params);
2895
2896         goto finish;
2897
2898 finish:
2899         _COREGL_TRACEPATH_FUNC_END();
2900 }
2901
2902 void
2903 tracepath_glGetUniformfv(GLuint program, GLint location, GLfloat *params)
2904 {
2905         _COREGL_TRACEPATH_FUNC_BEGIN();
2906         _orig_tracepath_glGetUniformfv(program, location, params);
2907
2908         goto finish;
2909
2910 finish:
2911         _COREGL_TRACEPATH_FUNC_END();
2912 }
2913
2914 void
2915 tracepath_glGetUniformiv(GLuint program, GLint location, GLint *params)
2916 {
2917         _COREGL_TRACEPATH_FUNC_BEGIN();
2918         _orig_tracepath_glGetUniformiv(program, location, params);
2919
2920         goto finish;
2921
2922 finish:
2923         _COREGL_TRACEPATH_FUNC_END();
2924 }
2925 int
2926 tracepath_glGetUniformLocation(GLuint program, const char *name)
2927 {
2928         int ret = _COREGL_INT_INIT_VALUE;
2929
2930         _COREGL_TRACEPATH_FUNC_BEGIN();
2931         ret = _orig_tracepath_glGetUniformLocation(program, name);
2932
2933         goto finish;
2934
2935 finish:
2936         _COREGL_TRACEPATH_FUNC_END();
2937         return ret;
2938 }
2939
2940 GLboolean
2941 tracepath_glIsBuffer(GLuint buffer)
2942 {
2943         GLboolean ret = GL_FALSE;
2944
2945         _COREGL_TRACEPATH_FUNC_BEGIN();
2946         ret = _orig_tracepath_glIsBuffer(buffer);
2947
2948         goto finish;
2949
2950 finish:
2951         _COREGL_TRACEPATH_FUNC_END();
2952         return ret;
2953 }
2954
2955 GLboolean
2956 tracepath_glIsEnabled(GLenum cap)
2957 {
2958         GLboolean ret = GL_FALSE;
2959
2960         _COREGL_TRACEPATH_FUNC_BEGIN();
2961         ret = _orig_tracepath_glIsEnabled(cap);
2962
2963         goto finish;
2964
2965 finish:
2966         _COREGL_TRACEPATH_FUNC_END();
2967         return ret;
2968 }
2969
2970 GLboolean
2971 tracepath_glIsFramebuffer(GLuint framebuffer)
2972 {
2973         GLboolean ret = GL_FALSE;
2974
2975         _COREGL_TRACEPATH_FUNC_BEGIN();
2976         ret = _orig_tracepath_glIsFramebuffer(framebuffer);
2977
2978         goto finish;
2979
2980 finish:
2981         _COREGL_TRACEPATH_FUNC_END();
2982         return ret;
2983 }
2984
2985 GLboolean
2986 tracepath_glIsProgram(GLuint program)
2987 {
2988         GLboolean ret;
2989         _COREGL_TRACEPATH_FUNC_BEGIN();
2990         ret = _orig_tracepath_glIsProgram(program);
2991
2992         goto finish;
2993
2994 finish:
2995         _COREGL_TRACEPATH_FUNC_END();
2996         return ret;
2997 }
2998
2999 GLboolean
3000 tracepath_glIsRenderbuffer(GLuint renderbuffer)
3001 {
3002         GLboolean ret;
3003         _COREGL_TRACEPATH_FUNC_BEGIN();
3004         ret = _orig_tracepath_glIsRenderbuffer(renderbuffer);
3005
3006         goto finish;
3007
3008 finish:
3009         _COREGL_TRACEPATH_FUNC_END();
3010         return ret;
3011 }
3012
3013 GLboolean
3014 tracepath_glIsShader(GLuint shader)
3015 {
3016         GLboolean ret;
3017         _COREGL_TRACEPATH_FUNC_BEGIN();
3018         ret = _orig_tracepath_glIsShader(shader);
3019
3020         goto finish;
3021
3022 finish:
3023         _COREGL_TRACEPATH_FUNC_END();
3024         return ret;
3025 }
3026
3027 GLboolean
3028 tracepath_glIsTexture(GLuint texture)
3029 {
3030         GLboolean ret;
3031         _COREGL_TRACEPATH_FUNC_BEGIN();
3032         ret = _orig_tracepath_glIsTexture(texture);
3033
3034         goto finish;
3035
3036 finish:
3037         _COREGL_TRACEPATH_FUNC_END();
3038         return ret;
3039 }
3040
3041 void
3042 tracepath_glLineWidth(GLfloat width)
3043 {
3044         _COREGL_TRACEPATH_FUNC_BEGIN();
3045         _orig_tracepath_glLineWidth(width);
3046
3047         goto finish;
3048
3049 finish:
3050         _COREGL_TRACEPATH_FUNC_END();
3051 }
3052
3053 void
3054 tracepath_glLinkProgram(GLuint program)
3055 {
3056         _COREGL_TRACEPATH_FUNC_BEGIN();
3057         _orig_tracepath_glLinkProgram(program);
3058
3059         goto finish;
3060
3061 finish:
3062         _COREGL_TRACEPATH_FUNC_END();
3063 }
3064
3065 void
3066 tracepath_glPixelStorei(GLenum pname, GLint param)
3067 {
3068         _COREGL_TRACEPATH_FUNC_BEGIN();
3069         _orig_tracepath_glPixelStorei(pname, param);
3070
3071         goto finish;
3072
3073 finish:
3074         _COREGL_TRACEPATH_FUNC_END();
3075 }
3076
3077 void
3078 tracepath_glPolygonOffset(GLfloat factor, GLfloat units)
3079 {
3080         _COREGL_TRACEPATH_FUNC_BEGIN();
3081         _orig_tracepath_glPolygonOffset(factor, units);
3082
3083         goto finish;
3084
3085 finish:
3086         _COREGL_TRACEPATH_FUNC_END();
3087 }
3088
3089 void
3090 tracepath_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3091                                            GLenum format, GLenum type, void *pixels)
3092 {
3093         _COREGL_TRACEPATH_FUNC_BEGIN();
3094         _orig_tracepath_glReadPixels(x, y, width, height, format, type, pixels);
3095
3096         goto finish;
3097
3098 finish:
3099         _COREGL_TRACEPATH_FUNC_END();
3100 }
3101
3102 void
3103 tracepath_glReleaseShaderCompiler(void)
3104 {
3105         _COREGL_TRACEPATH_FUNC_BEGIN();
3106         _orig_tracepath_glReleaseShaderCompiler();
3107
3108         goto finish;
3109
3110 finish:
3111         _COREGL_TRACEPATH_FUNC_END();
3112 }
3113
3114 void
3115 tracepath_glRenderbufferStorage(GLenum target, GLenum internalformat,
3116                                                                 GLsizei width, GLsizei height)
3117 {
3118         _COREGL_TRACEPATH_FUNC_BEGIN();
3119
3120         _orig_tracepath_glRenderbufferStorage(target, internalformat, width, height);
3121
3122         goto finish;
3123
3124 finish:
3125         _COREGL_TRACEPATH_FUNC_END();
3126 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3127         if (get_trace_mem_flag() == 1) {
3128                 MY_MODULE_TSTATE* tstate = _get_my_state();
3129                 if (tstate && tstate->ctx != NULL) {
3130                         struct _Glbuf_Data data = _get_glbuf_data(GL_RENDERBUFFER_BINDING, internalformat);
3131                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, data.obj_idx, "Renderbuffer", width,
3132                                                           height, data.bpp, data.format);
3133                 }
3134         }
3135 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3136 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
3137         if (get_trace_surface_flag() == 1) {
3138                 MY_MODULE_TSTATE* tstate = _get_my_state();
3139                 if (tstate && tstate->ctx != NULL) {
3140                         int objidx = _COREGL_INT_INIT_VALUE;
3141                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
3142                         AST(objidx != _COREGL_INT_INIT_VALUE);
3143
3144                         {
3145                                 int channel = _get_channel_by_format(internalformat);
3146                                 char name[256];
3147                                 snprintf(name, sizeof(name), "FBORB_%d", objidx);
3148                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
3149                                                                                         tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
3150                         }
3151                 }
3152         }
3153 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
3154 }
3155
3156 void
3157 tracepath_glSampleCoverage(GLclampf value, GLboolean invert)
3158 {
3159         _COREGL_TRACEPATH_FUNC_BEGIN();
3160         _orig_tracepath_glSampleCoverage(value, invert);
3161
3162         goto finish;
3163
3164 finish:
3165         _COREGL_TRACEPATH_FUNC_END();
3166 }
3167
3168 void
3169 tracepath_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
3170 {
3171         _COREGL_TRACEPATH_FUNC_BEGIN();
3172         _orig_tracepath_glScissor(x, y, width, height);
3173
3174         goto finish;
3175
3176 finish:
3177         _COREGL_TRACEPATH_FUNC_END();
3178 }
3179
3180 void
3181 tracepath_glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
3182                                                  const void *binary, GLsizei length)
3183 {
3184         _COREGL_TRACEPATH_FUNC_BEGIN();
3185         _orig_tracepath_glShaderBinary(n, shaders, binaryformat, binary, length);
3186
3187         goto finish;
3188
3189 finish:
3190         _COREGL_TRACEPATH_FUNC_END();
3191 }
3192
3193 void
3194 tracepath_glShaderSource(GLuint shader, GLsizei count, const char **string,
3195                                                  const GLint *length)
3196 {
3197         _COREGL_TRACEPATH_FUNC_BEGIN();
3198         _orig_tracepath_glShaderSource(shader, count, string, length);
3199
3200         goto finish;
3201
3202 finish:
3203         _COREGL_TRACEPATH_FUNC_END();
3204 }
3205
3206 void
3207 tracepath_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3208 {
3209         _COREGL_TRACEPATH_FUNC_BEGIN();
3210         _orig_tracepath_glStencilFunc(func, ref, mask);
3211
3212         goto finish;
3213
3214 finish:
3215         _COREGL_TRACEPATH_FUNC_END();
3216 }
3217
3218 void
3219 tracepath_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
3220                                                                 GLuint mask)
3221 {
3222         _COREGL_TRACEPATH_FUNC_BEGIN();
3223         _orig_tracepath_glStencilFuncSeparate(face, func, ref, mask);
3224
3225         goto finish;
3226
3227 finish:
3228         _COREGL_TRACEPATH_FUNC_END();
3229 }
3230
3231 void
3232 tracepath_glStencilMask(GLuint mask)
3233 {
3234         _COREGL_TRACEPATH_FUNC_BEGIN();
3235         _orig_tracepath_glStencilMask(mask);
3236
3237         goto finish;
3238
3239 finish:
3240         _COREGL_TRACEPATH_FUNC_END();
3241 }
3242
3243 void
3244 tracepath_glStencilMaskSeparate(GLenum face, GLuint mask)
3245 {
3246         _COREGL_TRACEPATH_FUNC_BEGIN();
3247         _orig_tracepath_glStencilMaskSeparate(face, mask);
3248
3249         goto finish;
3250
3251 finish:
3252         _COREGL_TRACEPATH_FUNC_END();
3253 }
3254
3255 void
3256 tracepath_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3257 {
3258         _COREGL_TRACEPATH_FUNC_BEGIN();
3259         _orig_tracepath_glStencilOp(fail, zfail, zpass);
3260
3261         goto finish;
3262
3263 finish:
3264         _COREGL_TRACEPATH_FUNC_END();
3265 }
3266
3267 void
3268 tracepath_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
3269                                                           GLenum zpass)
3270 {
3271         _COREGL_TRACEPATH_FUNC_BEGIN();
3272         _orig_tracepath_glStencilOpSeparate(face, fail, zfail, zpass);
3273
3274         goto finish;
3275
3276 finish:
3277         _COREGL_TRACEPATH_FUNC_END();
3278 }
3279
3280 void
3281 tracepath_glTexImage2D(GLenum target, GLint level, GLint internalformat,
3282                                            GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
3283                                            const void *pixels)
3284 {
3285         _COREGL_TRACEPATH_FUNC_BEGIN();
3286         _orig_tracepath_glTexImage2D(target, level, internalformat, width, height,
3287                                                                  border, format, type, pixels);
3288
3289         goto finish;
3290
3291 finish:
3292         _COREGL_TRACEPATH_FUNC_END();
3293 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3294         if (get_trace_mem_flag() == 1) {
3295                 MY_MODULE_TSTATE* tstate = _get_my_state();
3296                 if (tstate && tstate->ctx != NULL) {
3297                         struct _Glbuf_Data data = _get_glbuf_data(GL_TEXTURE_BINDING_2D, internalformat);
3298                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, data.obj_idx, "Texture", width,
3299                                                           height, data.bpp, data.format);
3300                 }
3301         }
3302 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3303 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
3304         if (get_trace_surface_flag() == 1) {
3305                 MY_MODULE_TSTATE* tstate = _get_my_state();
3306                 if (tstate && tstate->ctx != NULL) {
3307                         int objidx = _COREGL_INT_INIT_VALUE;
3308                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
3309                         AST(objidx != _COREGL_INT_INIT_VALUE);
3310
3311                         {
3312                                 int channel = _get_channel_by_format(internalformat);
3313                                 char name[256];
3314                                 snprintf(name, sizeof(name), "FBOTEX_0x%X", objidx);
3315                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
3316                                                                                         tstate->surf_draw, -1, objidx, 0, width, height, channel, NULL);
3317                         }
3318                 }
3319         }
3320 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
3321 }
3322
3323 void
3324 tracepath_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
3325 {
3326         _COREGL_TRACEPATH_FUNC_BEGIN();
3327         _orig_tracepath_glTexParameterf(target, pname, param);
3328
3329         goto finish;
3330
3331 finish:
3332         _COREGL_TRACEPATH_FUNC_END();
3333 }
3334
3335 void
3336 tracepath_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
3337 {
3338         _COREGL_TRACEPATH_FUNC_BEGIN();
3339         _orig_tracepath_glTexParameterfv(target, pname, params);
3340
3341         goto finish;
3342
3343 finish:
3344         _COREGL_TRACEPATH_FUNC_END();
3345 }
3346
3347 void
3348 tracepath_glTexParameteri(GLenum target, GLenum pname, GLint param)
3349 {
3350         _COREGL_TRACEPATH_FUNC_BEGIN();
3351         _orig_tracepath_glTexParameteri(target, pname, param);
3352
3353         goto finish;
3354
3355 finish:
3356         _COREGL_TRACEPATH_FUNC_END();
3357 }
3358
3359 void
3360 tracepath_glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
3361 {
3362         _COREGL_TRACEPATH_FUNC_BEGIN();
3363         _orig_tracepath_glTexParameteriv(target, pname, params);
3364
3365         goto finish;
3366
3367 finish:
3368         _COREGL_TRACEPATH_FUNC_END();
3369 }
3370
3371 void
3372 tracepath_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
3373                                                   GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
3374                                                   const void *pixels)
3375 {
3376         _COREGL_TRACEPATH_FUNC_BEGIN();
3377         _orig_tracepath_glTexSubImage2D(target, level, xoffset, yoffset, width, height,
3378                                                                         format, type, pixels);
3379
3380         goto finish;
3381
3382 finish:
3383         _COREGL_TRACEPATH_FUNC_END();
3384 }
3385
3386 void
3387 tracepath_glUniform1f(GLint location, GLfloat x)
3388 {
3389         _COREGL_TRACEPATH_FUNC_BEGIN();
3390         _orig_tracepath_glUniform1f(location, x);
3391
3392         goto finish;
3393
3394 finish:
3395         _COREGL_TRACEPATH_FUNC_END();
3396 }
3397
3398 void
3399 tracepath_glUniform1fv(GLint location, GLsizei count, const GLfloat *v)
3400 {
3401         _COREGL_TRACEPATH_FUNC_BEGIN();
3402         _orig_tracepath_glUniform1fv(location, count, v);
3403
3404         goto finish;
3405
3406 finish:
3407         _COREGL_TRACEPATH_FUNC_END();
3408 }
3409
3410 void
3411 tracepath_glUniform1i(GLint location, GLint x)
3412 {
3413         _COREGL_TRACEPATH_FUNC_BEGIN();
3414         _orig_tracepath_glUniform1i(location, x);
3415
3416         goto finish;
3417
3418 finish:
3419         _COREGL_TRACEPATH_FUNC_END();
3420 }
3421
3422 void
3423 tracepath_glUniform1iv(GLint location, GLsizei count, const GLint *v)
3424 {
3425         _COREGL_TRACEPATH_FUNC_BEGIN();
3426         _orig_tracepath_glUniform1iv(location, count, v);
3427
3428         goto finish;
3429
3430 finish:
3431         _COREGL_TRACEPATH_FUNC_END();
3432 }
3433
3434 void
3435 tracepath_glUniform2f(GLint location, GLfloat x, GLfloat y)
3436 {
3437         _COREGL_TRACEPATH_FUNC_BEGIN();
3438         _orig_tracepath_glUniform2f(location, x, y);
3439
3440         goto finish;
3441
3442 finish:
3443         _COREGL_TRACEPATH_FUNC_END();
3444 }
3445
3446 void
3447 tracepath_glUniform2fv(GLint location, GLsizei count, const GLfloat *v)
3448 {
3449         _COREGL_TRACEPATH_FUNC_BEGIN();
3450         _orig_tracepath_glUniform2fv(location, count, v);
3451
3452         goto finish;
3453
3454 finish:
3455         _COREGL_TRACEPATH_FUNC_END();
3456 }
3457
3458 void
3459 tracepath_glUniform2i(GLint location, GLint x, GLint y)
3460 {
3461         _COREGL_TRACEPATH_FUNC_BEGIN();
3462         _orig_tracepath_glUniform2i(location, x, y);
3463
3464         goto finish;
3465
3466 finish:
3467         _COREGL_TRACEPATH_FUNC_END();
3468 }
3469
3470 void
3471 tracepath_glUniform2iv(GLint location, GLsizei count, const GLint *v)
3472 {
3473         _COREGL_TRACEPATH_FUNC_BEGIN();
3474         _orig_tracepath_glUniform2iv(location, count, v);
3475
3476         goto finish;
3477
3478 finish:
3479         _COREGL_TRACEPATH_FUNC_END();
3480 }
3481
3482 void
3483 tracepath_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
3484 {
3485         _COREGL_TRACEPATH_FUNC_BEGIN();
3486         _orig_tracepath_glUniform3f(location, x, y, z);
3487
3488         goto finish;
3489
3490 finish:
3491         _COREGL_TRACEPATH_FUNC_END();
3492 }
3493
3494 void
3495 tracepath_glUniform3fv(GLint location, GLsizei count, const GLfloat *v)
3496 {
3497         _COREGL_TRACEPATH_FUNC_BEGIN();
3498         _orig_tracepath_glUniform3fv(location, count, v);
3499
3500         goto finish;
3501
3502 finish:
3503         _COREGL_TRACEPATH_FUNC_END();
3504 }
3505
3506 void
3507 tracepath_glUniform3i(GLint location, GLint x, GLint y, GLint z)
3508 {
3509         _COREGL_TRACEPATH_FUNC_BEGIN();
3510         _orig_tracepath_glUniform3i(location, x, y, z);
3511
3512         goto finish;
3513
3514 finish:
3515         _COREGL_TRACEPATH_FUNC_END();
3516 }
3517
3518 void
3519 tracepath_glUniform3iv(GLint location, GLsizei count, const GLint *v)
3520 {
3521         _COREGL_TRACEPATH_FUNC_BEGIN();
3522         _orig_tracepath_glUniform3iv(location, count, v);
3523
3524         goto finish;
3525
3526 finish:
3527         _COREGL_TRACEPATH_FUNC_END();
3528 }
3529
3530 void
3531 tracepath_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z,
3532                                           GLfloat w)
3533 {
3534         _COREGL_TRACEPATH_FUNC_BEGIN();
3535         _orig_tracepath_glUniform4f(location, x, y, z, w);
3536
3537         goto finish;
3538
3539 finish:
3540         _COREGL_TRACEPATH_FUNC_END();
3541 }
3542
3543 void
3544 tracepath_glUniform4fv(GLint location, GLsizei count, const GLfloat *v)
3545 {
3546         _COREGL_TRACEPATH_FUNC_BEGIN();
3547         _orig_tracepath_glUniform4fv(location, count, v);
3548
3549         goto finish;
3550
3551 finish:
3552         _COREGL_TRACEPATH_FUNC_END();
3553 }
3554
3555 void
3556 tracepath_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
3557 {
3558         _COREGL_TRACEPATH_FUNC_BEGIN();
3559         _orig_tracepath_glUniform4i(location, x, y, z, w);
3560
3561         goto finish;
3562
3563 finish:
3564         _COREGL_TRACEPATH_FUNC_END();
3565 }
3566
3567 void
3568 tracepath_glUniform4iv(GLint location, GLsizei count, const GLint *v)
3569 {
3570         _COREGL_TRACEPATH_FUNC_BEGIN();
3571         _orig_tracepath_glUniform4iv(location, count, v);
3572
3573         goto finish;
3574
3575 finish:
3576         _COREGL_TRACEPATH_FUNC_END();
3577 }
3578
3579 void
3580 tracepath_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
3581                                                          const GLfloat *value)
3582 {
3583         _COREGL_TRACEPATH_FUNC_BEGIN();
3584         _orig_tracepath_glUniformMatrix2fv(location, count, transpose, value);
3585
3586         goto finish;
3587
3588 finish:
3589         _COREGL_TRACEPATH_FUNC_END();
3590 }
3591
3592 void
3593 tracepath_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
3594                                                          const GLfloat *value)
3595 {
3596         _COREGL_TRACEPATH_FUNC_BEGIN();
3597         _orig_tracepath_glUniformMatrix3fv(location, count, transpose, value);
3598
3599         goto finish;
3600
3601 finish:
3602         _COREGL_TRACEPATH_FUNC_END();
3603 }
3604
3605 void
3606 tracepath_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
3607                                                          const GLfloat *value)
3608 {
3609         _COREGL_TRACEPATH_FUNC_BEGIN();
3610         _orig_tracepath_glUniformMatrix4fv(location, count, transpose, value);
3611
3612         goto finish;
3613
3614 finish:
3615         _COREGL_TRACEPATH_FUNC_END();
3616 }
3617
3618 void
3619 tracepath_glUseProgram(GLuint program)
3620 {
3621         _COREGL_TRACEPATH_FUNC_BEGIN();
3622         _orig_tracepath_glUseProgram(program);
3623
3624         goto finish;
3625
3626 finish:
3627         _COREGL_TRACEPATH_FUNC_END();
3628 }
3629
3630 void
3631 tracepath_glValidateProgram(GLuint program)
3632 {
3633         _COREGL_TRACEPATH_FUNC_BEGIN();
3634         _orig_tracepath_glValidateProgram(program);
3635
3636         goto finish;
3637
3638 finish:
3639         _COREGL_TRACEPATH_FUNC_END();
3640 }
3641
3642 void
3643 tracepath_glVertexAttrib1f(GLuint index, GLfloat x)
3644 {
3645         _COREGL_TRACEPATH_FUNC_BEGIN();
3646         _orig_tracepath_glVertexAttrib1f(index, x);
3647
3648         goto finish;
3649
3650 finish:
3651         _COREGL_TRACEPATH_FUNC_END();
3652 }
3653
3654 void
3655 tracepath_glVertexAttrib1fv(GLuint index, const GLfloat *values)
3656 {
3657         _COREGL_TRACEPATH_FUNC_BEGIN();
3658         _orig_tracepath_glVertexAttrib1fv(index, values);
3659
3660         goto finish;
3661
3662 finish:
3663         _COREGL_TRACEPATH_FUNC_END();
3664 }
3665
3666 void
3667 tracepath_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
3668 {
3669         _COREGL_TRACEPATH_FUNC_BEGIN();
3670         _orig_tracepath_glVertexAttrib2f(index, x, y);
3671
3672         goto finish;
3673
3674 finish:
3675         _COREGL_TRACEPATH_FUNC_END();
3676 }
3677
3678 void
3679 tracepath_glVertexAttrib2fv(GLuint index, const GLfloat *values)
3680 {
3681         _COREGL_TRACEPATH_FUNC_BEGIN();
3682         _orig_tracepath_glVertexAttrib2fv(index, values);
3683
3684         goto finish;
3685
3686 finish:
3687         _COREGL_TRACEPATH_FUNC_END();
3688 }
3689
3690 void
3691 tracepath_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
3692 {
3693         _COREGL_TRACEPATH_FUNC_BEGIN();
3694         _orig_tracepath_glVertexAttrib3f(index, x, y, z);
3695
3696         goto finish;
3697
3698 finish:
3699         _COREGL_TRACEPATH_FUNC_END();
3700 }
3701
3702 void
3703 tracepath_glVertexAttrib3fv(GLuint index, const GLfloat *values)
3704 {
3705         _COREGL_TRACEPATH_FUNC_BEGIN();
3706         _orig_tracepath_glVertexAttrib3fv(index, values);
3707
3708         goto finish;
3709
3710 finish:
3711         _COREGL_TRACEPATH_FUNC_END();
3712 }
3713
3714 void
3715 tracepath_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
3716                                                    GLfloat w)
3717 {
3718         _COREGL_TRACEPATH_FUNC_BEGIN();
3719         _orig_tracepath_glVertexAttrib4f(index, x, y, z, w);
3720
3721         goto finish;
3722
3723 finish:
3724         _COREGL_TRACEPATH_FUNC_END();
3725 }
3726
3727 void
3728 tracepath_glVertexAttrib4fv(GLuint index, const GLfloat *values)
3729 {
3730         _COREGL_TRACEPATH_FUNC_BEGIN();
3731         _orig_tracepath_glVertexAttrib4fv(index, values);
3732
3733         goto finish;
3734
3735 finish:
3736         _COREGL_TRACEPATH_FUNC_END();
3737 }
3738
3739 void
3740 tracepath_glVertexAttribPointer(GLuint index, GLint size, GLenum type,
3741                                                                 GLboolean normalized, GLsizei stride, const void *pointer)
3742 {
3743         _COREGL_TRACEPATH_FUNC_BEGIN();
3744         _orig_tracepath_glVertexAttribPointer(index, size, type, normalized, stride,
3745                                                                                   pointer);
3746
3747         goto finish;
3748
3749 finish:
3750         _COREGL_TRACEPATH_FUNC_END();
3751 }
3752
3753 void
3754 tracepath_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
3755 {
3756         _COREGL_TRACEPATH_FUNC_BEGIN();
3757         _orig_tracepath_glViewport(x, y, width, height);
3758
3759         goto finish;
3760
3761 finish:
3762         _COREGL_TRACEPATH_FUNC_END();
3763 }
3764
3765
3766 /* OpenGL ES 3.0 */
3767 void
3768 tracepath_glReadBuffer(GLenum mode)
3769 {
3770         _COREGL_TRACEPATH_FUNC_BEGIN();
3771         _orig_tracepath_glReadBuffer(mode);
3772
3773         goto finish;
3774
3775 finish:
3776         _COREGL_TRACEPATH_FUNC_END();
3777 }
3778
3779 void
3780 tracepath_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
3781                                                           GLsizei count, GLenum type, const GLvoid *indices)
3782 {
3783         _COREGL_TRACEPATH_FUNC_BEGIN();
3784         _orig_tracepath_glDrawRangeElements(mode, start, end, count, type, indices);
3785
3786         goto finish;
3787
3788 finish:
3789         _COREGL_TRACEPATH_FUNC_END();
3790 }
3791
3792 void
3793 tracepath_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat,
3794                                            GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
3795                                            GLenum type, const GLvoid *pixels)
3796 {
3797         _COREGL_TRACEPATH_FUNC_BEGIN();
3798         _orig_tracepath_glTexImage3D(target, level, GLinternalFormat, width, height,
3799                                                                  depth, border, format, type, pixels);
3800
3801         goto finish;
3802
3803 finish:
3804         _COREGL_TRACEPATH_FUNC_END();
3805 }
3806
3807 void
3808 tracepath_glTexImage3DOES(GLenum target, GLint level, GLenum GLinternalFormat,
3809                                                   GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
3810                                                   GLenum type, const void *pixels)
3811 {
3812         _COREGL_TRACEPATH_FUNC_BEGIN();
3813         _orig_tracepath_glTexImage3DOES(target, level, GLinternalFormat, width, height,
3814                                                                         depth, border, format, type, pixels);
3815
3816         goto finish;
3817
3818 finish:
3819         _COREGL_TRACEPATH_FUNC_END();
3820 }
3821
3822 void
3823 tracepath_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
3824                                                   GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
3825                                                   GLenum format, GLenum type, const GLvoid *pixels)
3826 {
3827         _COREGL_TRACEPATH_FUNC_BEGIN();
3828         _orig_tracepath_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
3829                                                                         height, depth, format, type, pixels);
3830
3831         goto finish;
3832
3833 finish:
3834         _COREGL_TRACEPATH_FUNC_END();
3835 }
3836
3837 void
3838 tracepath_glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset,
3839                                                          GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
3840                                                          GLenum format, GLenum type, const GLvoid *pixels)
3841 {
3842         _COREGL_TRACEPATH_FUNC_BEGIN();
3843         _orig_tracepath_glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset,
3844                                                                            width, height, depth, format, type, pixels);
3845
3846         goto finish;
3847
3848 finish:
3849         _COREGL_TRACEPATH_FUNC_END();
3850 }
3851
3852 void
3853 tracepath_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
3854                                                           GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
3855 {
3856         _COREGL_TRACEPATH_FUNC_BEGIN();
3857         _orig_tracepath_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x,
3858                                                                                 y, width, height);
3859
3860         goto finish;
3861
3862 finish:
3863         _COREGL_TRACEPATH_FUNC_END();
3864 }
3865
3866 void
3867 tracepath_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset,
3868                                                                  GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
3869 {
3870         _COREGL_TRACEPATH_FUNC_BEGIN();
3871         _orig_tracepath_glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset,
3872                                                                                    x, y, width, height);
3873
3874         goto finish;
3875
3876 finish:
3877         _COREGL_TRACEPATH_FUNC_END();
3878 }
3879
3880 void
3881 tracepath_glCompressedTexImage3D(GLenum target, GLint level,
3882                                                                  GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
3883                                                                  GLint border, GLsizei imageSize, const GLvoid *data)
3884 {
3885         _COREGL_TRACEPATH_FUNC_BEGIN();
3886         _orig_tracepath_glCompressedTexImage3D(target, level, GLinternalformat, width,
3887                                                                                    height, depth, border, imageSize, data);
3888
3889         goto finish;
3890
3891 finish:
3892         _COREGL_TRACEPATH_FUNC_END();
3893 }
3894
3895 void
3896 tracepath_glCompressedTexImage3DOES(GLenum target, GLint level,
3897                                                                         GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
3898                                                                         GLint border, GLsizei imageSize, const GLvoid *data)
3899 {
3900         _COREGL_TRACEPATH_FUNC_BEGIN();
3901         _orig_tracepath_glCompressedTexImage3DOES(target, level, GLinternalformat,
3902                         width, height, depth, border, imageSize, data);
3903
3904         goto finish;
3905
3906 finish:
3907         _COREGL_TRACEPATH_FUNC_END();
3908 }
3909
3910 void
3911 tracepath_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
3912                                                                         GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
3913                                                                         GLenum format, GLsizei imageSize, const GLvoid *data)
3914 {
3915         _COREGL_TRACEPATH_FUNC_BEGIN();
3916         _orig_tracepath_glCompressedTexSubImage3D(target, level, xoffset, yoffset,
3917                         zoffset, width, height, depth, format, imageSize, data);
3918
3919         goto finish;
3920
3921 finish:
3922         _COREGL_TRACEPATH_FUNC_END();
3923 }
3924
3925 void
3926 tracepath_glCompressedTexSubImage3DOES(GLenum target, GLint level,
3927                                                                            GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
3928                                                                            GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
3929 {
3930         _COREGL_TRACEPATH_FUNC_BEGIN();
3931         _orig_tracepath_glCompressedTexSubImage3DOES(target, level, xoffset, yoffset,
3932                         zoffset, width, height, depth, format, imageSize, data);
3933
3934         goto finish;
3935
3936 finish:
3937         _COREGL_TRACEPATH_FUNC_END();
3938 }
3939
3940 void
3941 tracepath_glGenQueries(GLsizei n, GLuint *ids)
3942 {
3943         _COREGL_TRACEPATH_FUNC_BEGIN();
3944         _orig_tracepath_glGenQueries(n, ids);
3945
3946         goto finish;
3947
3948 finish:
3949         _COREGL_TRACEPATH_FUNC_END();
3950 }
3951
3952 void
3953 tracepath_glDeleteQueries(GLsizei n, const GLuint *ids)
3954 {
3955         _COREGL_TRACEPATH_FUNC_BEGIN();
3956         _orig_tracepath_glDeleteQueries(n, ids);
3957
3958         goto finish;
3959
3960 finish:
3961         _COREGL_TRACEPATH_FUNC_END();
3962 }
3963
3964 GLboolean
3965 tracepath_glIsQuery(GLuint id)
3966 {
3967         GLboolean ret = GL_FALSE;
3968
3969         _COREGL_TRACEPATH_FUNC_BEGIN();
3970         ret = _orig_tracepath_glIsQuery(id);
3971
3972         goto finish;
3973
3974 finish:
3975         _COREGL_TRACEPATH_FUNC_END();
3976         return ret;
3977 }
3978
3979 void
3980 tracepath_glBeginQuery(GLenum target, GLuint id)
3981 {
3982         _COREGL_TRACEPATH_FUNC_BEGIN();
3983         _orig_tracepath_glBeginQuery(target, id);
3984
3985         goto finish;
3986
3987 finish:
3988         _COREGL_TRACEPATH_FUNC_END();
3989 }
3990
3991 void
3992 tracepath_glEndQuery(GLenum target)
3993 {
3994         _COREGL_TRACEPATH_FUNC_BEGIN();
3995         _orig_tracepath_glEndQuery(target);
3996
3997         goto finish;
3998
3999 finish:
4000         _COREGL_TRACEPATH_FUNC_END();
4001 }
4002
4003 void
4004 tracepath_glGetQueryiv(GLenum target, GLenum pname, GLint *params)
4005 {
4006         _COREGL_TRACEPATH_FUNC_BEGIN();
4007         _orig_tracepath_glGetQueryiv(target, pname, params);
4008
4009         goto finish;
4010
4011 finish:
4012         _COREGL_TRACEPATH_FUNC_END();
4013 }
4014
4015 void
4016 tracepath_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
4017 {
4018         _COREGL_TRACEPATH_FUNC_BEGIN();
4019         _orig_tracepath_glGetQueryObjectuiv(id, pname, params);
4020
4021         goto finish;
4022
4023 finish:
4024         _COREGL_TRACEPATH_FUNC_END();
4025 }
4026
4027 GLboolean
4028 tracepath_glUnmapBuffer(GLenum target)
4029 {
4030         GLboolean ret = GL_FALSE;
4031
4032         _COREGL_TRACEPATH_FUNC_BEGIN();
4033         ret = _orig_tracepath_glUnmapBuffer(target);
4034
4035         goto finish;
4036
4037 finish:
4038         _COREGL_TRACEPATH_FUNC_END();
4039         return ret;
4040 }
4041
4042 void
4043 tracepath_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
4044 {
4045         _COREGL_TRACEPATH_FUNC_BEGIN();
4046         _orig_tracepath_glGetBufferPointerv(target, pname, params);
4047
4048         goto finish;
4049
4050 finish:
4051         _COREGL_TRACEPATH_FUNC_END();
4052 }
4053
4054 void
4055 tracepath_glDrawBuffers(GLsizei n, const GLenum *bufs)
4056 {
4057         _COREGL_TRACEPATH_FUNC_BEGIN();
4058         _orig_tracepath_glDrawBuffers(n, bufs);
4059
4060         goto finish;
4061
4062 finish:
4063         _COREGL_TRACEPATH_FUNC_END();
4064 }
4065
4066 void
4067 tracepath_glUniformMatrix2x3fv(GLint location, GLsizei count,
4068                                                            GLboolean transpose, const GLfloat *value)
4069 {
4070         _COREGL_TRACEPATH_FUNC_BEGIN();
4071         _orig_tracepath_glUniformMatrix2x3fv(location, count, transpose, value);
4072
4073         goto finish;
4074
4075 finish:
4076         _COREGL_TRACEPATH_FUNC_END();
4077 }
4078
4079 void
4080 tracepath_glUniformMatrix3x2fv(GLint location, GLsizei count,
4081                                                            GLboolean transpose, const GLfloat *value)
4082 {
4083         _COREGL_TRACEPATH_FUNC_BEGIN();
4084         _orig_tracepath_glUniformMatrix3x2fv(location, count, transpose, value);
4085
4086         goto finish;
4087
4088 finish:
4089         _COREGL_TRACEPATH_FUNC_END();
4090 }
4091
4092 void
4093 tracepath_glUniformMatrix2x4fv(GLint location, GLsizei count,
4094                                                            GLboolean transpose, const GLfloat *value)
4095 {
4096         _COREGL_TRACEPATH_FUNC_BEGIN();
4097         _orig_tracepath_glUniformMatrix2x4fv(location, count, transpose, value);
4098
4099         goto finish;
4100
4101 finish:
4102         _COREGL_TRACEPATH_FUNC_END();
4103 }
4104
4105 void
4106 tracepath_glUniformMatrix4x2fv(GLint location, GLsizei count,
4107                                                            GLboolean transpose, const GLfloat *value)
4108 {
4109         _COREGL_TRACEPATH_FUNC_BEGIN();
4110         _orig_tracepath_glUniformMatrix4x2fv(location, count, transpose, value);
4111
4112         goto finish;
4113
4114 finish:
4115         _COREGL_TRACEPATH_FUNC_END();
4116 }
4117
4118 void
4119 tracepath_glUniformMatrix3x4fv(GLint location, GLsizei count,
4120                                                            GLboolean transpose, const GLfloat *value)
4121 {
4122         _COREGL_TRACEPATH_FUNC_BEGIN();
4123         _orig_tracepath_glUniformMatrix3x4fv(location, count, transpose, value);
4124
4125         goto finish;
4126
4127 finish:
4128         _COREGL_TRACEPATH_FUNC_END();
4129 }
4130
4131 void
4132 tracepath_glUniformMatrix4x3fv(GLint location, GLsizei count,
4133                                                            GLboolean transpose, const GLfloat *value)
4134 {
4135         _COREGL_TRACEPATH_FUNC_BEGIN();
4136         _orig_tracepath_glUniformMatrix4x3fv(location, count, transpose, value);
4137
4138         goto finish;
4139
4140 finish:
4141         _COREGL_TRACEPATH_FUNC_END();
4142 }
4143
4144 void
4145 tracepath_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
4146                                                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
4147                                                         GLenum filter)
4148 {
4149         _COREGL_TRACEPATH_FUNC_BEGIN();
4150         _orig_tracepath_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
4151                                                                           dstX1, dstY1, mask, filter);
4152
4153         goto finish;
4154
4155 finish:
4156         _COREGL_TRACEPATH_FUNC_END();
4157 }
4158
4159 static void
4160 _tp_glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
4161                 GLenum internalformat, GLsizei width, GLsizei height, TRACEPATH_FUNC_TYPE ftype)
4162 {
4163         switch (ftype) {
4164         case TRACEPATH_FUNC_TYPE_STANDARD:
4165                 _orig_tracepath_glRenderbufferStorageMultisample(target, samples,
4166                         internalformat, width, height);
4167                 break;
4168         case TRACEPATH_FUNC_TYPE_EXT:
4169                 _orig_tracepath_glRenderbufferStorageMultisampleEXT(target, samples,
4170                         internalformat, width, height);
4171                 break;
4172         default:
4173                 goto finish;
4174         }
4175
4176         goto finish;
4177
4178 finish:
4179 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4180         if (get_trace_mem_flag() == 1) {
4181                 MY_MODULE_TSTATE* tstate = _get_my_state();
4182                 if (tstate && tstate->ctx != NULL) {
4183                         struct _Glbuf_Data data = _get_glbuf_data(GL_RENDERBUFFER_BINDING, internalformat);
4184                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, data.obj_idx, "Renderbuffer", width,
4185                                                           height, data.bpp, data.format);
4186                 }
4187         }
4188 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4189 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4190         if (get_trace_surface_flag() == 1) {
4191                 MY_MODULE_TSTATE* tstate = _get_my_state();
4192                 if (tstate && tstate->ctx != NULL) {
4193                         int objidx = _COREGL_INT_INIT_VALUE;
4194                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4195                         AST(objidx != _COREGL_INT_INIT_VALUE);
4196
4197                         {
4198                                 int channel = _get_channel_by_format(internalformat);
4199                                 char name[256];
4200                                 snprintf(name, sizeof(name), "FBORB_0x%X", objidx);
4201                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
4202                                                                                         tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
4203                         }
4204                 }
4205         }
4206 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4207 }
4208
4209 void
4210 tracepath_glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
4211         GLenum internalformat, GLsizei width, GLsizei height)
4212 {
4213         _COREGL_TRACEPATH_FUNC_BEGIN();
4214
4215         _tp_glRenderbufferStorageMultisample(target, samples, internalformat,
4216                 width, height, TRACEPATH_FUNC_TYPE_STANDARD);
4217
4218         _COREGL_TRACEPATH_FUNC_END();
4219 }
4220
4221 void
4222 tracepath_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples,
4223                 GLenum internalformat, GLsizei width, GLsizei height)
4224 {
4225         _COREGL_TRACEPATH_FUNC_BEGIN();
4226
4227         _tp_glRenderbufferStorageMultisample(target, samples, internalformat,
4228                 width, height, TRACEPATH_FUNC_TYPE_EXT);
4229
4230         _COREGL_TRACEPATH_FUNC_END();
4231 }
4232
4233 void
4234 tracepath_glFramebufferTextureLayer(GLenum target, GLenum attachment,
4235                                                                         GLuint texture, GLint level, GLint layer)
4236 {
4237         _COREGL_TRACEPATH_FUNC_BEGIN();
4238
4239 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4240         tracepath_fbdump_update(0);
4241 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4242
4243         _orig_tracepath_glFramebufferTextureLayer(target, attachment, texture, level,
4244                         layer);
4245
4246 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4247         tracepath_fbdump_update(1);
4248 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4249
4250         goto finish;
4251
4252 finish:
4253         _COREGL_TRACEPATH_FUNC_END();
4254 }
4255
4256 GLvoid *
4257 tracepath_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
4258                                                    GLbitfield access)
4259 {
4260         GLvoid *ret = NULL;
4261
4262         _COREGL_TRACEPATH_FUNC_BEGIN();
4263         ret = _orig_tracepath_glMapBufferRange(target, offset, length, access);
4264
4265         goto finish;
4266
4267 finish:
4268         _COREGL_TRACEPATH_FUNC_END();
4269         return ret;
4270 }
4271
4272 void
4273 tracepath_glFlushMappedBufferRange(GLenum target, GLintptr offset,
4274                                                                    GLsizeiptr length)
4275 {
4276         _COREGL_TRACEPATH_FUNC_BEGIN();
4277         _orig_tracepath_glFlushMappedBufferRange(target, offset, length);
4278
4279         goto finish;
4280
4281 finish:
4282         _COREGL_TRACEPATH_FUNC_END();
4283 }
4284
4285 void
4286 tracepath_glBindVertexArray(GLuint array)
4287 {
4288         _COREGL_TRACEPATH_FUNC_BEGIN();
4289         _orig_tracepath_glBindVertexArray(array);
4290
4291         goto finish;
4292
4293 finish:
4294         _COREGL_TRACEPATH_FUNC_END();
4295 }
4296
4297 void
4298 tracepath_glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
4299 {
4300         _COREGL_TRACEPATH_FUNC_BEGIN();
4301         _orig_tracepath_glDeleteVertexArrays(n, arrays);
4302
4303         goto finish;
4304
4305 finish:
4306         _COREGL_TRACEPATH_FUNC_END();
4307 }
4308
4309 void
4310 tracepath_glGenVertexArrays(GLsizei n, GLuint *arrays)
4311 {
4312         _COREGL_TRACEPATH_FUNC_BEGIN();
4313         _orig_tracepath_glGenVertexArrays(n, arrays);
4314
4315         goto finish;
4316
4317 finish:
4318         _COREGL_TRACEPATH_FUNC_END();
4319 }
4320
4321 GLboolean
4322 tracepath_glIsVertexArray(GLuint array)
4323 {
4324         GLboolean ret = GL_FALSE;
4325
4326         _COREGL_TRACEPATH_FUNC_BEGIN();
4327         ret = _orig_tracepath_glIsVertexArray(array);
4328
4329         goto finish;
4330
4331 finish:
4332         _COREGL_TRACEPATH_FUNC_END();
4333         return ret;
4334 }
4335
4336 void
4337 tracepath_glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
4338 {
4339         _COREGL_TRACEPATH_FUNC_BEGIN();
4340         _orig_tracepath_glGetIntegeri_v(target, index, data);
4341
4342         goto finish;
4343
4344 finish:
4345         _COREGL_TRACEPATH_FUNC_END();
4346 }
4347
4348 void
4349 tracepath_glBeginTransformFeedback(GLenum primitiveMode)
4350 {
4351         _COREGL_TRACEPATH_FUNC_BEGIN();
4352         _orig_tracepath_glBeginTransformFeedback(primitiveMode);
4353
4354         goto finish;
4355
4356 finish:
4357         _COREGL_TRACEPATH_FUNC_END();
4358 }
4359
4360 void
4361 tracepath_glEndTransformFeedback()
4362 {
4363         _COREGL_TRACEPATH_FUNC_BEGIN();
4364         _orig_tracepath_glEndTransformFeedback();
4365
4366         goto finish;
4367
4368 finish:
4369         _COREGL_TRACEPATH_FUNC_END();
4370 }
4371
4372 void
4373 tracepath_glBindBufferRange(GLenum target, GLuint index, GLuint buffer,
4374                                                         GLintptr offset, GLsizeiptr size)
4375 {
4376         _COREGL_TRACEPATH_FUNC_BEGIN();
4377         _orig_tracepath_glBindBufferRange(target, index, buffer, offset, size);
4378
4379         goto finish;
4380
4381 finish:
4382         _COREGL_TRACEPATH_FUNC_END();
4383 }
4384
4385 void
4386 tracepath_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
4387 {
4388         _COREGL_TRACEPATH_FUNC_BEGIN();
4389         _orig_tracepath_glBindBufferBase(target, index, buffer);
4390
4391         goto finish;
4392
4393 finish:
4394         _COREGL_TRACEPATH_FUNC_END();
4395 }
4396
4397 void
4398 tracepath_glTransformFeedbackVaryings(GLuint program, GLsizei count,
4399                                                                           const GLchar *const *varyings, GLenum bufferMode)
4400 {
4401         _COREGL_TRACEPATH_FUNC_BEGIN();
4402         _orig_tracepath_glTransformFeedbackVaryings(program, count, varyings,
4403                         bufferMode);
4404
4405         goto finish;
4406
4407 finish:
4408         _COREGL_TRACEPATH_FUNC_END();
4409 }
4410
4411 void
4412 tracepath_glGetTransformFeedbackVarying(GLuint program, GLuint index,
4413                                                                                 GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
4414 {
4415         _COREGL_TRACEPATH_FUNC_BEGIN();
4416         _orig_tracepath_glGetTransformFeedbackVarying(program, index, bufSize, length,
4417                         size, type, name);
4418
4419         goto finish;
4420
4421 finish:
4422         _COREGL_TRACEPATH_FUNC_END();
4423 }
4424
4425 void
4426 tracepath_glVertexAttribIPointer(GLuint index, GLint size, GLenum type,
4427                                                                  GLsizei stride, const GLvoid *pointer)
4428 {
4429         _COREGL_TRACEPATH_FUNC_BEGIN();
4430         _orig_tracepath_glVertexAttribIPointer(index, size, type, stride, pointer);
4431
4432         goto finish;
4433
4434 finish:
4435         _COREGL_TRACEPATH_FUNC_END();
4436 }
4437
4438 void
4439 tracepath_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
4440 {
4441         _COREGL_TRACEPATH_FUNC_BEGIN();
4442         _orig_tracepath_glGetVertexAttribIiv(index, pname, params);
4443
4444         goto finish;
4445
4446 finish:
4447         _COREGL_TRACEPATH_FUNC_END();
4448 }
4449
4450 void
4451 tracepath_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
4452 {
4453         _COREGL_TRACEPATH_FUNC_BEGIN();
4454         _orig_tracepath_glGetVertexAttribIuiv(index, pname, params);
4455
4456         goto finish;
4457
4458 finish:
4459         _COREGL_TRACEPATH_FUNC_END();
4460 }
4461
4462 void
4463 tracepath_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
4464 {
4465         _COREGL_TRACEPATH_FUNC_BEGIN();
4466         _orig_tracepath_glVertexAttribI4i(index, x, y, z, w);
4467
4468         goto finish;
4469
4470 finish:
4471         _COREGL_TRACEPATH_FUNC_END();
4472 }
4473
4474 void
4475 tracepath_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
4476                                                          GLuint w)
4477 {
4478         _COREGL_TRACEPATH_FUNC_BEGIN();
4479         _orig_tracepath_glVertexAttribI4ui(index, x, y, z, w);
4480
4481         goto finish;
4482
4483 finish:
4484         _COREGL_TRACEPATH_FUNC_END();
4485 }
4486
4487 void
4488 tracepath_glVertexAttribI4iv(GLuint index, const GLint *v)
4489 {
4490         _COREGL_TRACEPATH_FUNC_BEGIN();
4491         _orig_tracepath_glVertexAttribI4iv(index, v);
4492
4493         goto finish;
4494
4495 finish:
4496         _COREGL_TRACEPATH_FUNC_END();
4497 }
4498
4499 void
4500 tracepath_glVertexAttribI4uiv(GLuint index, const GLuint *v)
4501 {
4502         _COREGL_TRACEPATH_FUNC_BEGIN();
4503         _orig_tracepath_glVertexAttribI4uiv(index, v);
4504
4505         goto finish;
4506
4507 finish:
4508         _COREGL_TRACEPATH_FUNC_END();
4509 }
4510
4511 void
4512 tracepath_glGetUniformuiv(GLuint program, GLint location, GLuint *params)
4513 {
4514         _COREGL_TRACEPATH_FUNC_BEGIN();
4515         _orig_tracepath_glGetUniformuiv(program, location, params);
4516
4517         goto finish;
4518
4519 finish:
4520         _COREGL_TRACEPATH_FUNC_END();
4521 }
4522
4523 GLint
4524 tracepath_glGetFragDataLocation(GLuint program, const GLchar *name)
4525 {
4526         GLint ret = _COREGL_INT_INIT_VALUE;
4527
4528         _COREGL_TRACEPATH_FUNC_BEGIN();
4529         ret = _orig_tracepath_glGetFragDataLocation(program, name);
4530
4531         goto finish;
4532
4533 finish:
4534         _COREGL_TRACEPATH_FUNC_END();
4535         return ret;
4536 }
4537
4538 void
4539 tracepath_glUniform1ui(GLint location, GLuint v0)
4540 {
4541         _COREGL_TRACEPATH_FUNC_BEGIN();
4542         _orig_tracepath_glUniform1ui(location, v0);
4543
4544         goto finish;
4545
4546 finish:
4547         _COREGL_TRACEPATH_FUNC_END();
4548 }
4549
4550 void
4551 tracepath_glUniform2ui(GLint location, GLuint v0, GLuint v1)
4552 {
4553         _COREGL_TRACEPATH_FUNC_BEGIN();
4554         _orig_tracepath_glUniform2ui(location, v0, v1);
4555
4556         goto finish;
4557
4558 finish:
4559         _COREGL_TRACEPATH_FUNC_END();
4560 }
4561
4562 void
4563 tracepath_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
4564 {
4565         _COREGL_TRACEPATH_FUNC_BEGIN();
4566         _orig_tracepath_glUniform3ui(location, v0, v1, v2);
4567
4568         goto finish;
4569
4570 finish:
4571         _COREGL_TRACEPATH_FUNC_END();
4572 }
4573
4574 void
4575 tracepath_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2,
4576                                            GLuint v3)
4577 {
4578         _COREGL_TRACEPATH_FUNC_BEGIN();
4579         _orig_tracepath_glUniform4ui(location, v0, v1, v2, v3);
4580
4581         goto finish;
4582
4583 finish:
4584         _COREGL_TRACEPATH_FUNC_END();
4585 }
4586
4587 void
4588 tracepath_glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
4589 {
4590         _COREGL_TRACEPATH_FUNC_BEGIN();
4591         _orig_tracepath_glUniform1uiv(location, count, value);
4592
4593         goto finish;
4594
4595 finish:
4596         _COREGL_TRACEPATH_FUNC_END();
4597 }
4598
4599 void
4600 tracepath_glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
4601 {
4602         _COREGL_TRACEPATH_FUNC_BEGIN();
4603         _orig_tracepath_glUniform2uiv(location, count, value);
4604
4605         goto finish;
4606
4607 finish:
4608         _COREGL_TRACEPATH_FUNC_END();
4609 }
4610
4611 void
4612 tracepath_glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
4613 {
4614         _COREGL_TRACEPATH_FUNC_BEGIN();
4615         _orig_tracepath_glUniform3uiv(location, count, value);
4616
4617         goto finish;
4618
4619 finish:
4620         _COREGL_TRACEPATH_FUNC_END();
4621 }
4622
4623 void
4624 tracepath_glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
4625 {
4626         _COREGL_TRACEPATH_FUNC_BEGIN();
4627         _orig_tracepath_glUniform4uiv(location, count, value);
4628
4629         goto finish;
4630
4631 finish:
4632         _COREGL_TRACEPATH_FUNC_END();
4633 }
4634
4635 void
4636 tracepath_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
4637 {
4638         _COREGL_TRACEPATH_FUNC_BEGIN();
4639         _orig_tracepath_glClearBufferiv(buffer, drawbuffer, value);
4640
4641         goto finish;
4642
4643 finish:
4644         _COREGL_TRACEPATH_FUNC_END();
4645 }
4646
4647 void
4648 tracepath_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
4649 {
4650         _COREGL_TRACEPATH_FUNC_BEGIN();
4651         _orig_tracepath_glClearBufferuiv(buffer, drawbuffer, value);
4652
4653         goto finish;
4654
4655 finish:
4656         _COREGL_TRACEPATH_FUNC_END();
4657 }
4658
4659 void
4660 tracepath_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
4661 {
4662         _COREGL_TRACEPATH_FUNC_BEGIN();
4663         _orig_tracepath_glClearBufferfv(buffer, drawbuffer, value);
4664
4665         goto finish;
4666
4667 finish:
4668         _COREGL_TRACEPATH_FUNC_END();
4669 }
4670
4671 void
4672 tracepath_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth,
4673                                                   GLint stencil)
4674 {
4675         _COREGL_TRACEPATH_FUNC_BEGIN();
4676         _orig_tracepath_glClearBufferfi(buffer, drawbuffer, depth, stencil);
4677
4678         goto finish;
4679
4680 finish:
4681         _COREGL_TRACEPATH_FUNC_END();
4682 }
4683
4684 const GLubyte *
4685 tracepath_glGetStringi(GLenum name, GLuint index)
4686 {
4687         const GLubyte *ret = NULL;
4688
4689         _COREGL_TRACEPATH_FUNC_BEGIN();
4690         ret = _orig_tracepath_glGetStringi(name, index);
4691
4692         goto finish;
4693
4694 finish:
4695         _COREGL_TRACEPATH_FUNC_END();
4696         return ret;
4697 }
4698
4699 void
4700 tracepath_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget,
4701                                                           GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
4702 {
4703         _COREGL_TRACEPATH_FUNC_BEGIN();
4704         _orig_tracepath_glCopyBufferSubData(readTarget, writeTarget, readOffset,
4705                                                                                 writeOffset, size);
4706
4707         goto finish;
4708
4709 finish:
4710         _COREGL_TRACEPATH_FUNC_END();
4711 }
4712
4713 void
4714 tracepath_glGetUniformIndices(GLuint program, GLsizei uniformCount,
4715                                                           const GLchar *const *uniformNames, GLuint *uniformIndices)
4716 {
4717         _COREGL_TRACEPATH_FUNC_BEGIN();
4718         _orig_tracepath_glGetUniformIndices(program, uniformCount, uniformNames,
4719                                                                                 uniformIndices);
4720
4721         goto finish;
4722
4723 finish:
4724         _COREGL_TRACEPATH_FUNC_END();
4725 }
4726
4727 void
4728 tracepath_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
4729                                                                 const GLuint *uniformIndices, GLenum pname, GLint *params)
4730 {
4731         _COREGL_TRACEPATH_FUNC_BEGIN();
4732         _orig_tracepath_glGetActiveUniformsiv(program, uniformCount, uniformIndices,
4733                                                                                   pname, params);
4734
4735         goto finish;
4736
4737 finish:
4738         _COREGL_TRACEPATH_FUNC_END();
4739 }
4740
4741 GLuint
4742 tracepath_glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
4743 {
4744         GLuint ret = _COREGL_INT_INIT_VALUE;
4745
4746         _COREGL_TRACEPATH_FUNC_BEGIN();
4747         ret = _orig_tracepath_glGetUniformBlockIndex(program, uniformBlockName);
4748
4749         goto finish;
4750
4751 finish:
4752         _COREGL_TRACEPATH_FUNC_END();
4753         return ret;
4754 }
4755
4756 void
4757 tracepath_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
4758                                                                         GLenum pname, GLint *params)
4759 {
4760         _COREGL_TRACEPATH_FUNC_BEGIN();
4761         _orig_tracepath_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname,
4762                         params);
4763
4764         goto finish;
4765
4766 finish:
4767         _COREGL_TRACEPATH_FUNC_END();
4768 }
4769
4770 void
4771 tracepath_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
4772                                                                           GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
4773 {
4774         _COREGL_TRACEPATH_FUNC_BEGIN();
4775         _orig_tracepath_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize,
4776                         length, uniformBlockName);
4777
4778         goto finish;
4779
4780 finish:
4781         _COREGL_TRACEPATH_FUNC_END();
4782 }
4783
4784 void
4785 tracepath_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
4786                                                                 GLuint uniformBlockBinding)
4787 {
4788         _COREGL_TRACEPATH_FUNC_BEGIN();
4789         _orig_tracepath_glUniformBlockBinding(program, uniformBlockIndex,
4790                                                                                   uniformBlockBinding);
4791
4792         goto finish;
4793
4794 finish:
4795         _COREGL_TRACEPATH_FUNC_END();
4796 }
4797
4798 void
4799 tracepath_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
4800                                                                 GLsizei instanceCount)
4801 {
4802         _COREGL_TRACEPATH_FUNC_BEGIN();
4803         _orig_tracepath_glDrawArraysInstanced(mode, first, count, instanceCount);
4804
4805         goto finish;
4806
4807 finish:
4808         _COREGL_TRACEPATH_FUNC_END();
4809 }
4810
4811 void
4812 tracepath_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
4813                                                                   const GLvoid *indices, GLsizei instanceCount)
4814 {
4815         _COREGL_TRACEPATH_FUNC_BEGIN();
4816         _orig_tracepath_glDrawElementsInstanced(mode, count, type, indices,
4817                                                                                         instanceCount);
4818
4819         goto finish;
4820
4821 finish:
4822         _COREGL_TRACEPATH_FUNC_END();
4823 }
4824
4825 GLsync
4826 tracepath_glFenceSync(GLenum condition, GLbitfield flags)
4827 {
4828         GLsync ret = NULL;
4829
4830         _COREGL_TRACEPATH_FUNC_BEGIN();
4831         ret = _orig_tracepath_glFenceSync(condition, flags);
4832
4833         goto finish;
4834
4835 finish:
4836         _COREGL_TRACEPATH_FUNC_END();
4837         return ret;
4838 }
4839
4840 GLboolean
4841 tracepath_glIsSync(GLsync sync)
4842 {
4843         GLboolean ret = GL_FALSE;
4844
4845         _COREGL_TRACEPATH_FUNC_BEGIN();
4846         ret = _orig_tracepath_glIsSync(sync);
4847
4848         goto finish;
4849
4850 finish:
4851         _COREGL_TRACEPATH_FUNC_END();
4852         return ret;
4853 }
4854
4855 void
4856 tracepath_glDeleteSync(GLsync sync)
4857 {
4858         _COREGL_TRACEPATH_FUNC_BEGIN();
4859         _orig_tracepath_glDeleteSync(sync);
4860
4861         goto finish;
4862
4863 finish:
4864         _COREGL_TRACEPATH_FUNC_END();
4865 }
4866
4867 GLenum
4868 tracepath_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
4869 {
4870         GLenum ret = _COREGL_INT_INIT_VALUE;
4871
4872         _COREGL_TRACEPATH_FUNC_BEGIN();
4873         ret = _orig_tracepath_glClientWaitSync(sync, flags, timeout);
4874
4875         goto finish;
4876
4877 finish:
4878         _COREGL_TRACEPATH_FUNC_END();
4879         return ret;
4880 }
4881
4882 void
4883 tracepath_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
4884 {
4885         _COREGL_TRACEPATH_FUNC_BEGIN();
4886         _orig_tracepath_glWaitSync(sync, flags, timeout);
4887
4888         goto finish;
4889
4890 finish:
4891         _COREGL_TRACEPATH_FUNC_END();
4892 }
4893
4894 void
4895 tracepath_glGetInteger64v(GLenum pname, GLint64 *params)
4896 {
4897         _COREGL_TRACEPATH_FUNC_BEGIN();
4898         _orig_tracepath_glGetInteger64v(pname, params);
4899
4900         goto finish;
4901
4902 finish:
4903         _COREGL_TRACEPATH_FUNC_END();
4904 }
4905
4906 void
4907 tracepath_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize,
4908                                           GLsizei *length, GLint *values)
4909 {
4910         _COREGL_TRACEPATH_FUNC_BEGIN();
4911         _orig_tracepath_glGetSynciv(sync, pname, bufSize, length, values);
4912
4913         goto finish;
4914
4915 finish:
4916         _COREGL_TRACEPATH_FUNC_END();
4917 }
4918
4919 void
4920 tracepath_glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
4921 {
4922         _COREGL_TRACEPATH_FUNC_BEGIN();
4923         _orig_tracepath_glGetInteger64i_v(target, index, data);
4924
4925         goto finish;
4926
4927 finish:
4928         _COREGL_TRACEPATH_FUNC_END();
4929 }
4930
4931 void
4932 tracepath_glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
4933 {
4934         _COREGL_TRACEPATH_FUNC_BEGIN();
4935         _orig_tracepath_glGetBufferParameteri64v(target, pname, params);
4936
4937         goto finish;
4938
4939 finish:
4940         _COREGL_TRACEPATH_FUNC_END();
4941 }
4942
4943 void
4944 tracepath_glGenSamplers(GLsizei n, GLuint *samplers)
4945 {
4946         _COREGL_TRACEPATH_FUNC_BEGIN();
4947         _orig_tracepath_glGenSamplers(n, samplers);
4948
4949         goto finish;
4950
4951 finish:
4952         _COREGL_TRACEPATH_FUNC_END();
4953 }
4954
4955 void
4956 tracepath_glDeleteSamplers(GLsizei n, const GLuint *samplers)
4957 {
4958         _COREGL_TRACEPATH_FUNC_BEGIN();
4959         _orig_tracepath_glDeleteSamplers(n, samplers);
4960
4961         goto finish;
4962
4963 finish:
4964         _COREGL_TRACEPATH_FUNC_END();
4965 }
4966
4967 GLboolean
4968 tracepath_glIsSampler(GLuint sampler)
4969 {
4970         GLboolean ret = GL_FALSE;
4971
4972         _COREGL_TRACEPATH_FUNC_BEGIN();
4973         ret = _orig_tracepath_glIsSampler(sampler);
4974
4975         goto finish;
4976
4977 finish:
4978         _COREGL_TRACEPATH_FUNC_END();
4979         return ret;
4980 }
4981
4982 void
4983 tracepath_glBindSampler(GLuint unit, GLuint sampler)
4984 {
4985         _COREGL_TRACEPATH_FUNC_BEGIN();
4986         _orig_tracepath_glBindSampler(unit, sampler);
4987
4988         goto finish;
4989
4990 finish:
4991         _COREGL_TRACEPATH_FUNC_END();
4992 }
4993
4994 void
4995 tracepath_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
4996 {
4997         _COREGL_TRACEPATH_FUNC_BEGIN();
4998         _orig_tracepath_glSamplerParameteri(sampler, pname, param);
4999
5000         goto finish;
5001
5002 finish:
5003         _COREGL_TRACEPATH_FUNC_END();
5004 }
5005
5006 void
5007 tracepath_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
5008 {
5009         _COREGL_TRACEPATH_FUNC_BEGIN();
5010         _orig_tracepath_glSamplerParameteriv(sampler, pname, param);
5011
5012         goto finish;
5013
5014 finish:
5015         _COREGL_TRACEPATH_FUNC_END();
5016 }
5017
5018 void
5019 tracepath_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
5020 {
5021         _COREGL_TRACEPATH_FUNC_BEGIN();
5022         _orig_tracepath_glSamplerParameterf(sampler, pname, param);
5023
5024         goto finish;
5025
5026 finish:
5027         _COREGL_TRACEPATH_FUNC_END();
5028 }
5029
5030 void
5031 tracepath_glSamplerParameterfv(GLuint sampler, GLenum pname,
5032                                                            const GLfloat *param)
5033 {
5034         _COREGL_TRACEPATH_FUNC_BEGIN();
5035         _orig_tracepath_glSamplerParameterfv(sampler, pname, param);
5036
5037         goto finish;
5038
5039 finish:
5040         _COREGL_TRACEPATH_FUNC_END();
5041 }
5042
5043 void
5044 tracepath_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
5045 {
5046         _COREGL_TRACEPATH_FUNC_BEGIN();
5047         _orig_tracepath_glGetSamplerParameteriv(sampler, pname, params);
5048
5049         goto finish;
5050
5051 finish:
5052         _COREGL_TRACEPATH_FUNC_END();
5053 }
5054
5055 void
5056 tracepath_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
5057 {
5058         _COREGL_TRACEPATH_FUNC_BEGIN();
5059         _orig_tracepath_glGetSamplerParameterfv(sampler, pname, params);
5060
5061         goto finish;
5062
5063 finish:
5064         _COREGL_TRACEPATH_FUNC_END();
5065 }
5066
5067 void
5068 tracepath_glVertexAttribDivisor(GLuint index, GLuint divisor)
5069 {
5070         _COREGL_TRACEPATH_FUNC_BEGIN();
5071         _orig_tracepath_glVertexAttribDivisor(index, divisor);
5072
5073         goto finish;
5074
5075 finish:
5076         _COREGL_TRACEPATH_FUNC_END();
5077 }
5078
5079 void
5080 tracepath_glBindTransformFeedback(GLenum target, GLuint id)
5081 {
5082         _COREGL_TRACEPATH_FUNC_BEGIN();
5083         _orig_tracepath_glBindTransformFeedback(target, id);
5084
5085         goto finish;
5086
5087 finish:
5088         _COREGL_TRACEPATH_FUNC_END();
5089 }
5090
5091 void
5092 tracepath_glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
5093 {
5094         _COREGL_TRACEPATH_FUNC_BEGIN();
5095         _orig_tracepath_glDeleteTransformFeedbacks(n, ids);
5096
5097         goto finish;
5098
5099 finish:
5100         _COREGL_TRACEPATH_FUNC_END();
5101 }
5102
5103 void
5104 tracepath_glGenTransformFeedbacks(GLsizei n, GLuint *ids)
5105 {
5106         _COREGL_TRACEPATH_FUNC_BEGIN();
5107         _orig_tracepath_glGenTransformFeedbacks(n, ids);
5108
5109         goto finish;
5110
5111 finish:
5112         _COREGL_TRACEPATH_FUNC_END();
5113 }
5114
5115 GLboolean
5116 tracepath_glIsTransformFeedback(GLuint id)
5117 {
5118         GLboolean ret = GL_FALSE;
5119
5120         _COREGL_TRACEPATH_FUNC_BEGIN();
5121         ret = _orig_tracepath_glIsTransformFeedback(id);
5122
5123         goto finish;
5124
5125 finish:
5126         _COREGL_TRACEPATH_FUNC_END();
5127         return ret;
5128 }
5129
5130 void
5131 tracepath_glPauseTransformFeedback()
5132 {
5133         _COREGL_TRACEPATH_FUNC_BEGIN();
5134         _orig_tracepath_glPauseTransformFeedback();
5135
5136         goto finish;
5137
5138 finish:
5139         _COREGL_TRACEPATH_FUNC_END();
5140 }
5141
5142 void
5143 tracepath_glResumeTransformFeedback()
5144 {
5145         _COREGL_TRACEPATH_FUNC_BEGIN();
5146         _orig_tracepath_glResumeTransformFeedback();
5147
5148         goto finish;
5149
5150 finish:
5151         _COREGL_TRACEPATH_FUNC_END();
5152 }
5153
5154 void
5155 tracepath_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
5156                                                          GLenum *binaryFormat, GLvoid *binary)
5157 {
5158         _COREGL_TRACEPATH_FUNC_BEGIN();
5159         _orig_tracepath_glGetProgramBinary(program, bufSize, length, binaryFormat,
5160                                                                            binary);
5161
5162         goto finish;
5163
5164 finish:
5165         _COREGL_TRACEPATH_FUNC_END();
5166 }
5167
5168 void
5169 tracepath_glGetProgramBinaryOES(GLuint program, GLsizei bufSize,
5170                                                                 GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
5171 {
5172         _COREGL_TRACEPATH_FUNC_BEGIN();
5173         _orig_tracepath_glGetProgramBinaryOES(program, bufSize, length, binaryFormat,
5174                                                                                   binary);
5175
5176         goto finish;
5177
5178 finish:
5179         _COREGL_TRACEPATH_FUNC_END();
5180 }
5181
5182 void
5183 tracepath_glProgramBinary(GLuint program, GLenum binaryFormat,
5184                                                   const GLvoid *binary, GLsizei length)
5185 {
5186         _COREGL_TRACEPATH_FUNC_BEGIN();
5187         _orig_tracepath_glProgramBinary(program, binaryFormat, binary, length);
5188
5189         goto finish;
5190
5191 finish:
5192         _COREGL_TRACEPATH_FUNC_END();
5193 }
5194
5195 void
5196 tracepath_glProgramBinaryOES(GLuint program, GLenum binaryFormat,
5197                                                          const GLvoid *binary, GLsizei length)
5198 {
5199         _COREGL_TRACEPATH_FUNC_BEGIN();
5200         _orig_tracepath_glProgramBinaryOES(program, binaryFormat, binary, length);
5201
5202         goto finish;
5203
5204 finish:
5205         _COREGL_TRACEPATH_FUNC_END();
5206 }
5207
5208 void
5209 tracepath_glProgramParameteri(GLuint program, GLenum pname, GLint value)
5210 {
5211         _COREGL_TRACEPATH_FUNC_BEGIN();
5212         _orig_tracepath_glProgramParameteri(program, pname, value);
5213
5214         goto finish;
5215
5216 finish:
5217         _COREGL_TRACEPATH_FUNC_END();
5218 }
5219
5220 void
5221 tracepath_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
5222                                                                   const GLenum *attachments)
5223 {
5224         _COREGL_TRACEPATH_FUNC_BEGIN();
5225         _orig_tracepath_glInvalidateFramebuffer(target, numAttachments, attachments);
5226
5227         goto finish;
5228
5229 finish:
5230         _COREGL_TRACEPATH_FUNC_END();
5231 }
5232
5233 void
5234 tracepath_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments,
5235                                                                   const GLenum *attachments)
5236 {
5237         _COREGL_TRACEPATH_FUNC_BEGIN();
5238         _orig_tracepath_glDiscardFramebufferEXT(target, numAttachments, attachments);
5239
5240         goto finish;
5241
5242 finish:
5243         _COREGL_TRACEPATH_FUNC_END();
5244 }
5245
5246 void
5247 tracepath_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
5248                                                                          const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
5249 {
5250         _COREGL_TRACEPATH_FUNC_BEGIN();
5251         _orig_tracepath_glInvalidateSubFramebuffer(target, numAttachments, attachments,
5252                         x, y, width, height);
5253
5254         goto finish;
5255
5256 finish:
5257         _COREGL_TRACEPATH_FUNC_END();
5258 }
5259
5260 void
5261 tracepath_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
5262                                                  GLsizei width, GLsizei height)
5263 {
5264         _COREGL_TRACEPATH_FUNC_BEGIN();
5265         _orig_tracepath_glTexStorage2D(target, levels, internalformat, width, height);
5266
5267         goto finish;
5268
5269 finish:
5270         _COREGL_TRACEPATH_FUNC_END();
5271 }
5272
5273 void
5274 tracepath_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
5275                                                  GLsizei width, GLsizei height, GLsizei depth)
5276 {
5277         _COREGL_TRACEPATH_FUNC_BEGIN();
5278         _orig_tracepath_glTexStorage3D(target, levels, internalformat, width, height,
5279                                                                    depth);
5280
5281         goto finish;
5282
5283 finish:
5284         _COREGL_TRACEPATH_FUNC_END();
5285 }
5286
5287 void
5288 tracepath_glGetInternalformativ(GLenum target, GLenum internalformat,
5289                                                                 GLenum pname, GLsizei bufSize, GLint *params)
5290 {
5291         _COREGL_TRACEPATH_FUNC_BEGIN();
5292         _orig_tracepath_glGetInternalformativ(target, internalformat, pname, bufSize,
5293                                                                                   params);
5294
5295         goto finish;
5296
5297 finish:
5298         _COREGL_TRACEPATH_FUNC_END();
5299 }
5300
5301
5302 /* GLES Extensions */
5303 void
5304 tracepath_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
5305 {
5306         _COREGL_TRACEPATH_FUNC_BEGIN();
5307         _COREGL_TRACE_SURFACE(0, 1, "TEXTURE2DOES");
5308         _orig_tracepath_glEGLImageTargetTexture2DOES(target, image);
5309         goto finish;
5310
5311 finish:
5312         _COREGL_TRACEPATH_FUNC_END();
5313 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5314         if (get_trace_mem_flag() == 1) {
5315                 MY_MODULE_TSTATE* tstate = _get_my_state();
5316                 if (tstate && tstate->ctx != NULL) {
5317                         int objidx = _COREGL_INT_INIT_VALUE;
5318                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
5319                         AST(objidx != _COREGL_INT_INIT_VALUE);
5320
5321                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", 0, 0, 0,
5322                                                           "Unknown");
5323                 }
5324         }
5325 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5326 }
5327
5328 void
5329 tracepath_glEGLImageTargetRenderbufferStorageOES(GLenum target,
5330                 GLeglImageOES image)
5331 {
5332         _COREGL_TRACEPATH_FUNC_BEGIN();
5333         _orig_tracepath_glEGLImageTargetRenderbufferStorageOES(target, image);
5334         goto finish;
5335
5336 finish:
5337         _COREGL_TRACEPATH_FUNC_END();
5338 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5339         if (get_trace_mem_flag() == 1) {
5340                 MY_MODULE_TSTATE* tstate = _get_my_state();
5341                 if (tstate && tstate->ctx != NULL) {
5342                         int objidx = _COREGL_INT_INIT_VALUE;
5343                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
5344                         AST(objidx != _COREGL_INT_INIT_VALUE);
5345
5346                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", 0, 0,
5347                                                           0, "Unknown");
5348                 }
5349         }
5350 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5351 }
5352
5353 void
5354 tracepath_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages,
5355                                                                 GLuint program)
5356 {
5357         _COREGL_TRACEPATH_FUNC_BEGIN();
5358         _orig_tracepath_glUseProgramStagesEXT(pipeline, stages, program);
5359
5360         goto finish;
5361
5362 finish:
5363         _COREGL_TRACEPATH_FUNC_END();
5364 }
5365
5366 void
5367 tracepath_glActiveShaderProgramEXT(GLuint pipeline, GLuint program)
5368 {
5369         _COREGL_TRACEPATH_FUNC_BEGIN();
5370         _orig_tracepath_glActiveShaderProgramEXT(pipeline, program);
5371
5372         goto finish;
5373
5374 finish:
5375         _COREGL_TRACEPATH_FUNC_END();
5376 }
5377
5378 GLuint
5379 tracepath_glCreateShaderProgramvEXT(GLenum type, GLsizei count,
5380                                                                         const char **strings)
5381 {
5382         GLuint ret = _COREGL_INT_INIT_VALUE;
5383
5384         _COREGL_TRACEPATH_FUNC_BEGIN();
5385         ret = _orig_tracepath_glCreateShaderProgramvEXT(type, count, strings);
5386
5387         goto finish;
5388
5389 finish:
5390         _COREGL_TRACEPATH_FUNC_END();
5391         return ret;
5392 }
5393
5394 void
5395 tracepath_glBindProgramPipelineEXT(GLuint pipeline)
5396 {
5397         _COREGL_TRACEPATH_FUNC_BEGIN();
5398         _orig_tracepath_glBindProgramPipelineEXT(pipeline);
5399
5400         goto finish;
5401
5402 finish:
5403         _COREGL_TRACEPATH_FUNC_END();
5404 }
5405
5406 void
5407 tracepath_glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
5408 {
5409         _COREGL_TRACEPATH_FUNC_BEGIN();
5410         _orig_tracepath_glDeleteProgramPipelinesEXT(n, pipelines);
5411
5412         goto finish;
5413
5414 finish:
5415         _COREGL_TRACEPATH_FUNC_END();
5416 }
5417
5418 void
5419 tracepath_glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
5420 {
5421         _COREGL_TRACEPATH_FUNC_BEGIN();
5422         _orig_tracepath_glGenProgramPipelinesEXT(n, pipelines);
5423
5424         goto finish;
5425
5426 finish:
5427         _COREGL_TRACEPATH_FUNC_END();
5428 }
5429
5430 GLboolean
5431 tracepath_glIsProgramPipelineEXT(GLuint pipeline)
5432 {
5433         GLboolean ret = _COREGL_INT_INIT_VALUE;
5434
5435         _COREGL_TRACEPATH_FUNC_BEGIN();
5436         ret = _orig_tracepath_glIsProgramPipelineEXT(pipeline);
5437
5438         goto finish;
5439
5440 finish:
5441         _COREGL_TRACEPATH_FUNC_END();
5442         return ret;
5443 }
5444
5445 void
5446 tracepath_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
5447 {
5448         _COREGL_TRACEPATH_FUNC_BEGIN();
5449         _orig_tracepath_glProgramParameteriEXT(program, pname, value);
5450
5451         goto finish;
5452
5453 finish:
5454         _COREGL_TRACEPATH_FUNC_END();
5455 }
5456
5457 void
5458 tracepath_glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname,
5459                                                                         GLint *params)
5460 {
5461         _COREGL_TRACEPATH_FUNC_BEGIN();
5462         _orig_tracepath_glGetProgramPipelineivEXT(pipeline, pname, params);
5463
5464         goto finish;
5465
5466 finish:
5467         _COREGL_TRACEPATH_FUNC_END();
5468 }
5469
5470 void
5471 tracepath_glProgramUniform1iEXT(GLuint program, GLint location, GLint x)
5472 {
5473         _COREGL_TRACEPATH_FUNC_BEGIN();
5474         _orig_tracepath_glProgramUniform1iEXT(program, location, x);
5475
5476         goto finish;
5477
5478 finish:
5479         _COREGL_TRACEPATH_FUNC_END();
5480 }
5481
5482 void
5483 tracepath_glProgramUniform2iEXT(GLuint program, GLint location, GLint x,
5484                                                                 GLint y)
5485 {
5486         _COREGL_TRACEPATH_FUNC_BEGIN();
5487         _orig_tracepath_glProgramUniform2iEXT(program, location, x, y);
5488
5489         goto finish;
5490
5491 finish:
5492         _COREGL_TRACEPATH_FUNC_END();
5493 }
5494
5495 void
5496 tracepath_glProgramUniform3iEXT(GLuint program, GLint location, GLint x,
5497                                                                 GLint y, GLint z)
5498 {
5499         _COREGL_TRACEPATH_FUNC_BEGIN();
5500         _orig_tracepath_glProgramUniform3iEXT(program, location, x, y, z);
5501
5502         goto finish;
5503
5504 finish:
5505         _COREGL_TRACEPATH_FUNC_END();
5506 }
5507
5508 void
5509 tracepath_glProgramUniform4iEXT(GLuint program, GLint location, GLint x,
5510                                                                 GLint y, GLint z, GLint w)
5511 {
5512         _COREGL_TRACEPATH_FUNC_BEGIN();
5513         _orig_tracepath_glProgramUniform4iEXT(program, location, x, y, z, w);
5514
5515         goto finish;
5516
5517 finish:
5518         _COREGL_TRACEPATH_FUNC_END();
5519 }
5520
5521 void
5522 tracepath_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat x)
5523 {
5524         _COREGL_TRACEPATH_FUNC_BEGIN();
5525         _orig_tracepath_glProgramUniform1fEXT(program, location, x);
5526
5527         goto finish;
5528
5529 finish:
5530         _COREGL_TRACEPATH_FUNC_END();
5531 }
5532
5533 void
5534 tracepath_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x,
5535                                                                 GLfloat y)
5536 {
5537         _COREGL_TRACEPATH_FUNC_BEGIN();
5538         _orig_tracepath_glProgramUniform2fEXT(program, location, x, y);
5539
5540         goto finish;
5541
5542 finish:
5543         _COREGL_TRACEPATH_FUNC_END();
5544 }
5545
5546 void
5547 tracepath_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x,
5548                                                                 GLfloat y, GLfloat z)
5549 {
5550         _COREGL_TRACEPATH_FUNC_BEGIN();
5551         _orig_tracepath_glProgramUniform3fEXT(program, location, x, y, z);
5552
5553         goto finish;
5554
5555 finish:
5556         _COREGL_TRACEPATH_FUNC_END();
5557 }
5558
5559 void
5560 tracepath_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x,
5561                                                                 GLfloat y, GLfloat z, GLfloat w)
5562 {
5563         _COREGL_TRACEPATH_FUNC_BEGIN();
5564         _orig_tracepath_glProgramUniform4fEXT(program, location, x, y, z, w);
5565
5566         goto finish;
5567
5568 finish:
5569         _COREGL_TRACEPATH_FUNC_END();
5570 }
5571
5572 void
5573 tracepath_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count,
5574                                                                  const GLint *value)
5575 {
5576         _COREGL_TRACEPATH_FUNC_BEGIN();
5577         _orig_tracepath_glProgramUniform1ivEXT(program, location, count, value);
5578
5579         goto finish;
5580
5581 finish:
5582         _COREGL_TRACEPATH_FUNC_END();
5583 }
5584
5585 void
5586 tracepath_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count,
5587                                                                  const GLint *value)
5588 {
5589         _COREGL_TRACEPATH_FUNC_BEGIN();
5590         _orig_tracepath_glProgramUniform2ivEXT(program, location, count, value);
5591
5592         goto finish;
5593
5594 finish:
5595         _COREGL_TRACEPATH_FUNC_END();
5596 }
5597
5598 void
5599 tracepath_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count,
5600                                                                  const GLint *value)
5601 {
5602         _COREGL_TRACEPATH_FUNC_BEGIN();
5603         _orig_tracepath_glProgramUniform3ivEXT(program, location, count, value);
5604
5605         goto finish;
5606
5607 finish:
5608         _COREGL_TRACEPATH_FUNC_END();
5609 }
5610
5611 void
5612 tracepath_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count,
5613                                                                  const GLint *value)
5614 {
5615         _COREGL_TRACEPATH_FUNC_BEGIN();
5616         _orig_tracepath_glProgramUniform4ivEXT(program, location, count, value);
5617
5618         goto finish;
5619
5620 finish:
5621         _COREGL_TRACEPATH_FUNC_END();
5622 }
5623
5624 void
5625 tracepath_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count,
5626                                                                  const GLfloat *value)
5627 {
5628         _COREGL_TRACEPATH_FUNC_BEGIN();
5629         _orig_tracepath_glProgramUniform1fvEXT(program, location, count, value);
5630
5631         goto finish;
5632
5633 finish:
5634         _COREGL_TRACEPATH_FUNC_END();
5635 }
5636
5637 void
5638 tracepath_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count,
5639                                                                  const GLfloat *value)
5640 {
5641         _COREGL_TRACEPATH_FUNC_BEGIN();
5642         _orig_tracepath_glProgramUniform2fvEXT(program, location, count, value);
5643
5644         goto finish;
5645
5646 finish:
5647         _COREGL_TRACEPATH_FUNC_END();
5648 }
5649
5650 void
5651 tracepath_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count,
5652                                                                  const GLfloat *value)
5653 {
5654         _COREGL_TRACEPATH_FUNC_BEGIN();
5655         _orig_tracepath_glProgramUniform3fvEXT(program, location, count, value);
5656
5657         goto finish;
5658
5659 finish:
5660         _COREGL_TRACEPATH_FUNC_END();
5661 }
5662
5663 void
5664 tracepath_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count,
5665                                                                  const GLfloat *value)
5666 {
5667         _COREGL_TRACEPATH_FUNC_BEGIN();
5668         _orig_tracepath_glProgramUniform4fvEXT(program, location, count, value);
5669
5670         goto finish;
5671
5672 finish:
5673         _COREGL_TRACEPATH_FUNC_END();
5674 }
5675
5676 void
5677 tracepath_glProgramUniformMatrix2fvEXT(GLuint program, GLint location,
5678                                                                            GLsizei count, GLboolean transpose, const GLfloat *value)
5679 {
5680         _COREGL_TRACEPATH_FUNC_BEGIN();
5681         _orig_tracepath_glProgramUniformMatrix2fvEXT(program, location, count,
5682                         transpose, value);
5683
5684         goto finish;
5685
5686 finish:
5687         _COREGL_TRACEPATH_FUNC_END();
5688 }
5689
5690 void
5691 tracepath_glProgramUniformMatrix3fvEXT(GLuint program, GLint location,
5692                                                                            GLsizei count, GLboolean transpose, const GLfloat *value)
5693 {
5694         _COREGL_TRACEPATH_FUNC_BEGIN();
5695         _orig_tracepath_glProgramUniformMatrix3fvEXT(program, location, count,
5696                         transpose, value);
5697
5698         goto finish;
5699
5700 finish:
5701         _COREGL_TRACEPATH_FUNC_END();
5702 }
5703
5704 void
5705 tracepath_glProgramUniformMatrix4fvEXT(GLuint program, GLint location,
5706                                                                            GLsizei count, GLboolean transpose, const GLfloat *value)
5707 {
5708         _COREGL_TRACEPATH_FUNC_BEGIN();
5709         _orig_tracepath_glProgramUniformMatrix4fvEXT(program, location, count,
5710                         transpose, value);
5711
5712         goto finish;
5713
5714 finish:
5715         _COREGL_TRACEPATH_FUNC_END();
5716 }
5717
5718 void
5719 tracepath_glValidateProgramPipelineEXT(GLuint pipeline)
5720 {
5721         _COREGL_TRACEPATH_FUNC_BEGIN();
5722         _orig_tracepath_glValidateProgramPipelineEXT(pipeline);
5723
5724         goto finish;
5725
5726 finish:
5727         _COREGL_TRACEPATH_FUNC_END();
5728 }
5729
5730 void
5731 tracepath_glGetProgramPipelineInfoLogEXT(GLuint pipeline, GLsizei bufSize,
5732                 GLsizei *length, char *infoLog)
5733 {
5734         _COREGL_TRACEPATH_FUNC_BEGIN();
5735         _orig_tracepath_glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length,
5736                         infoLog);
5737
5738         goto finish;
5739
5740 finish:
5741         _COREGL_TRACEPATH_FUNC_END();
5742 }
5743
5744
5745 void
5746 tracepath_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment,
5747                 GLenum textarget, GLuint texture, GLint level, GLsizei samples)
5748 {
5749         _COREGL_TRACEPATH_FUNC_BEGIN();
5750
5751 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5752         tracepath_fbdump_update(0);
5753 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5754
5755         _orig_tracepath_glFramebufferTexture2DMultisampleEXT(target, attachment,
5756                         textarget, texture, level, samples);
5757
5758 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5759         tracepath_fbdump_update(1);
5760 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5761
5762         goto finish;
5763
5764 finish:
5765         _COREGL_TRACEPATH_FUNC_END();
5766 }
5767
5768 void
5769 tracepath_glFramebufferTexture3DOES(GLenum target, GLenum attachment,
5770                                                                         GLenum textarget, GLuint texture, GLint level, GLint zoffset)
5771 {
5772         _COREGL_TRACEPATH_FUNC_BEGIN();
5773         _orig_tracepath_glFramebufferTexture3DOES(target, attachment, textarget,
5774                         texture, level, zoffset);
5775
5776         goto finish;
5777
5778 finish:
5779         _COREGL_TRACEPATH_FUNC_END();
5780 }
5781 /*
5782 void
5783 tracepath_glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
5784 {
5785         _COREGL_TRACEPATH_FUNC_BEGIN();
5786         _orig_tracepath_glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
5787
5788         goto finish;
5789
5790 finish:
5791         _COREGL_TRACEPATH_FUNC_END();
5792 }
5793
5794 void
5795 tracepath_glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
5796 {
5797         _COREGL_TRACEPATH_FUNC_BEGIN();
5798
5799         _orig_tracepath_glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
5800
5801         goto finish;
5802
5803 finish:
5804         _COREGL_TRACEPATH_FUNC_END();
5805 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5806         if (trace_mem_flag == 1)
5807         {
5808                 MY_MODULE_TSTATE *tstate = NULL;
5809
5810                 GET_MY_TSTATE(tstate, get_current_thread_state());
5811                 AST(tstate != NULL);
5812                 if (tstate->ctx != NULL)
5813                 {
5814                         int objidx = _COREGL_INT_INIT_VALUE;
5815                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
5816                         AST(objidx != _COREGL_INT_INIT_VALUE);
5817
5818                         // Detect byte per pixel
5819                         int bpp = 0;
5820                         char formatment[80];
5821                         switch (internalformat)
5822                         {
5823                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
5824                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
5825                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
5826                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
5827                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
5828                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
5829                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
5830                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
5831                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
5832                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
5833                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
5834                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
5835                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
5836                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
5837                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
5838                         }
5839
5840                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
5841                 }
5842         }
5843 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5844 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5845         if (trace_surface_flag == 1)
5846         {
5847                 MY_MODULE_TSTATE *tstate = NULL;
5848
5849                 GET_MY_TSTATE(tstate, get_current_thread_state());
5850                 AST(tstate != NULL);
5851                 if (tstate->ctx != NULL)
5852                 {
5853                         int objidx = _COREGL_INT_INIT_VALUE;
5854                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
5855                         AST(objidx != _COREGL_INT_INIT_VALUE);
5856
5857                         {
5858                                 int channel = 0;
5859                                 switch (internalformat)
5860                                 {
5861                                         case GL_ALPHA:
5862                                         case GL_LUMINANCE:
5863                                         case GL_DEPTH_COMPONENT :
5864                                         case 0x81A5:
5865                                         case 0x81A6:
5866                                         case 0x81A7:
5867                                         case 0x8D46 :
5868                                         case 0x8D47 :
5869                                         case 0x8D48 : channel = 1; break;
5870                                         case GL_LUMINANCE_ALPHA:
5871                                         case 0x84F9: channel = 2; break;
5872                                         case GL_RGB: channel = 3; break;
5873                                         case GL_RGBA:
5874                                         case 0x80E1: channel = 4; break;
5875                                 }
5876
5877                                 char name[256];
5878                                 sprintf(name, "FBORB_%d", objidx);
5879                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
5880                         }
5881                 }
5882         }
5883 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5884 }
5885 */
5886
5887
5888 void
5889 tracepath_glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid **params)
5890 {
5891         _COREGL_TRACEPATH_FUNC_BEGIN();
5892         _orig_tracepath_glGetBufferPointervOES(target, pname, params);
5893
5894         goto finish;
5895
5896 finish:
5897         _COREGL_TRACEPATH_FUNC_END();
5898 }
5899
5900
5901 void *
5902 tracepath_glMapBufferOES(GLenum target, GLenum access)
5903 {
5904         void *ret = NULL;
5905
5906         _COREGL_TRACEPATH_FUNC_BEGIN();
5907         ret = _orig_tracepath_glMapBufferOES(target, access);
5908
5909         goto finish;
5910
5911 finish:
5912         _COREGL_TRACEPATH_FUNC_END();
5913         return ret;
5914 }
5915
5916
5917 GLboolean
5918 tracepath_glUnmapBufferOES(GLenum target)
5919 {
5920         GLboolean ret = GL_FALSE;
5921
5922         _COREGL_TRACEPATH_FUNC_BEGIN();
5923         ret = _orig_tracepath_glUnmapBufferOES(target);
5924
5925         goto finish;
5926
5927 finish:
5928         _COREGL_TRACEPATH_FUNC_END();
5929         return ret;
5930 }
5931
5932 /* GLES3.1 API */
5933 void
5934 tracepath_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
5935                                                                           GLsizei *length, GLchar *infoLog)
5936 {
5937         _COREGL_TRACEPATH_FUNC_BEGIN();
5938         _orig_tracepath_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
5939
5940         goto finish;
5941
5942 finish:
5943         _COREGL_TRACEPATH_FUNC_END();
5944 }
5945
5946 GLuint
5947 tracepath_glCreateShaderProgramv(GLenum type,  GLsizei count,
5948                                                                  const GLchar *const *strings)
5949 {
5950         GLboolean ret = GL_FALSE;
5951         _COREGL_TRACEPATH_FUNC_BEGIN();
5952         ret = _orig_tracepath_glCreateShaderProgramv(type, count, strings);
5953
5954         goto finish;
5955
5956 finish:
5957         _COREGL_TRACEPATH_FUNC_END();
5958         return ret;
5959 }
5960
5961 void
5962 tracepath_glGenProgramPipelines( GLsizei n,  GLuint *pipelines)
5963 {
5964         _COREGL_TRACEPATH_FUNC_BEGIN();
5965         _orig_tracepath_glGenProgramPipelines(n, pipelines);
5966
5967         goto finish;
5968
5969 finish:
5970         _COREGL_TRACEPATH_FUNC_END();
5971 }
5972
5973 void
5974 tracepath_glBindProgramPipeline( GLuint pipeline)
5975 {
5976         _COREGL_TRACEPATH_FUNC_BEGIN();
5977         _orig_tracepath_glBindProgramPipeline(pipeline);
5978
5979         goto finish;
5980
5981 finish:
5982         _COREGL_TRACEPATH_FUNC_END();
5983 }
5984
5985 void
5986 tracepath_glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
5987 {
5988         _COREGL_TRACEPATH_FUNC_BEGIN();
5989         _orig_tracepath_glGetProgramPipelineiv(pipeline, pname, params);
5990
5991         goto finish;
5992
5993 finish:
5994         _COREGL_TRACEPATH_FUNC_END();
5995 }
5996
5997 void
5998 tracepath_glDeleteProgramPipelines(GLsizei n, GLuint const *pipelines)
5999 {
6000         _COREGL_TRACEPATH_FUNC_BEGIN();
6001         _orig_tracepath_glDeleteProgramPipelines(n, pipelines);
6002
6003         goto finish;
6004
6005 finish:
6006         _COREGL_TRACEPATH_FUNC_END();
6007 }
6008
6009 GLboolean
6010 tracepath_glIsProgramPipeline( GLuint pipeline)
6011 {
6012         GLboolean ret = GL_FALSE;
6013
6014         _COREGL_TRACEPATH_FUNC_BEGIN();
6015         ret = _orig_tracepath_glIsProgramPipeline(pipeline);
6016
6017         goto finish;
6018
6019 finish:
6020         _COREGL_TRACEPATH_FUNC_END();
6021         return ret;
6022 }
6023
6024 void
6025 tracepath_glValidateProgramPipeline(GLuint pipeline)
6026 {
6027         _COREGL_TRACEPATH_FUNC_BEGIN();
6028         _orig_tracepath_glValidateProgramPipeline(pipeline);
6029
6030         goto finish;
6031
6032 finish:
6033         _COREGL_TRACEPATH_FUNC_END();
6034 }
6035
6036 void
6037 tracepath_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
6038                                                         GLuint num_groups_z)
6039 {
6040         _COREGL_TRACEPATH_FUNC_BEGIN();
6041         _orig_tracepath_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
6042
6043         goto finish;
6044
6045 finish:
6046         _COREGL_TRACEPATH_FUNC_END();
6047 }
6048
6049 void
6050 tracepath_glDispatchComputeIndirect( GLintptr indirect)
6051 {
6052         _COREGL_TRACEPATH_FUNC_BEGIN();
6053         _orig_tracepath_glDispatchComputeIndirect(indirect);
6054
6055         goto finish;
6056
6057 finish:
6058         _COREGL_TRACEPATH_FUNC_END();
6059 }
6060
6061 void
6062 tracepath_glDrawArraysIndirect(GLenum mode, GLvoid const *indirect)
6063 {
6064         _COREGL_TRACEPATH_FUNC_BEGIN();
6065         _orig_tracepath_glDrawArraysIndirect(mode, indirect);
6066
6067         goto finish;
6068
6069 finish:
6070         _COREGL_TRACEPATH_FUNC_END();
6071 }
6072
6073 void
6074 tracepath_glDrawElementsIndirect(GLenum mode, GLenum type,
6075                                                                  GLvoid const *indirect)
6076 {
6077         _COREGL_TRACEPATH_FUNC_BEGIN();
6078         _orig_tracepath_glDrawElementsIndirect(mode, type, indirect);
6079
6080         goto finish;
6081
6082 finish:
6083         _COREGL_TRACEPATH_FUNC_END();
6084 }
6085
6086 void
6087 tracepath_glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
6088 {
6089         _COREGL_TRACEPATH_FUNC_BEGIN();
6090         _orig_tracepath_glFramebufferParameteri(target, pname, param);
6091
6092         goto finish;
6093
6094 finish:
6095         _COREGL_TRACEPATH_FUNC_END();
6096 }
6097
6098 void
6099 tracepath_glGetFramebufferParameteriv( GLenum target,  GLenum pname,
6100                                                                            GLint *params)
6101 {
6102         _COREGL_TRACEPATH_FUNC_BEGIN();
6103         _orig_tracepath_glGetFramebufferParameteriv(target,  pname,  params);
6104
6105         goto finish;
6106
6107 finish:
6108         _COREGL_TRACEPATH_FUNC_END();
6109 }
6110
6111 void
6112 tracepath_glGetProgramInterfaceiv(GLuint program,  GLenum programInterface,
6113                                                                   GLenum pname,  GLint *params)
6114 {
6115         _COREGL_TRACEPATH_FUNC_BEGIN();
6116         _orig_tracepath_glGetProgramInterfaceiv(program, programInterface, pname,
6117                                                                                         params);
6118
6119         goto finish;
6120
6121 finish:
6122         _COREGL_TRACEPATH_FUNC_END();
6123 }
6124
6125 GLuint
6126 tracepath_glGetProgramResourceIndex( GLuint program,  GLenum programInterface,
6127                                                                          const char *name)
6128 {
6129         GLuint ret = GL_INVALID_INDEX;
6130         _COREGL_TRACEPATH_FUNC_BEGIN();
6131         ret =  _orig_tracepath_glGetProgramResourceIndex(program,  programInterface,
6132                         name);
6133
6134         goto finish;
6135
6136 finish:
6137         _COREGL_TRACEPATH_FUNC_END();
6138         return ret;
6139 }
6140
6141 void
6142 tracepath_glGetProgramResourceName(GLuint program, GLenum programInterface,
6143                                                                    GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
6144 {
6145         _COREGL_TRACEPATH_FUNC_BEGIN();
6146
6147         _orig_tracepath_glGetProgramResourceName(program, programInterface, index,
6148                         bufSize, length, name);
6149
6150         goto finish;
6151
6152 finish:
6153         _COREGL_TRACEPATH_FUNC_END();
6154 }
6155
6156 void
6157 tracepath_glGetProgramResourceiv( GLuint program,  GLenum programInterface,
6158                                                                   GLuint index,  GLsizei propCount,  const GLenum *props,  GLsizei bufSize,
6159                                                                   GLsizei *length,  GLint *params)
6160 {
6161         _COREGL_TRACEPATH_FUNC_BEGIN();
6162
6163         _orig_tracepath_glGetProgramResourceiv(program,  programInterface,  index,
6164                                                                                    propCount,  props,  bufSize,  length,  params);
6165
6166         goto finish;
6167
6168 finish:
6169         _COREGL_TRACEPATH_FUNC_END();
6170 }
6171
6172 GLint
6173 tracepath_glGetProgramResourceLocation(GLuint program, GLenum programInterface,
6174                                                                            GLchar const *name)
6175 {
6176         GLuint ret = -1;
6177         _COREGL_TRACEPATH_FUNC_BEGIN();
6178
6179         ret = _orig_tracepath_glGetProgramResourceLocation(program, programInterface,
6180                         name);
6181
6182         goto finish;
6183
6184 finish:
6185         _COREGL_TRACEPATH_FUNC_END();
6186         return ret;
6187 }
6188
6189 void
6190 tracepath_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
6191 {
6192         _COREGL_TRACEPATH_FUNC_BEGIN();
6193         _orig_tracepath_glUseProgramStages(pipeline, stages, program);
6194
6195         goto finish;
6196
6197 finish:
6198         _COREGL_TRACEPATH_FUNC_END();
6199 }
6200
6201 void
6202 tracepath_glActiveShaderProgram(GLuint pipeline, GLuint program)
6203 {
6204         _COREGL_TRACEPATH_FUNC_BEGIN();
6205         _orig_tracepath_glActiveShaderProgram(pipeline, program);
6206
6207         goto finish;
6208
6209 finish:
6210         _COREGL_TRACEPATH_FUNC_END();
6211 }
6212
6213 void
6214 tracepath_glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
6215                                                           const GLint *value)
6216 {
6217         _COREGL_TRACEPATH_FUNC_BEGIN();
6218         _orig_tracepath_glProgramUniform1iv(program, location, count, value);
6219
6220         goto finish;
6221
6222 finish:
6223         _COREGL_TRACEPATH_FUNC_END();
6224 }
6225
6226 void
6227 tracepath_glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
6228                                                           const GLint *value)
6229 {
6230         _COREGL_TRACEPATH_FUNC_BEGIN();
6231         _orig_tracepath_glProgramUniform2iv(program, location, count, value);
6232
6233         goto finish;
6234
6235 finish:
6236         _COREGL_TRACEPATH_FUNC_END();
6237 }
6238
6239 void
6240 tracepath_glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
6241                                                           const GLint *value)
6242 {
6243         _COREGL_TRACEPATH_FUNC_BEGIN();
6244         _orig_tracepath_glProgramUniform3iv(program, location, count, value);
6245
6246         goto finish;
6247
6248 finish:
6249         _COREGL_TRACEPATH_FUNC_END();
6250 }
6251
6252 void
6253 tracepath_glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
6254                                                           const GLint *value)
6255 {
6256         _COREGL_TRACEPATH_FUNC_BEGIN();
6257         _orig_tracepath_glProgramUniform4iv(program, location, count, value);
6258
6259         goto finish;
6260
6261 finish:
6262         _COREGL_TRACEPATH_FUNC_END();
6263 }
6264
6265 void
6266 tracepath_glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
6267                                                           const GLfloat *value)
6268 {
6269         _COREGL_TRACEPATH_FUNC_BEGIN();
6270         _orig_tracepath_glProgramUniform1fv(program, location, count, value);
6271
6272         goto finish;
6273
6274 finish:
6275         _COREGL_TRACEPATH_FUNC_END();
6276 }
6277
6278 void
6279 tracepath_glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
6280                                                           const GLfloat *value)
6281 {
6282         _COREGL_TRACEPATH_FUNC_BEGIN();
6283         _orig_tracepath_glProgramUniform2fv(program, location, count, value);
6284
6285         goto finish;
6286
6287 finish:
6288         _COREGL_TRACEPATH_FUNC_END();
6289 }
6290
6291 void
6292 tracepath_glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
6293                                                           const GLfloat *value)
6294 {
6295         _COREGL_TRACEPATH_FUNC_BEGIN();
6296         _orig_tracepath_glProgramUniform3fv(program, location, count, value);
6297
6298         goto finish;
6299
6300 finish:
6301         _COREGL_TRACEPATH_FUNC_END();
6302 }
6303
6304 void
6305 tracepath_glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
6306                                                           const GLfloat *value)
6307 {
6308         _COREGL_TRACEPATH_FUNC_BEGIN();
6309         _orig_tracepath_glProgramUniform4fv(program, location, count, value);
6310
6311         goto finish;
6312
6313 finish:
6314         _COREGL_TRACEPATH_FUNC_END();
6315 }
6316
6317 void
6318 tracepath_glProgramUniformMatrix2fv(GLuint program, GLint location,
6319                                                                         GLsizei count, GLboolean transpose, const GLfloat *value)
6320 {
6321         _COREGL_TRACEPATH_FUNC_BEGIN();
6322         _orig_tracepath_glProgramUniformMatrix2fv(program, location, count, transpose,
6323                         value);
6324
6325         goto finish;
6326
6327 finish:
6328         _COREGL_TRACEPATH_FUNC_END();
6329 }
6330
6331 void
6332 tracepath_glProgramUniformMatrix3fv(GLuint program, GLint location,
6333                                                                         GLsizei count, GLboolean transpose, const GLfloat *value)
6334 {
6335         _COREGL_TRACEPATH_FUNC_BEGIN();
6336         _orig_tracepath_glProgramUniformMatrix3fv(program, location, count, transpose,
6337                         value);
6338
6339         goto finish;
6340
6341 finish:
6342         _COREGL_TRACEPATH_FUNC_END();
6343 }
6344
6345 void
6346 tracepath_glProgramUniformMatrix4fv(GLuint program, GLint location,
6347                                                                         GLsizei count, GLboolean transpose, const GLfloat *value)
6348 {
6349         _COREGL_TRACEPATH_FUNC_BEGIN();
6350         _orig_tracepath_glProgramUniformMatrix4fv(program, location, count, transpose,
6351                         value);
6352
6353         goto finish;
6354
6355 finish:
6356         _COREGL_TRACEPATH_FUNC_END();
6357 }
6358
6359 void
6360 tracepath_glProgramUniform1i(GLuint program, GLint location, GLint x)
6361 {
6362         _COREGL_TRACEPATH_FUNC_BEGIN();
6363         _orig_tracepath_glProgramUniform1i(program, location, x);
6364
6365         goto finish;
6366
6367 finish:
6368         _COREGL_TRACEPATH_FUNC_END();
6369 }
6370
6371 void
6372 tracepath_glProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
6373 {
6374         _COREGL_TRACEPATH_FUNC_BEGIN();
6375         _orig_tracepath_glProgramUniform2i(program, location, x, y);
6376
6377         goto finish;
6378
6379 finish:
6380         _COREGL_TRACEPATH_FUNC_END();
6381 }
6382
6383 void
6384 tracepath_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y,
6385                                                          GLint z)
6386 {
6387         _COREGL_TRACEPATH_FUNC_BEGIN();
6388         _orig_tracepath_glProgramUniform3i(program, location, x, y, z);
6389
6390         goto finish;
6391
6392 finish:
6393         _COREGL_TRACEPATH_FUNC_END();
6394 }
6395
6396 void
6397 tracepath_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y,
6398                                                          GLint z, GLint w)
6399 {
6400         _COREGL_TRACEPATH_FUNC_BEGIN();
6401         _orig_tracepath_glProgramUniform4i(program, location, x, y, z, w);
6402
6403         goto finish;
6404
6405 finish:
6406         _COREGL_TRACEPATH_FUNC_END();
6407 }
6408
6409 void
6410 tracepath_glProgramUniform1f(GLuint program, GLint location, GLfloat x)
6411 {
6412         _COREGL_TRACEPATH_FUNC_BEGIN();
6413         _orig_tracepath_glProgramUniform1f(program, location, x);
6414
6415         goto finish;
6416
6417 finish:
6418         _COREGL_TRACEPATH_FUNC_END();
6419 }
6420
6421 void
6422 tracepath_glProgramUniform2f(GLuint program, GLint location, GLfloat x,
6423                                                          GLfloat y)
6424 {
6425         _COREGL_TRACEPATH_FUNC_BEGIN();
6426         _orig_tracepath_glProgramUniform2f(program, location, x, y);
6427
6428         goto finish;
6429
6430 finish:
6431         _COREGL_TRACEPATH_FUNC_END();
6432 }
6433
6434 void
6435 tracepath_glProgramUniform3f(GLuint program, GLint location, GLfloat x,
6436                                                          GLfloat y, GLfloat z)
6437 {
6438         _COREGL_TRACEPATH_FUNC_BEGIN();
6439         _orig_tracepath_glProgramUniform3f(program, location, x, y, z);
6440
6441         goto finish;
6442
6443 finish:
6444         _COREGL_TRACEPATH_FUNC_END();
6445 }
6446
6447 void
6448 tracepath_glProgramUniform4f(GLuint program, GLint location, GLfloat x,
6449                                                          GLfloat y, GLfloat z, GLfloat w)
6450 {
6451         _COREGL_TRACEPATH_FUNC_BEGIN();
6452         _orig_tracepath_glProgramUniform4f(program, location, x, y, z, w);
6453
6454         goto finish;
6455
6456 finish:
6457         _COREGL_TRACEPATH_FUNC_END();
6458 }
6459
6460 void
6461 tracepath_glProgramUniform1ui(GLuint program, GLint location, GLuint x)
6462 {
6463         _COREGL_TRACEPATH_FUNC_BEGIN();
6464         _orig_tracepath_glProgramUniform1ui(program, location, x);
6465
6466         goto finish;
6467
6468 finish:
6469         _COREGL_TRACEPATH_FUNC_END();
6470 }
6471
6472 void
6473 tracepath_glProgramUniform2ui(GLuint program, GLint location, GLuint x,
6474                                                           GLuint y)
6475 {
6476         _COREGL_TRACEPATH_FUNC_BEGIN();
6477         _orig_tracepath_glProgramUniform2ui(program, location, x, y);
6478
6479         goto finish;
6480
6481 finish:
6482         _COREGL_TRACEPATH_FUNC_END();
6483 }
6484
6485 void
6486 tracepath_glProgramUniform3ui(GLuint program, GLint location, GLuint x,
6487                                                           GLuint y, GLuint z)
6488 {
6489         _COREGL_TRACEPATH_FUNC_BEGIN();
6490         _orig_tracepath_glProgramUniform3ui(program, location, x, y, z);
6491
6492         goto finish;
6493
6494 finish:
6495         _COREGL_TRACEPATH_FUNC_END();
6496 }
6497
6498 void
6499 tracepath_glProgramUniform4ui(GLuint program, GLint location, GLuint x,
6500                                                           GLuint y, GLuint z, GLuint w)
6501 {
6502         _COREGL_TRACEPATH_FUNC_BEGIN();
6503         _orig_tracepath_glProgramUniform4ui(program, location, x, y, z, w);
6504
6505         goto finish;
6506
6507 finish:
6508         _COREGL_TRACEPATH_FUNC_END();
6509 }
6510
6511 void
6512 tracepath_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
6513                                                            const GLuint *value)
6514 {
6515         _COREGL_TRACEPATH_FUNC_BEGIN();
6516         _orig_tracepath_glProgramUniform1uiv(program, location, count, value);
6517
6518         goto finish;
6519
6520 finish:
6521         _COREGL_TRACEPATH_FUNC_END();
6522 }
6523
6524 void
6525 tracepath_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
6526                                                            const GLuint *value)
6527 {
6528         _COREGL_TRACEPATH_FUNC_BEGIN();
6529         _orig_tracepath_glProgramUniform2uiv(program, location, count, value);
6530
6531         goto finish;
6532
6533 finish:
6534         _COREGL_TRACEPATH_FUNC_END();
6535 }
6536
6537 void
6538 tracepath_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
6539                                                            const GLuint *value)
6540 {
6541         _COREGL_TRACEPATH_FUNC_BEGIN();
6542         _orig_tracepath_glProgramUniform3uiv(program, location, count, value);
6543
6544         goto finish;
6545
6546 finish:
6547         _COREGL_TRACEPATH_FUNC_END();
6548 }
6549
6550 void
6551 tracepath_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
6552                                                            const GLuint *value)
6553 {
6554         _COREGL_TRACEPATH_FUNC_BEGIN();
6555         _orig_tracepath_glProgramUniform4uiv(program, location, count, value);
6556
6557         goto finish;
6558
6559 finish:
6560         _COREGL_TRACEPATH_FUNC_END();
6561 }
6562
6563 void
6564 tracepath_glProgramUniformMatrix2x3fv(GLuint program, GLint location,
6565                                                                           GLsizei count, GLboolean transpose, const GLfloat *value)
6566 {
6567         _COREGL_TRACEPATH_FUNC_BEGIN();
6568         _orig_tracepath_glProgramUniformMatrix2x3fv(program, location, count, transpose,
6569                         value);
6570
6571         goto finish;
6572
6573 finish:
6574         _COREGL_TRACEPATH_FUNC_END();
6575 }
6576
6577 void
6578 tracepath_glProgramUniformMatrix3x2fv(GLuint program, GLint location,
6579                                                                           GLsizei count, GLboolean transpose, const GLfloat *value)
6580 {
6581         _COREGL_TRACEPATH_FUNC_BEGIN();
6582         _orig_tracepath_glProgramUniformMatrix3x2fv(program, location, count, transpose,
6583                         value);
6584
6585         goto finish;
6586
6587 finish:
6588         _COREGL_TRACEPATH_FUNC_END();
6589 }
6590
6591 void
6592 tracepath_glProgramUniformMatrix4x2fv(GLuint program, GLint location,
6593                                                                           GLsizei count, GLboolean transpose, const GLfloat *value)
6594 {
6595         _COREGL_TRACEPATH_FUNC_BEGIN();
6596         _orig_tracepath_glProgramUniformMatrix4x2fv(program, location, count, transpose,
6597                         value);
6598
6599         goto finish;
6600
6601 finish:
6602         _COREGL_TRACEPATH_FUNC_END();
6603 }
6604
6605 void
6606 tracepath_glProgramUniformMatrix2x4fv(GLuint program, GLint location,
6607                                                                           GLsizei count, GLboolean transpose, const GLfloat *value)
6608 {
6609         _COREGL_TRACEPATH_FUNC_BEGIN();
6610         _orig_tracepath_glProgramUniformMatrix2x4fv(program, location, count, transpose,
6611                         value);
6612
6613         goto finish;
6614
6615 finish:
6616         _COREGL_TRACEPATH_FUNC_END();
6617 }
6618
6619 void
6620 tracepath_glProgramUniformMatrix3x4fv(GLuint program, GLint location,
6621                                                                           GLsizei count, GLboolean transpose, const GLfloat *value)
6622 {
6623         _COREGL_TRACEPATH_FUNC_BEGIN();
6624         _orig_tracepath_glProgramUniformMatrix3x4fv(program, location, count, transpose,
6625                         value);
6626
6627         goto finish;
6628
6629 finish:
6630         _COREGL_TRACEPATH_FUNC_END();
6631 }
6632
6633 void
6634 tracepath_glProgramUniformMatrix4x3fv(GLuint program, GLint location,
6635                                                                           GLsizei count, GLboolean transpose, const GLfloat *value)
6636 {
6637         _COREGL_TRACEPATH_FUNC_BEGIN();
6638         _orig_tracepath_glProgramUniformMatrix4x3fv(program, location, count, transpose,
6639                         value);
6640
6641         goto finish;
6642
6643 finish:
6644         _COREGL_TRACEPATH_FUNC_END();
6645 }
6646
6647 void
6648 tracepath_glBindImageTexture(GLuint unit, GLuint texture, GLint level,
6649                                                          GLboolean layered, GLint layer, GLenum access, GLenum format)
6650 {
6651         _COREGL_TRACEPATH_FUNC_BEGIN();
6652
6653         _orig_tracepath_glBindImageTexture(unit, texture, level, layered, layer, access,
6654                                                                            format);
6655
6656         goto finish;
6657
6658 finish:
6659         _COREGL_TRACEPATH_FUNC_END();
6660 }
6661
6662 void
6663 tracepath_glGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
6664 {
6665         _COREGL_TRACEPATH_FUNC_BEGIN();
6666         _orig_tracepath_glGetBooleani_v (target, index, data);
6667
6668         goto finish;
6669
6670 finish:
6671         _COREGL_TRACEPATH_FUNC_END();
6672 }
6673
6674 void
6675 tracepath_glMemoryBarrier (GLbitfield barriers)
6676 {
6677         _COREGL_TRACEPATH_FUNC_BEGIN();
6678         _orig_tracepath_glMemoryBarrier (barriers);
6679
6680         goto finish;
6681
6682 finish:
6683         _COREGL_TRACEPATH_FUNC_END();
6684 }
6685
6686 void tracepath_glMemoryBarrierByRegion (GLbitfield barriers)
6687 {
6688         _COREGL_TRACEPATH_FUNC_BEGIN();
6689         _orig_tracepath_glMemoryBarrierByRegion (barriers);
6690
6691         goto finish;
6692
6693 finish:
6694         _COREGL_TRACEPATH_FUNC_END();
6695 }
6696
6697 void
6698 tracepath_glTexStorage2DMultisample (GLenum target, GLsizei samples,
6699                                                                          GLenum internalformat, GLsizei width, GLsizei height,
6700                                                                          GLboolean fixedsamplelocations)
6701 {
6702         _COREGL_TRACEPATH_FUNC_BEGIN();
6703         _orig_tracepath_glTexStorage2DMultisample (target, samples, internalformat,
6704                         width, height, fixedsamplelocations);
6705
6706         goto finish;
6707
6708 finish:
6709         _COREGL_TRACEPATH_FUNC_END();
6710 }
6711
6712 void
6713 tracepath_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
6714 {
6715         _COREGL_TRACEPATH_FUNC_BEGIN();
6716         _orig_tracepath_glGetMultisamplefv (pname, index, val);
6717
6718         goto finish;
6719
6720 finish:
6721         _COREGL_TRACEPATH_FUNC_END();
6722 }
6723
6724 void
6725 tracepath_glSampleMaski (GLuint maskNumber, GLbitfield mask)
6726 {
6727         _COREGL_TRACEPATH_FUNC_BEGIN();
6728         _orig_tracepath_glSampleMaski (maskNumber, mask);
6729
6730         goto finish;
6731
6732 finish:
6733         _COREGL_TRACEPATH_FUNC_END();
6734 }
6735
6736 void
6737 tracepath_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
6738                                                                         GLint *params)
6739 {
6740         _COREGL_TRACEPATH_FUNC_BEGIN();
6741         _orig_tracepath_glGetTexLevelParameteriv (target, level, pname, params);
6742
6743         goto finish;
6744
6745 finish:
6746         _COREGL_TRACEPATH_FUNC_END();
6747 }
6748
6749 void
6750 tracepath_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
6751                                                                         GLfloat *params)
6752 {
6753         _COREGL_TRACEPATH_FUNC_BEGIN();
6754         _orig_tracepath_glGetTexLevelParameterfv (target, level, pname, params);
6755
6756         goto finish;
6757
6758 finish:
6759         _COREGL_TRACEPATH_FUNC_END();
6760 }
6761
6762 void
6763 tracepath_glBindVertexBuffer (GLuint bindingindex, GLuint buffer,
6764                                                           GLintptr offset, GLsizei stride)
6765 {
6766         _COREGL_TRACEPATH_FUNC_BEGIN();
6767         _orig_tracepath_glBindVertexBuffer (bindingindex, buffer, offset, stride);
6768
6769         goto finish;
6770
6771 finish:
6772         _COREGL_TRACEPATH_FUNC_END();
6773 }
6774
6775
6776 void tracepath_glVertexAttribFormat (GLuint attribindex, GLint size,
6777                                                                          GLenum type, GLboolean normalized, GLuint relativeoffset)
6778 {
6779         _COREGL_TRACEPATH_FUNC_BEGIN();
6780         _orig_tracepath_glVertexAttribFormat (attribindex, size, type, normalized,
6781                                                                                   relativeoffset);
6782
6783         goto finish;
6784
6785 finish:
6786         _COREGL_TRACEPATH_FUNC_END();
6787 }
6788
6789 void tracepath_glVertexAttribIFormat (GLuint attribindex, GLint size,
6790                                                                           GLenum type, GLuint relativeoffset)
6791 {
6792         _COREGL_TRACEPATH_FUNC_BEGIN();
6793         _orig_tracepath_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
6794
6795         goto finish;
6796
6797 finish:
6798         _COREGL_TRACEPATH_FUNC_END();
6799 }
6800
6801 void tracepath_glVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
6802 {
6803         _COREGL_TRACEPATH_FUNC_BEGIN();
6804         _orig_tracepath_glVertexAttribBinding (attribindex, bindingindex);
6805
6806         goto finish;
6807
6808 finish:
6809         _COREGL_TRACEPATH_FUNC_END();
6810 }
6811
6812 void tracepath_glVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
6813 {
6814         _COREGL_TRACEPATH_FUNC_BEGIN();
6815         _orig_tracepath_glVertexBindingDivisor (bindingindex, divisor);
6816
6817         goto finish;
6818
6819 finish:
6820         _COREGL_TRACEPATH_FUNC_END();
6821 }
6822 void
6823 tracepath_glBindFramebufferOES(GLenum target, GLuint framebuffer)
6824 {
6825         _COREGL_TRACEPATH_FUNC_BEGIN();
6826
6827         _tp_glBindFramebuffer(target, framebuffer, TRACEPATH_FUNC_TYPE_OES);
6828
6829         _COREGL_TRACEPATH_FUNC_END();
6830 }
6831
6832 void
6833 tracepath_glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
6834 {
6835         _COREGL_TRACEPATH_FUNC_BEGIN();
6836         _orig_tracepath_glBindRenderbufferOES(target, renderbuffer);
6837
6838         goto finish;
6839
6840 finish:
6841         _COREGL_TRACEPATH_FUNC_END();
6842 }
6843
6844 void
6845 tracepath_glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
6846 {
6847         _COREGL_TRACEPATH_FUNC_BEGIN();
6848
6849 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
6850         tracepath_fbdump_update(0);
6851 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
6852
6853         _orig_tracepath_glDeleteFramebuffersOES(n, framebuffers);
6854
6855 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
6856         tracepath_fbdump_update(1);
6857 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
6858
6859         goto finish;
6860
6861 finish:
6862         _COREGL_TRACEPATH_FUNC_END();
6863 }
6864
6865 void
6866 tracepath_glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
6867 {
6868         _COREGL_TRACEPATH_FUNC_BEGIN();
6869
6870         _tp_glDeleteRenderbuffers(n, renderbuffers, TRACEPATH_FUNC_TYPE_OES);
6871
6872         _COREGL_TRACEPATH_FUNC_END();
6873 }
6874
6875 void
6876 tracepath_glDepthRangefOES(GLclampf zNear, GLclampf zFar)
6877 {
6878         _COREGL_TRACEPATH_FUNC_BEGIN();
6879         _orig_tracepath_glDepthRangefOES(zNear, zFar);
6880
6881         goto finish;
6882
6883 finish:
6884         _COREGL_TRACEPATH_FUNC_END();
6885 }
6886
6887 void
6888 tracepath_glDepthRangexOES(GLclampx zNear, GLclampx zFar)
6889 {
6890         _COREGL_TRACEPATH_FUNC_BEGIN();
6891         _orig_tracepath_glDepthRangexOES(zNear, zFar);
6892
6893         goto finish;
6894
6895 finish:
6896         _COREGL_TRACEPATH_FUNC_END();
6897 }
6898
6899 void
6900 tracepath_glFramebufferRenderbufferOES(GLenum target, GLenum attachment,
6901                                                                            GLenum renderbuffertarget, GLuint renderbuffer)
6902 {
6903         _COREGL_TRACEPATH_FUNC_BEGIN();
6904
6905 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
6906         tracepath_fbdump_update(0);
6907 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
6908
6909         _orig_tracepath_glFramebufferRenderbufferOES(target, attachment,
6910                         renderbuffertarget, renderbuffer);
6911
6912 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
6913         tracepath_fbdump_update(1);
6914 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
6915
6916         goto finish;
6917
6918 finish:
6919         _COREGL_TRACEPATH_FUNC_END();
6920 }
6921
6922 void
6923 tracepath_glFramebufferTexture2DOES(GLenum target, GLenum attachment,
6924                                                                         GLenum textarget, GLuint texture, GLint level)
6925 {
6926         _COREGL_TRACEPATH_FUNC_BEGIN();
6927
6928 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
6929         tracepath_fbdump_update(0);
6930 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
6931
6932         _orig_tracepath_glFramebufferTexture2DOES(target, attachment, textarget,
6933                         texture, level);
6934
6935 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
6936         tracepath_fbdump_update(1);
6937 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
6938
6939         goto finish;
6940
6941 finish:
6942         _COREGL_TRACEPATH_FUNC_END();
6943 }
6944
6945 void
6946 tracepath_glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
6947 {
6948         _COREGL_TRACEPATH_FUNC_BEGIN();
6949         _orig_tracepath_glGenFramebuffersOES(n, framebuffers);
6950
6951         goto finish;
6952
6953 finish:
6954         _COREGL_TRACEPATH_FUNC_END();
6955 }
6956
6957 void
6958 tracepath_glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
6959 {
6960         _COREGL_TRACEPATH_FUNC_BEGIN();
6961
6962         _tp_glGenRenderbuffers(n, renderbuffers, TRACEPATH_FUNC_TYPE_OES);
6963
6964         _COREGL_TRACEPATH_FUNC_END();
6965 }
6966
6967 void
6968 tracepath_glGetFramebufferAttachmentParameterivOES(GLenum target,
6969                 GLenum attachment, GLenum pname, GLint *params)
6970 {
6971         _COREGL_TRACEPATH_FUNC_BEGIN();
6972         _orig_tracepath_glGetFramebufferAttachmentParameterivOES(target, attachment,
6973                         pname, params);
6974
6975         goto finish;
6976
6977 finish:
6978         _COREGL_TRACEPATH_FUNC_END();
6979 }
6980
6981 void
6982 tracepath_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
6983 {
6984         _COREGL_TRACEPATH_FUNC_BEGIN();
6985         _orig_tracepath_glGetQueryObjecti64vEXT(id, pname, params);
6986
6987         goto finish;
6988
6989 finish:
6990         _COREGL_TRACEPATH_FUNC_END();
6991 }
6992
6993 void
6994 tracepath_glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
6995 {
6996         _COREGL_TRACEPATH_FUNC_BEGIN();
6997         _orig_tracepath_glGetQueryObjectivEXT(id, pname, params);
6998
6999         goto finish;
7000
7001 finish:
7002         _COREGL_TRACEPATH_FUNC_END();
7003 }
7004
7005 void
7006 tracepath_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
7007 {
7008         _COREGL_TRACEPATH_FUNC_BEGIN();
7009         _orig_tracepath_glGetQueryObjectui64vEXT(id, pname, params);
7010
7011         goto finish;
7012
7013 finish:
7014         _COREGL_TRACEPATH_FUNC_END();
7015 }
7016
7017 void
7018 tracepath_glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
7019 {
7020         _COREGL_TRACEPATH_FUNC_BEGIN();
7021         _orig_tracepath_glGetQueryObjectuivEXT(id, pname, params);
7022
7023         goto finish;
7024
7025 finish:
7026         _COREGL_TRACEPATH_FUNC_END();
7027 }
7028
7029 void
7030 tracepath_glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
7031 {
7032         _COREGL_TRACEPATH_FUNC_BEGIN();
7033         _orig_tracepath_glGetQueryivEXT(target, pname, params);
7034
7035         goto finish;
7036
7037 finish:
7038         _COREGL_TRACEPATH_FUNC_END();
7039 }
7040
7041 void
7042 tracepath_glBeginQueryEXT(GLenum target, GLuint id)
7043 {
7044         _COREGL_TRACEPATH_FUNC_BEGIN();
7045         _orig_tracepath_glBeginQueryEXT(target, id);
7046
7047         goto finish;
7048
7049 finish:
7050         _COREGL_TRACEPATH_FUNC_END();
7051 }
7052
7053
7054 void
7055 tracepath_glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
7056 {
7057         _COREGL_TRACEPATH_FUNC_BEGIN();
7058         _orig_tracepath_glDeleteQueriesEXT(n, ids);
7059
7060         goto finish;
7061
7062 finish:
7063         _COREGL_TRACEPATH_FUNC_END();
7064 }
7065
7066 void
7067 tracepath_glGenQueriesEXT(GLsizei n, GLuint *ids)
7068 {
7069         _COREGL_TRACEPATH_FUNC_BEGIN();
7070         _orig_tracepath_glGenQueriesEXT(n, ids);
7071
7072         goto finish;
7073
7074 finish:
7075         _COREGL_TRACEPATH_FUNC_END();
7076 }
7077
7078 GLboolean
7079 tracepath_glIsFramebufferOES(GLuint framebuffer)
7080 {
7081         GLboolean ret = GL_FALSE;
7082
7083         _COREGL_TRACEPATH_FUNC_BEGIN();
7084         ret = _orig_tracepath_glIsFramebufferOES(framebuffer);
7085
7086         goto finish;
7087
7088 finish:
7089         _COREGL_TRACEPATH_FUNC_END();
7090         return ret;
7091 }
7092
7093 GLboolean
7094 tracepath_glIsQueryEXT(GLuint id)
7095 {
7096         GLboolean ret = GL_FALSE;
7097
7098         _COREGL_TRACEPATH_FUNC_BEGIN();
7099         ret = _orig_tracepath_glIsQueryEXT(id);
7100
7101         goto finish;
7102
7103 finish:
7104         _COREGL_TRACEPATH_FUNC_END();
7105         return ret;
7106 }
7107
7108 GLboolean
7109 tracepath_glIsRenderbufferOES(GLuint renderbuffer)
7110 {
7111         GLboolean ret;
7112         _COREGL_TRACEPATH_FUNC_BEGIN();
7113         ret = _orig_tracepath_glIsRenderbufferOES(renderbuffer);
7114
7115         goto finish;
7116
7117 finish:
7118         _COREGL_TRACEPATH_FUNC_END();
7119         return ret;
7120 }
7121
7122 void
7123 tracepath_glEndQueryEXT(GLenum target)
7124 {
7125         _COREGL_TRACEPATH_FUNC_BEGIN();
7126         _orig_tracepath_glEndQueryEXT(target);
7127
7128         goto finish;
7129
7130 finish:
7131         _COREGL_TRACEPATH_FUNC_END();
7132 }
7133
7134 void
7135 tracepath_glAlphaFuncxOES(GLenum func, GLclampx ref)
7136 {
7137         _COREGL_TRACEPATH_FUNC_BEGIN();
7138         _orig_tracepath_glAlphaFuncxOES(func, ref);
7139         goto finish;
7140
7141 finish:
7142         _COREGL_TRACEPATH_FUNC_END();
7143 }
7144
7145 void tracepath_glBlendBarrierKHR()
7146 {
7147         _COREGL_TRACEPATH_FUNC_BEGIN();
7148         _orig_tracepath_glBlendBarrierKHR();
7149
7150         goto finish;
7151
7152 finish:
7153         _COREGL_TRACEPATH_FUNC_END();
7154 }
7155
7156 void tracepath_glBlendEquationOES(GLenum mode)
7157 {
7158         _COREGL_TRACEPATH_FUNC_BEGIN();
7159         _orig_tracepath_glBlendEquationOES(mode);
7160
7161         goto finish;
7162
7163 finish:
7164         _COREGL_TRACEPATH_FUNC_END();
7165 }
7166
7167 void tracepath_glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
7168 {
7169         _COREGL_TRACEPATH_FUNC_BEGIN();
7170         _orig_tracepath_glBlendEquationSeparateOES(modeRGB, modeAlpha);
7171
7172         goto finish;
7173
7174 finish:
7175         _COREGL_TRACEPATH_FUNC_END();
7176 }
7177
7178 void tracepath_glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB,
7179                                                                           GLenum srcAlpha, GLenum dstAlpha)
7180 {
7181         _COREGL_TRACEPATH_FUNC_BEGIN();
7182         _orig_tracepath_glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
7183
7184         goto finish;
7185
7186 finish:
7187         _COREGL_TRACEPATH_FUNC_END();
7188 }
7189
7190 GLenum tracepath_glCheckFramebufferStatusOES(GLenum target)
7191 {
7192         GLenum ret = _COREGL_INT_INIT_VALUE;
7193
7194         _COREGL_TRACEPATH_FUNC_BEGIN();
7195         ret = _orig_tracepath_glCheckFramebufferStatusOES(target);
7196
7197         goto finish;
7198
7199 finish:
7200         _COREGL_TRACEPATH_FUNC_END();
7201         return ret;
7202 }
7203
7204
7205 void tracepath_glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue,
7206                                                                 GLclampx alpha)
7207 {
7208         _COREGL_TRACEPATH_FUNC_BEGIN();
7209         _orig_tracepath_glClearColorxOES(red, green, blue, alpha);
7210
7211         goto finish;
7212
7213 finish:
7214         _COREGL_TRACEPATH_FUNC_END();
7215 }
7216
7217 void tracepath_glClearDepthfOES(GLclampf depth)
7218 {
7219         _COREGL_TRACEPATH_FUNC_BEGIN();
7220         _orig_tracepath_glClearDepthfOES(depth);
7221
7222         goto finish;
7223
7224 finish:
7225         _COREGL_TRACEPATH_FUNC_END();
7226 }
7227
7228 void tracepath_glClearDepthxOES(GLclampx depth)
7229 {
7230         _COREGL_TRACEPATH_FUNC_BEGIN();
7231         _orig_tracepath_glClearDepthxOES(depth);
7232
7233         goto finish;
7234
7235 finish:
7236         _COREGL_TRACEPATH_FUNC_END();
7237 }
7238
7239 void tracepath_glClipPlanefOES(GLenum plane, GLfloat const *equation)
7240 {
7241         _COREGL_TRACEPATH_FUNC_BEGIN();
7242         _orig_tracepath_glClipPlanefOES(plane, equation);
7243
7244         goto finish;
7245
7246 finish:
7247         _COREGL_TRACEPATH_FUNC_END();
7248 }
7249
7250
7251 void tracepath_glClipPlanexOES(GLenum plane, GLfixed const *equation)
7252 {
7253         _COREGL_TRACEPATH_FUNC_BEGIN();
7254         _orig_tracepath_glClipPlanexOES(plane, equation);
7255
7256         goto finish;
7257
7258 finish:
7259         _COREGL_TRACEPATH_FUNC_END();
7260 }
7261
7262 void tracepath_glColor4xOES(GLfixed red, GLfixed green, GLfixed blue,
7263                                                         GLfixed alpha)
7264 {
7265         _COREGL_TRACEPATH_FUNC_BEGIN();
7266         _orig_tracepath_glColor4xOES(red, green, blue, alpha);
7267
7268         goto finish;
7269
7270 finish:
7271         _COREGL_TRACEPATH_FUNC_END();
7272 }
7273
7274 void tracepath_glFogxOES(GLenum pname, GLfixed param)
7275 {
7276         _COREGL_TRACEPATH_FUNC_BEGIN();
7277         _orig_tracepath_glFogxOES(pname, param);
7278
7279         goto finish;
7280
7281 finish:
7282         _COREGL_TRACEPATH_FUNC_END();
7283 }
7284
7285 void tracepath_glFogxvOES(GLenum pname, GLfixed const *params)
7286 {
7287         _COREGL_TRACEPATH_FUNC_BEGIN();
7288         _orig_tracepath_glFogxvOES(pname, params);
7289
7290         goto finish;
7291
7292 finish:
7293         _COREGL_TRACEPATH_FUNC_END();
7294 }
7295
7296 void tracepath_glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom,
7297                                                          GLfixed top, GLfixed zNear, GLfixed zFar)
7298 {
7299         _COREGL_TRACEPATH_FUNC_BEGIN();
7300         _orig_tracepath_glFrustumxOES(left, right, bottom, top, zNear, zFar);
7301
7302         goto finish;
7303
7304 finish:
7305         _COREGL_TRACEPATH_FUNC_END();
7306 }
7307
7308 void tracepath_glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom,
7309                                                          GLfloat top, GLfloat zNear, GLfloat zFar)
7310 {
7311         _COREGL_TRACEPATH_FUNC_BEGIN();
7312         _orig_tracepath_glFrustumfOES(left, right, bottom, top, zNear, zFar);
7313
7314         goto finish;
7315
7316 finish:
7317         _COREGL_TRACEPATH_FUNC_END();
7318 }
7319
7320 void tracepath_glGenerateMipmapOES(GLenum target)
7321 {
7322         _COREGL_TRACEPATH_FUNC_BEGIN();
7323         _orig_tracepath_glGenerateMipmapOES(target);
7324
7325         goto finish;
7326
7327 finish:
7328         _COREGL_TRACEPATH_FUNC_END();
7329 }
7330
7331 void tracepath_glGetClipPlanefOES(GLenum pname, GLfloat eqn[4])
7332 {
7333         _COREGL_TRACEPATH_FUNC_BEGIN();
7334         _orig_tracepath_glGetClipPlanefOES(pname, eqn);
7335
7336         goto finish;
7337
7338 finish:
7339         _COREGL_TRACEPATH_FUNC_END();
7340 }
7341
7342 void tracepath_glGetClipPlanexOES(GLenum pname, GLfixed eqn[4])
7343 {
7344         _COREGL_TRACEPATH_FUNC_BEGIN();
7345         _orig_tracepath_glGetClipPlanexOES(pname, eqn);
7346
7347         goto finish;
7348
7349 finish:
7350         _COREGL_TRACEPATH_FUNC_END();
7351 }
7352
7353 void tracepath_glGetFixedvOES(GLenum pname, GLfixed *params)
7354 {
7355         _COREGL_TRACEPATH_FUNC_BEGIN();
7356         _orig_tracepath_glGetFixedvOES(pname, params);
7357
7358         goto finish;
7359
7360 finish:
7361         _COREGL_TRACEPATH_FUNC_END();
7362 }
7363
7364 void tracepath_glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params)
7365 {
7366         _COREGL_TRACEPATH_FUNC_BEGIN();
7367         _orig_tracepath_glGetLightxvOES(light, pname, params);
7368
7369         goto finish;
7370
7371 finish:
7372         _COREGL_TRACEPATH_FUNC_END();
7373 }
7374
7375 void tracepath_glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params)
7376 {
7377         _COREGL_TRACEPATH_FUNC_BEGIN();
7378         _orig_tracepath_glGetMaterialxvOES(face, pname, params);
7379
7380         goto finish;
7381
7382 finish:
7383         _COREGL_TRACEPATH_FUNC_END();
7384 }
7385
7386 void tracepath_glGetPointervKHR(GLenum pname, GLvoid **params)
7387 {
7388         _COREGL_TRACEPATH_FUNC_BEGIN();
7389         _orig_tracepath_glGetPointervKHR(pname, params);
7390
7391         goto finish;
7392
7393 finish:
7394         _COREGL_TRACEPATH_FUNC_END();
7395 }
7396
7397 void tracepath_glGetRenderbufferParameterivOES(GLenum target, GLenum pname,
7398                 GLint *params)
7399 {
7400         _COREGL_TRACEPATH_FUNC_BEGIN();
7401         _orig_tracepath_glGetRenderbufferParameterivOES(target, pname, params);
7402
7403         goto finish;
7404
7405 finish:
7406         _COREGL_TRACEPATH_FUNC_END();
7407 }
7408
7409 void tracepath_glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params)
7410 {
7411         _COREGL_TRACEPATH_FUNC_BEGIN();
7412         _orig_tracepath_glGetTexEnvxvOES(env, pname, params);
7413
7414         goto finish;
7415
7416 finish:
7417         _COREGL_TRACEPATH_FUNC_END();
7418 }
7419
7420 void tracepath_glGetTexParameterxvOES(GLenum target, GLenum pname,
7421                                                                           GLfixed *params)
7422 {
7423         _COREGL_TRACEPATH_FUNC_BEGIN();
7424         _orig_tracepath_glGetTexParameterxvOES(target, pname, params);
7425
7426         goto finish;
7427
7428 finish:
7429         _COREGL_TRACEPATH_FUNC_END();
7430 }
7431
7432
7433 void
7434 tracepath_glLightModelxOES (GLenum pname, GLfixed param)
7435 {
7436         _COREGL_TRACEPATH_FUNC_BEGIN();
7437         _orig_tracepath_glLightModelxOES (pname, param);
7438
7439         goto finish;
7440
7441 finish:
7442         _COREGL_TRACEPATH_FUNC_END();
7443 }
7444
7445
7446 void
7447 tracepath_glLightModelxvOES (GLenum pname, const GLfixed *params)
7448 {
7449         _COREGL_TRACEPATH_FUNC_BEGIN();
7450         _orig_tracepath_glLightModelxvOES (pname, params);
7451
7452         goto finish;
7453
7454 finish:
7455         _COREGL_TRACEPATH_FUNC_END();
7456 }
7457
7458
7459 void
7460 tracepath_glLightxOES (GLenum light, GLenum pname, GLfixed param)
7461 {
7462         _COREGL_TRACEPATH_FUNC_BEGIN();
7463         _orig_tracepath_glLightxOES (light, pname, param);
7464
7465         goto finish;
7466
7467 finish:
7468         _COREGL_TRACEPATH_FUNC_END();
7469 }
7470
7471
7472 void
7473 tracepath_glLightxvOES (GLenum light, GLenum pname, const GLfixed *params)
7474 {
7475         _COREGL_TRACEPATH_FUNC_BEGIN();
7476         _orig_tracepath_glLightxvOES (light, pname, params);
7477
7478         goto finish;
7479
7480 finish:
7481         _COREGL_TRACEPATH_FUNC_END();
7482 }
7483
7484 void
7485 tracepath_glLineWidthxOES (GLfixed width)
7486 {
7487         _COREGL_TRACEPATH_FUNC_BEGIN();
7488         _orig_tracepath_glLineWidthxOES (width);
7489
7490         goto finish;
7491
7492 finish:
7493         _COREGL_TRACEPATH_FUNC_END();
7494 }
7495
7496 void
7497 tracepath_glLoadMatrixxOES (const GLfixed *m)
7498 {
7499         _COREGL_TRACEPATH_FUNC_BEGIN();
7500         _orig_tracepath_glLoadMatrixxOES (m);
7501         goto finish;
7502
7503 finish:
7504         _COREGL_TRACEPATH_FUNC_END();
7505 }
7506
7507 void
7508 tracepath_glMaterialxOES (GLenum face, GLenum pname, GLfixed param)
7509 {
7510         _COREGL_TRACEPATH_FUNC_BEGIN();
7511         _orig_tracepath_glMaterialxOES (face, pname, param);
7512
7513         goto finish;
7514
7515 finish:
7516         _COREGL_TRACEPATH_FUNC_END();
7517 }
7518
7519 void
7520 tracepath_glMaterialxvOES (GLenum face, GLenum pname, const GLfixed *params)
7521 {
7522         _COREGL_TRACEPATH_FUNC_BEGIN();
7523         _orig_tracepath_glMaterialxvOES (face, pname, params);
7524
7525         goto finish;
7526
7527 finish:
7528         _COREGL_TRACEPATH_FUNC_END();
7529 }
7530
7531 void
7532 tracepath_glMultMatrixxOES (const GLfixed *m)
7533 {
7534         _COREGL_TRACEPATH_FUNC_BEGIN();
7535         _orig_tracepath_glMultMatrixxOES (m);
7536
7537         goto finish;
7538
7539 finish:
7540         _COREGL_TRACEPATH_FUNC_END();
7541 }
7542
7543 void
7544 tracepath_glMultiTexCoord4bOES (GLenum target, GLbyte s, GLbyte t, GLbyte r,
7545                                                                 GLbyte q)
7546 {
7547         _COREGL_TRACEPATH_FUNC_BEGIN();
7548         _orig_tracepath_glMultiTexCoord4bOES (target, s, t, r, q);
7549
7550         goto finish;
7551
7552 finish:
7553         _COREGL_TRACEPATH_FUNC_END();
7554 }
7555
7556 void
7557 tracepath_glMultiTexCoord4xOES (GLenum target, GLfixed s, GLfixed t, GLfixed r,
7558                                                                 GLfixed q)
7559 {
7560         _COREGL_TRACEPATH_FUNC_BEGIN();
7561         _orig_tracepath_glMultiTexCoord4xOES (target, s, t, r, q);
7562
7563         goto finish;
7564
7565 finish:
7566         _COREGL_TRACEPATH_FUNC_END();
7567 }
7568
7569 void
7570 tracepath_glNormal3xOES (GLfixed nx, GLfixed ny, GLfixed nz)
7571 {
7572         _COREGL_TRACEPATH_FUNC_BEGIN();
7573         _orig_tracepath_glNormal3xOES (nx, ny, nz);
7574
7575         goto finish;
7576
7577 finish:
7578         _COREGL_TRACEPATH_FUNC_END();
7579 }
7580
7581 void
7582 tracepath_glOrthofOES (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
7583                                            GLfloat zNear, GLfloat zFar)
7584 {
7585         _COREGL_TRACEPATH_FUNC_BEGIN();
7586         _orig_tracepath_glOrthofOES (left, right, bottom, top, zNear, zFar);
7587
7588         goto finish;
7589
7590 finish:
7591         _COREGL_TRACEPATH_FUNC_END();
7592 }
7593
7594 void
7595 tracepath_glOrthoxOES (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
7596                                            GLfixed zNear, GLfixed zFar)
7597 {
7598         _COREGL_TRACEPATH_FUNC_BEGIN();
7599         _orig_tracepath_glOrthoxOES (left, right, bottom, top, zNear, zFar);
7600
7601         goto finish;
7602
7603 finish:
7604         _COREGL_TRACEPATH_FUNC_END();
7605 }
7606
7607 void
7608 tracepath_glPointParameterxOES (GLenum pname, GLfixed param)
7609 {
7610         _COREGL_TRACEPATH_FUNC_BEGIN();
7611         _orig_tracepath_glPointParameterxOES (pname, param);
7612
7613         goto finish;
7614
7615 finish:
7616         _COREGL_TRACEPATH_FUNC_END();
7617 }
7618
7619 void
7620 tracepath_glPointParameterxvOES (GLenum pname, const GLfixed *params)
7621 {
7622         _COREGL_TRACEPATH_FUNC_BEGIN();
7623         _orig_tracepath_glPointParameterxvOES (pname, params);
7624
7625         goto finish;
7626
7627 finish:
7628         _COREGL_TRACEPATH_FUNC_END();
7629 }
7630
7631 void
7632 tracepath_glPointSizexOES (GLfixed size)
7633 {
7634         _COREGL_TRACEPATH_FUNC_BEGIN();
7635         _orig_tracepath_glPointSizexOES (size);
7636
7637         goto finish;
7638
7639 finish:
7640         _COREGL_TRACEPATH_FUNC_END();
7641 }
7642
7643 void
7644 tracepath_glPolygonOffsetxOES (GLfixed factor, GLfixed units)
7645 {
7646         _COREGL_TRACEPATH_FUNC_BEGIN();
7647         _orig_tracepath_glPolygonOffsetxOES (factor, units);
7648
7649         goto finish;
7650
7651 finish:
7652         _COREGL_TRACEPATH_FUNC_END();
7653 }
7654
7655 void
7656 tracepath_glQueryCounterEXT (GLuint id, GLenum target)
7657 {
7658         _COREGL_TRACEPATH_FUNC_BEGIN();
7659         _orig_tracepath_glQueryCounterEXT (id, target);
7660
7661         goto finish;
7662
7663 finish:
7664         _COREGL_TRACEPATH_FUNC_END();
7665 }
7666
7667 void
7668 tracepath_glRenderbufferStorageOES (GLenum target, GLenum internalformat,
7669                                                                         GLsizei width, GLsizei height)
7670 {
7671         _COREGL_TRACEPATH_FUNC_BEGIN();
7672         _orig_tracepath_glRenderbufferStorageOES (target, internalformat, width,
7673                         height);
7674
7675         goto finish;
7676
7677 finish:
7678         _COREGL_TRACEPATH_FUNC_END();
7679 }
7680
7681 void
7682 tracepath_glRotatexOES (GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
7683 {
7684         _COREGL_TRACEPATH_FUNC_BEGIN();
7685         _orig_tracepath_glRotatexOES (angle, x, y, z);
7686
7687         goto finish;
7688
7689 finish:
7690         _COREGL_TRACEPATH_FUNC_END();
7691 }
7692
7693 void
7694 tracepath_glSampleCoveragexOES (GLclampx value, GLboolean invert)
7695 {
7696         _COREGL_TRACEPATH_FUNC_BEGIN();
7697         _orig_tracepath_glSampleCoveragexOES (value, invert);
7698
7699         goto finish;
7700
7701 finish:
7702         _COREGL_TRACEPATH_FUNC_END();
7703 }
7704
7705 void
7706 tracepath_glScalexOES (GLfixed x, GLfixed y, GLfixed z)
7707 {
7708         _COREGL_TRACEPATH_FUNC_BEGIN();
7709         _orig_tracepath_glScalexOES (x, y, z);
7710
7711         goto finish;
7712
7713 finish:
7714         _COREGL_TRACEPATH_FUNC_END();
7715 }
7716
7717 void
7718 tracepath_glTexEnvxOES (GLenum target, GLenum pname, GLfixed param)
7719 {
7720         _COREGL_TRACEPATH_FUNC_BEGIN();
7721         _orig_tracepath_glTexEnvxOES (target, pname, param);
7722
7723         goto finish;
7724
7725 finish:
7726         _COREGL_TRACEPATH_FUNC_END();
7727 }
7728
7729 void
7730 tracepath_glTexEnvxvOES (GLenum target, GLenum pname, const GLfixed *params)
7731 {
7732         _COREGL_TRACEPATH_FUNC_BEGIN();
7733         _orig_tracepath_glTexEnvxvOES (target, pname, params);
7734
7735         goto finish;
7736
7737 finish:
7738         _COREGL_TRACEPATH_FUNC_END();
7739 }
7740
7741 void
7742 tracepath_glTexParameterxOES (GLenum target, GLenum pname, GLfixed param)
7743 {
7744         _COREGL_TRACEPATH_FUNC_BEGIN();
7745         _orig_tracepath_glTexParameterxOES (target, pname, param);
7746
7747         goto finish;
7748
7749 finish:
7750         _COREGL_TRACEPATH_FUNC_END();
7751 }
7752
7753 void
7754 tracepath_glTexParameterxvOES (GLenum target, GLenum pname,
7755                                                            const GLfixed *params)
7756 {
7757         _COREGL_TRACEPATH_FUNC_BEGIN();
7758         _orig_tracepath_glTexParameterxvOES (target, pname, params);
7759
7760         goto finish;
7761
7762 finish:
7763         _COREGL_TRACEPATH_FUNC_END();
7764 }
7765
7766 void
7767 tracepath_glTexStorage2DEXT (GLenum target, GLsizei levels,
7768                                                          GLenum internalformat, GLsizei width, GLsizei height)
7769 {
7770         _COREGL_TRACEPATH_FUNC_BEGIN();
7771         _orig_tracepath_glTexStorage2DEXT (target, levels, internalformat, width,
7772                                                                            height);
7773
7774         goto finish;
7775
7776 finish:
7777         _COREGL_TRACEPATH_FUNC_END();
7778 }
7779
7780 void
7781 tracepath_glTexStorage3DEXT (GLenum target, GLsizei levels,
7782                                                          GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
7783 {
7784         _COREGL_TRACEPATH_FUNC_BEGIN();
7785         _orig_tracepath_glTexStorage3DEXT (target, levels, internalformat, width,
7786                                                                            height, depth);
7787
7788         goto finish;
7789
7790 finish:
7791         _COREGL_TRACEPATH_FUNC_END();
7792 }
7793
7794 void
7795 tracepath_glTexStorage3DMultisampleOES (GLenum target, GLsizei samples,
7796                                                                                 GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
7797                                                                                 GLboolean fixedsamplelocations)
7798 {
7799         _COREGL_TRACEPATH_FUNC_BEGIN();
7800         _orig_tracepath_glTexStorage3DMultisampleOES (target, samples, internalformat,
7801                         width, height, depth, fixedsamplelocations);
7802
7803         goto finish;
7804
7805 finish:
7806         _COREGL_TRACEPATH_FUNC_END();
7807 }
7808
7809 void
7810 tracepath_glTranslatexOES (GLfixed x, GLfixed y, GLfixed z)
7811 {
7812         _COREGL_TRACEPATH_FUNC_BEGIN();
7813         _orig_tracepath_glTranslatexOES (x, y, z);
7814
7815         goto finish;
7816
7817 finish:
7818         _COREGL_TRACEPATH_FUNC_END();
7819 }
7820
7821 void
7822 tracepath_glBindVertexArrayOES(GLuint array)
7823 {
7824         _COREGL_TRACEPATH_FUNC_BEGIN();
7825         _orig_tracepath_glBindVertexArrayOES(array);
7826
7827         goto finish;
7828
7829 finish:
7830         _COREGL_TRACEPATH_FUNC_END();
7831 }
7832
7833 void
7834 tracepath_glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
7835 {
7836         _COREGL_TRACEPATH_FUNC_BEGIN();
7837         _orig_tracepath_glDeleteVertexArraysOES(n, arrays);
7838
7839         goto finish;
7840
7841 finish:
7842         _COREGL_TRACEPATH_FUNC_END();
7843 }
7844
7845 void
7846 tracepath_glGenVertexArraysOES(GLsizei n, GLuint *arrays)
7847 {
7848         _COREGL_TRACEPATH_FUNC_BEGIN();
7849         _orig_tracepath_glGenVertexArraysOES(n, arrays);
7850
7851         goto finish;
7852
7853 finish:
7854         _COREGL_TRACEPATH_FUNC_END();
7855 }
7856
7857 GLboolean
7858 tracepath_glIsVertexArrayOES(GLuint array)
7859 {
7860         GLboolean ret = GL_FALSE;
7861
7862         _COREGL_TRACEPATH_FUNC_BEGIN();
7863         ret = _orig_tracepath_glIsVertexArrayOES(array);
7864
7865         goto finish;
7866
7867 finish:
7868         _COREGL_TRACEPATH_FUNC_END();
7869         return ret;
7870 }
7871
7872 void tracepath_glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback,
7873                 void const *userParam)
7874 {
7875         _COREGL_TRACEPATH_FUNC_BEGIN();
7876         _orig_tracepath_glDebugMessageCallbackKHR(callback, userParam);
7877
7878         goto finish;
7879
7880 finish:
7881         _COREGL_TRACEPATH_FUNC_END();
7882 }
7883
7884
7885 void tracepath_glDebugMessageControlKHR(GLenum source, GLenum type,
7886                                                                                 GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled)
7887 {
7888         _COREGL_TRACEPATH_FUNC_BEGIN();
7889         _orig_tracepath_glDebugMessageControlKHR(source, type, severity, count, ids,
7890                         enabled);
7891
7892         goto finish;
7893
7894 finish:
7895         _COREGL_TRACEPATH_FUNC_END();
7896 }
7897
7898 void tracepath_glDebugMessageInsertKHR(GLenum source, GLenum type, GLuint id,
7899                                                                            GLenum severity, GLsizei length, GLchar const *buf)
7900 {
7901         _COREGL_TRACEPATH_FUNC_BEGIN();
7902         _orig_tracepath_glDebugMessageInsertKHR(source, type, id, severity, length,
7903                                                                                         buf);
7904
7905         goto finish;
7906
7907 finish:
7908         _COREGL_TRACEPATH_FUNC_END();
7909 }
7910
7911 GLuint tracepath_glGetDebugMessageLogKHR(GLuint count, GLsizei bufsize,
7912                 GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities,
7913                 GLsizei *lengths, GLchar *messageLog)
7914 {
7915         GLuint ret = GL_INVALID_INDEX;
7916         _COREGL_TRACEPATH_FUNC_BEGIN();
7917         ret =  _orig_tracepath_glGetDebugMessageLogKHR(count, bufsize, sources, types,
7918                         ids, severities, lengths, messageLog);
7919         goto finish;
7920
7921 finish:
7922         _COREGL_TRACEPATH_FUNC_END();
7923         return ret;
7924 }
7925
7926 void tracepath_glGetObjectLabelKHR(GLenum identifier, GLuint name,
7927                                                                    GLsizei bufSize, GLsizei *length, GLchar *label)
7928 {
7929         _COREGL_TRACEPATH_FUNC_BEGIN();
7930         _orig_tracepath_glGetObjectLabelKHR(identifier, name, bufSize, length, label);
7931
7932         goto finish;
7933
7934 finish:
7935         _COREGL_TRACEPATH_FUNC_END();
7936 }
7937
7938 void tracepath_glGetObjectPtrLabelKHR(void const *ptr, GLsizei bufSize,
7939                                                                           GLsizei *length, GLchar *label)
7940 {
7941         _COREGL_TRACEPATH_FUNC_BEGIN();
7942         _orig_tracepath_glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
7943
7944         goto finish;
7945
7946 finish:
7947         _COREGL_TRACEPATH_FUNC_END();
7948 }
7949
7950 void
7951 tracepath_glGetPointerv(GLenum pname, GLvoid **params)
7952 {
7953         _COREGL_TRACEPATH_FUNC_BEGIN();
7954         _orig_tracepath_glGetPointerv(pname, params);
7955
7956         goto finish;
7957
7958 finish:
7959         _COREGL_TRACEPATH_FUNC_END();
7960 }
7961
7962 void
7963 tracepath_glObjectLabelKHR (GLenum identifier, GLuint name, GLsizei length,
7964                                                         const GLchar *label)
7965 {
7966         _COREGL_TRACEPATH_FUNC_BEGIN();
7967         _orig_tracepath_glObjectLabelKHR (identifier, name, length, label);
7968         goto finish;
7969
7970 finish:
7971         _COREGL_TRACEPATH_FUNC_END();
7972 }
7973
7974 void
7975 tracepath_glObjectPtrLabelKHR (const void *ptr, GLsizei length,
7976                                                            const GLchar *label)
7977 {
7978         _COREGL_TRACEPATH_FUNC_BEGIN();
7979         _orig_tracepath_glObjectPtrLabelKHR (ptr, length, label);
7980
7981         goto finish;
7982
7983 finish:
7984         _COREGL_TRACEPATH_FUNC_END();
7985 }
7986
7987 void
7988 tracepath_glPopDebugGroupKHR (void)
7989 {
7990         _COREGL_TRACEPATH_FUNC_BEGIN();
7991         _orig_tracepath_glPopDebugGroupKHR ();
7992
7993         goto finish;
7994
7995 finish:
7996         _COREGL_TRACEPATH_FUNC_END();
7997 }
7998
7999 void
8000 tracepath_glPushDebugGroupKHR (GLenum source, GLuint id, GLsizei length,
8001                                                            const GLchar *message)
8002 {
8003         _COREGL_TRACEPATH_FUNC_BEGIN();
8004         _orig_tracepath_glPushDebugGroupKHR (source, id, length, message);
8005
8006         goto finish;
8007
8008 finish:
8009         _COREGL_TRACEPATH_FUNC_END();
8010 }
8011
8012 /* GLES3.2 API*/
8013 void
8014 tracepath_glBlendBarrier(void)
8015 {
8016         _COREGL_TRACEPATH_FUNC_BEGIN();
8017         _orig_tracepath_glBlendBarrier();
8018         goto finish;
8019
8020 finish:
8021         _COREGL_TRACEPATH_FUNC_END();
8022 }
8023
8024 void
8025 tracepath_glCopyImageSubData (GLuint srcName, GLenum srcTarget, GLint srcLevel,
8026                                                           GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget,
8027                                                           GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth,
8028                                                           GLsizei srcHeight, GLsizei srcDepth)
8029 {
8030         _COREGL_TRACEPATH_FUNC_BEGIN();
8031         _orig_tracepath_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY,
8032                                                                            srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
8033                                                                            srcDepth);
8034         goto finish;
8035
8036 finish:
8037         _COREGL_TRACEPATH_FUNC_END();
8038 }
8039
8040 void
8041 tracepath_glDebugMessageControl (GLenum source, GLenum type, GLenum severity,
8042                                                                  GLsizei count, const GLuint *ids, GLboolean enabled)
8043 {
8044         _COREGL_TRACEPATH_FUNC_BEGIN();
8045         _orig_tracepath_glDebugMessageControl (source, type, severity, count, ids,
8046                                                                                    enabled);
8047         goto finish;
8048
8049 finish:
8050         _COREGL_TRACEPATH_FUNC_END();
8051 }
8052
8053 void
8054 tracepath_glDebugMessageInsert(GLenum source, GLenum type, GLuint id,
8055                                                            GLenum severity, GLsizei length, const GLchar *buf)
8056 {
8057         _COREGL_TRACEPATH_FUNC_BEGIN();
8058         _orig_tracepath_glDebugMessageInsert(source, type, id, severity, length, buf);
8059         goto finish;
8060
8061 finish:
8062         _COREGL_TRACEPATH_FUNC_END();
8063 }
8064
8065 void
8066 tracepath_glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
8067 {
8068         _COREGL_TRACEPATH_FUNC_BEGIN();
8069         _orig_tracepath_glDebugMessageCallback(callback, userParam);
8070         goto finish;
8071
8072 finish:
8073         _COREGL_TRACEPATH_FUNC_END();
8074 }
8075
8076 GLuint
8077 tracepath_glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources,
8078                                                            GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths,
8079                                                            GLchar *messageLog)
8080 {
8081         GLuint ret = _COREGL_INT_INIT_VALUE;
8082         _COREGL_TRACEPATH_FUNC_BEGIN();
8083         ret = _orig_tracepath_glGetDebugMessageLog(count, bufSize, sources, types, ids,
8084                         severities, lengths, messageLog);
8085         goto finish;
8086
8087 finish:
8088         _COREGL_TRACEPATH_FUNC_END();
8089         return ret;
8090 }
8091
8092 void
8093 tracepath_glPushDebugGroup(GLenum source, GLuint id, GLsizei length,
8094                                                    const GLchar *message)
8095 {
8096         _COREGL_TRACEPATH_FUNC_BEGIN();
8097         _orig_tracepath_glPushDebugGroup(source, id, length, message);
8098         goto finish;
8099
8100 finish:
8101         _COREGL_TRACEPATH_FUNC_END();
8102 }
8103
8104 void
8105 tracepath_glPopDebugGroup(void)
8106 {
8107         _COREGL_TRACEPATH_FUNC_BEGIN();
8108         _orig_tracepath_glPopDebugGroup();
8109         goto finish;
8110
8111 finish:
8112         _COREGL_TRACEPATH_FUNC_END();
8113 }
8114
8115 void
8116 tracepath_glObjectLabel(GLenum identifier, GLuint name, GLsizei length,
8117                                                 const GLchar *label)
8118 {
8119         _COREGL_TRACEPATH_FUNC_BEGIN();
8120         _orig_tracepath_glObjectLabel(identifier, name, length, label);
8121         goto finish;
8122
8123 finish:
8124         _COREGL_TRACEPATH_FUNC_END();
8125 }
8126
8127 void
8128 tracepath_glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize,
8129                                                    GLsizei *length, GLchar *label)
8130 {
8131         _COREGL_TRACEPATH_FUNC_BEGIN();
8132         _orig_tracepath_glGetObjectLabel(identifier, name, bufSize, length, label);
8133         goto finish;
8134
8135 finish:
8136         _COREGL_TRACEPATH_FUNC_END();
8137 }
8138
8139 void
8140 tracepath_glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
8141 {
8142         _COREGL_TRACEPATH_FUNC_BEGIN();
8143         _orig_tracepath_glObjectPtrLabel(ptr, length, label);
8144         goto finish;
8145
8146 finish:
8147         _COREGL_TRACEPATH_FUNC_END();
8148 }
8149
8150 void
8151 tracepath_glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length,
8152                                                           GLchar *label)
8153 {
8154         _COREGL_TRACEPATH_FUNC_BEGIN();
8155         _orig_tracepath_glGetObjectPtrLabel(ptr, bufSize, length, label);
8156         goto finish;
8157
8158 finish:
8159         _COREGL_TRACEPATH_FUNC_END();
8160 }
8161
8162 void
8163 tracepath_glEnablei(GLenum target, GLuint index)
8164 {
8165         _COREGL_TRACEPATH_FUNC_BEGIN();
8166         _orig_tracepath_glEnablei(target, index);
8167         goto finish;
8168
8169 finish:
8170         _COREGL_TRACEPATH_FUNC_END();
8171 }
8172
8173 void
8174 tracepath_glDisablei(GLenum target, GLuint index)
8175 {
8176         _COREGL_TRACEPATH_FUNC_BEGIN();
8177         _orig_tracepath_glDisablei(target, index);
8178         goto finish;
8179
8180 finish:
8181         _COREGL_TRACEPATH_FUNC_END();
8182 }
8183
8184 void
8185 tracepath_glBlendEquationi(GLuint buf, GLenum mode)
8186 {
8187         _COREGL_TRACEPATH_FUNC_BEGIN();
8188         _orig_tracepath_glBlendEquationi(buf, mode);
8189         goto finish;
8190
8191 finish:
8192         _COREGL_TRACEPATH_FUNC_END();
8193 }
8194
8195 void
8196 tracepath_glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
8197 {
8198         _COREGL_TRACEPATH_FUNC_BEGIN();
8199         _orig_tracepath_glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
8200         goto finish;
8201
8202 finish:
8203         _COREGL_TRACEPATH_FUNC_END();
8204 }
8205
8206 void
8207 tracepath_glBlendFunci(GLuint buf, GLenum src, GLenum dst)
8208 {
8209         _COREGL_TRACEPATH_FUNC_BEGIN();
8210         _orig_tracepath_glBlendFunci(buf, src, dst);
8211         goto finish;
8212
8213 finish:
8214         _COREGL_TRACEPATH_FUNC_END();
8215 }
8216
8217 void
8218 tracepath_glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB,
8219                                                            GLenum srcAlpha, GLenum dstAlpha)
8220 {
8221         _COREGL_TRACEPATH_FUNC_BEGIN();
8222         _orig_tracepath_glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
8223         goto finish;
8224
8225 finish:
8226         _COREGL_TRACEPATH_FUNC_END();
8227 }
8228
8229 void
8230 tracepath_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b,
8231                                            GLboolean a)
8232 {
8233         _COREGL_TRACEPATH_FUNC_BEGIN();
8234         _orig_tracepath_glColorMaski(index, r, g, b, a);
8235         goto finish;
8236
8237 finish:
8238         _COREGL_TRACEPATH_FUNC_END();
8239 }
8240
8241 void
8242 tracepath_glColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b,
8243                                                   GLboolean a)
8244 {
8245         _COREGL_TRACEPATH_FUNC_BEGIN();
8246         _orig_tracepath_glColorMaskiOES(index, r, g, b, a);
8247         goto finish;
8248
8249 finish:
8250         _COREGL_TRACEPATH_FUNC_END();
8251 }
8252
8253 GLboolean
8254 tracepath_glIsEnabledi(GLenum target, GLuint index)
8255 {
8256         GLboolean ret = GL_FALSE;
8257         _COREGL_TRACEPATH_FUNC_BEGIN();
8258         ret = _orig_tracepath_glIsEnabledi(target, index);
8259         goto finish;
8260
8261 finish:
8262         _COREGL_TRACEPATH_FUNC_END();
8263         return ret;
8264 }
8265
8266 void
8267 tracepath_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
8268                                                                    const void *indices, GLint basevertex)
8269 {
8270         _COREGL_TRACEPATH_FUNC_BEGIN();
8271         _orig_tracepath_glDrawElementsBaseVertex(mode, count, type, indices,
8272                         basevertex);
8273         goto finish;
8274
8275 finish:
8276         _COREGL_TRACEPATH_FUNC_END();
8277 }
8278
8279 void
8280 tracepath_glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
8281                                                                                 GLsizei count, GLenum type, const void *indices, GLint basevertex)
8282 {
8283         _COREGL_TRACEPATH_FUNC_BEGIN();
8284         _orig_tracepath_glDrawRangeElementsBaseVertex(mode, start, end, count, type,
8285                         indices, basevertex);
8286         goto finish;
8287
8288 finish:
8289         _COREGL_TRACEPATH_FUNC_END();
8290 }
8291
8292 void
8293 tracepath_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count,
8294                 GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
8295 {
8296         _COREGL_TRACEPATH_FUNC_BEGIN();
8297         _orig_tracepath_glDrawElementsInstancedBaseVertex(mode, count, type, indices,
8298                         instancecount, basevertex);
8299         goto finish;
8300
8301 finish:
8302         _COREGL_TRACEPATH_FUNC_END();
8303 }
8304
8305 void
8306 tracepath_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture,
8307                                                            GLint level)
8308 {
8309         _COREGL_TRACEPATH_FUNC_BEGIN();
8310         _orig_tracepath_glFramebufferTexture(target, attachment, texture, level);
8311         goto finish;
8312
8313 finish:
8314         _COREGL_TRACEPATH_FUNC_END();
8315 }
8316
8317 void
8318 tracepath_glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ,
8319                                                                  GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
8320 {
8321         _COREGL_TRACEPATH_FUNC_BEGIN();
8322         _orig_tracepath_glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ,
8323                                                                                    maxW);
8324         goto finish;
8325
8326 finish:
8327         _COREGL_TRACEPATH_FUNC_END();
8328 }
8329
8330 GLenum
8331 tracepath_glGetGraphicsResetStatus(void)
8332 {
8333         GLenum ret = GL_NONE;
8334         _COREGL_TRACEPATH_FUNC_BEGIN();
8335         ret =  _orig_tracepath_glGetGraphicsResetStatus();
8336         goto finish;
8337
8338 finish:
8339         _COREGL_TRACEPATH_FUNC_END();
8340         return ret;
8341 }
8342
8343 void
8344 tracepath_glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height,
8345                                                 GLenum format, GLenum type, GLsizei bufSize, void *data)
8346 {
8347         _COREGL_TRACEPATH_FUNC_BEGIN();
8348         _orig_tracepath_glReadnPixels(x, y, width, height, format, type, bufSize, data);
8349         goto finish;
8350
8351 finish:
8352         _COREGL_TRACEPATH_FUNC_END();
8353 }
8354
8355 void
8356 tracepath_glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize,
8357                                                   GLfloat *params)
8358 {
8359         _COREGL_TRACEPATH_FUNC_BEGIN();
8360         _orig_tracepath_glGetnUniformfv(program, location, bufSize, params);
8361         goto finish;
8362
8363 finish:
8364         _COREGL_TRACEPATH_FUNC_END();
8365 }
8366
8367 void
8368 tracepath_glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize,
8369                                                   GLint *params)
8370 {
8371         _COREGL_TRACEPATH_FUNC_BEGIN();
8372         _orig_tracepath_glGetnUniformiv(program, location, bufSize, params);
8373         goto finish;
8374
8375 finish:
8376         _COREGL_TRACEPATH_FUNC_END();
8377 }
8378
8379 void
8380 tracepath_glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize,
8381                                                    GLuint *params)
8382 {
8383         _COREGL_TRACEPATH_FUNC_BEGIN();
8384         _orig_tracepath_glGetnUniformuiv(program, location, bufSize, params);
8385         goto finish;
8386
8387 finish:
8388         _COREGL_TRACEPATH_FUNC_END();
8389 }
8390
8391 void
8392 tracepath_glMinSampleShading(GLfloat value)
8393 {
8394         _COREGL_TRACEPATH_FUNC_BEGIN();
8395         _orig_tracepath_glMinSampleShading(value);
8396         goto finish;
8397
8398 finish:
8399         _COREGL_TRACEPATH_FUNC_END();
8400 }
8401
8402 void
8403 tracepath_glPatchParameteri(GLenum pname, GLint value)
8404 {
8405         _COREGL_TRACEPATH_FUNC_BEGIN();
8406         _orig_tracepath_glPatchParameteri(pname, value);
8407         goto finish;
8408
8409 finish:
8410         _COREGL_TRACEPATH_FUNC_END();
8411 }
8412
8413 void
8414 tracepath_glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
8415 {
8416         _COREGL_TRACEPATH_FUNC_BEGIN();
8417         _orig_tracepath_glTexParameterIiv(target, pname, params);
8418         goto finish;
8419
8420 finish:
8421         _COREGL_TRACEPATH_FUNC_END();
8422 }
8423
8424 void
8425 tracepath_glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
8426 {
8427         _COREGL_TRACEPATH_FUNC_BEGIN();
8428         _orig_tracepath_glTexParameterIuiv(target, pname, params);
8429         goto finish;
8430
8431 finish:
8432         _COREGL_TRACEPATH_FUNC_END();
8433 }
8434
8435 void
8436 tracepath_glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
8437 {
8438         _COREGL_TRACEPATH_FUNC_BEGIN();
8439         _orig_tracepath_glGetTexParameterIiv(target, pname, params);
8440         goto finish;
8441
8442 finish:
8443         _COREGL_TRACEPATH_FUNC_END();
8444 }
8445
8446 void
8447 tracepath_glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
8448 {
8449         _COREGL_TRACEPATH_FUNC_BEGIN();
8450         _orig_tracepath_glGetTexParameterIuiv(target, pname, params);
8451         goto finish;
8452
8453 finish:
8454         _COREGL_TRACEPATH_FUNC_END();
8455 }
8456
8457 void
8458 tracepath_glSamplerParameterIiv(GLuint sampler, GLenum pname,
8459                                                                 const GLint *param)
8460 {
8461         _COREGL_TRACEPATH_FUNC_BEGIN();
8462         _orig_tracepath_glSamplerParameterIiv(sampler, pname, param);
8463         goto finish;
8464
8465 finish:
8466         _COREGL_TRACEPATH_FUNC_END();
8467 }
8468
8469 void
8470 tracepath_glSamplerParameterIuiv(GLuint sampler, GLenum pname,
8471                                                                  const GLuint *param)
8472 {
8473         _COREGL_TRACEPATH_FUNC_BEGIN();
8474         _orig_tracepath_glSamplerParameterIuiv(sampler, pname, param);
8475         goto finish;
8476
8477 finish:
8478         _COREGL_TRACEPATH_FUNC_END();
8479 }
8480
8481 void
8482 tracepath_glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
8483 {
8484         _COREGL_TRACEPATH_FUNC_BEGIN();
8485         _orig_tracepath_glGetSamplerParameterIiv(sampler, pname, params);
8486         goto finish;
8487
8488 finish:
8489         _COREGL_TRACEPATH_FUNC_END();
8490 }
8491
8492 void
8493 tracepath_glGetSamplerParameterIuiv(GLuint sampler, GLenum pname,
8494                                                                         GLuint *params)
8495 {
8496         _COREGL_TRACEPATH_FUNC_BEGIN();
8497         _orig_tracepath_glGetSamplerParameterIuiv(sampler, pname, params);
8498         goto finish;
8499
8500 finish:
8501         _COREGL_TRACEPATH_FUNC_END();
8502 }
8503
8504 void
8505 tracepath_glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
8506 {
8507         _COREGL_TRACEPATH_FUNC_BEGIN();
8508         _orig_tracepath_glTexBuffer(target, internalformat, buffer);
8509         goto finish;
8510
8511 finish:
8512         _COREGL_TRACEPATH_FUNC_END();
8513 }
8514
8515 void
8516 tracepath_glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer,
8517                                                    GLintptr offset, GLsizeiptr size)
8518 {
8519         _COREGL_TRACEPATH_FUNC_BEGIN();
8520         _orig_tracepath_glTexBufferRange(target, internalformat, buffer, offset, size);
8521         goto finish;
8522
8523 finish:
8524         _COREGL_TRACEPATH_FUNC_END();
8525 }
8526
8527 void
8528 tracepath_glTexStorage3DMultisample(GLenum target, GLsizei samples,
8529                                                                         GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
8530                                                                         GLboolean fixedsamplelocations)
8531 {
8532         _COREGL_TRACEPATH_FUNC_BEGIN();
8533         _orig_tracepath_glTexStorage3DMultisample(target, samples, internalformat,
8534                         width, height, depth, fixedsamplelocations);
8535         goto finish;
8536
8537 finish:
8538         _COREGL_TRACEPATH_FUNC_END();
8539 }
8540
8541 void
8542 tracepath_glFramebufferTextureOES(GLenum target, GLenum attachment,
8543                                                                   GLuint texture, GLint level)
8544 {
8545         _COREGL_TRACEPATH_FUNC_BEGIN();
8546
8547 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
8548         tracepath_fbdump_update(0);
8549 #endif
8550
8551         _orig_tracepath_glFramebufferTextureOES(target, attachment, texture, level);
8552
8553 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
8554         tracepath_fbdump_update(1);
8555 #endif
8556
8557         goto finish;
8558
8559 finish:
8560         _COREGL_TRACEPATH_FUNC_END();
8561 }
8562
8563 void
8564 tracepath_glTexBufferRangeOES(GLenum target, GLenum internalformat,
8565                                                           GLuint buffer, GLintptr offset, GLsizeiptr size)
8566 {
8567         _COREGL_TRACEPATH_FUNC_BEGIN();
8568         _orig_tracepath_glTexBufferRangeOES(target, internalformat, buffer, offset,
8569                                                                                 size);
8570         goto finish;
8571
8572 finish:
8573         _COREGL_TRACEPATH_FUNC_END();
8574 }
8575
8576 void
8577 tracepath_glSamplerParameterIuivOES(GLuint sampler, GLenum pname,
8578                                                                         const GLuint *param)
8579 {
8580         _COREGL_TRACEPATH_FUNC_BEGIN();
8581         _orig_tracepath_glSamplerParameterIuivOES(sampler, pname, param);
8582         goto finish;
8583
8584 finish:
8585         _COREGL_TRACEPATH_FUNC_END();
8586 }
8587
8588 void
8589 tracepath_glSamplerParameterIivOES(GLuint sampler, GLenum pname,
8590                                                                    const GLint *param)
8591 {
8592         _COREGL_TRACEPATH_FUNC_BEGIN();
8593         _orig_tracepath_glSamplerParameterIivOES(sampler, pname, param);
8594         goto finish;
8595
8596 finish:
8597         _COREGL_TRACEPATH_FUNC_END();
8598 }
8599
8600 void
8601 tracepath_glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname,
8602                                                                            GLuint *params)
8603 {
8604         _COREGL_TRACEPATH_FUNC_BEGIN();
8605         _orig_tracepath_glGetSamplerParameterIuivOES(sampler, pname, params);
8606         goto finish;
8607
8608 finish:
8609         _COREGL_TRACEPATH_FUNC_END();
8610 }
8611
8612 void
8613 tracepath_glGetSamplerParameterIivOES(GLuint sampler, GLenum pname,
8614                                                                           GLint *params)
8615 {
8616         _COREGL_TRACEPATH_FUNC_BEGIN();
8617         _orig_tracepath_glGetSamplerParameterIivOES(sampler, pname, params);
8618         goto finish;
8619
8620 finish:
8621         _COREGL_TRACEPATH_FUNC_END();
8622 }
8623
8624 void
8625 tracepath_glGetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
8626 {
8627         _COREGL_TRACEPATH_FUNC_BEGIN();
8628         _orig_tracepath_glGetTexParameterIuivOES(target, pname, params);
8629         goto finish;
8630
8631 finish:
8632         _COREGL_TRACEPATH_FUNC_END();
8633 }
8634
8635 void
8636 tracepath_glTexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
8637 {
8638         _COREGL_TRACEPATH_FUNC_BEGIN();
8639         _orig_tracepath_glTexParameterIivOES(target, pname, params);
8640         goto finish;
8641
8642 finish:
8643         _COREGL_TRACEPATH_FUNC_END();
8644 }
8645
8646 void
8647 tracepath_glPatchParameteriOES(GLenum pname, GLint value)
8648 {
8649         _COREGL_TRACEPATH_FUNC_BEGIN();
8650         _orig_tracepath_glPatchParameteriOES(pname, value);
8651         goto finish;
8652
8653 finish:
8654         _COREGL_TRACEPATH_FUNC_END();
8655 }
8656
8657 void
8658 tracepath_glTexParameterIuivOES(GLenum target, GLenum pname,
8659                                                                 const GLuint *params)
8660 {
8661         _COREGL_TRACEPATH_FUNC_BEGIN();
8662         _orig_tracepath_glTexParameterIuivOES(target, pname, params);
8663         goto finish;
8664
8665 finish:
8666         _COREGL_TRACEPATH_FUNC_END();
8667 }
8668
8669 void
8670 tracepath_glGetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
8671 {
8672         _COREGL_TRACEPATH_FUNC_BEGIN();
8673         _orig_tracepath_glGetTexParameterIivOES(target, pname, params);
8674         goto finish;
8675
8676 finish:
8677         _COREGL_TRACEPATH_FUNC_END();
8678 }
8679
8680 void
8681 tracepath_glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname,
8682                                                                           GLint *params)
8683 {
8684         _COREGL_TRACEPATH_FUNC_BEGIN();
8685         _orig_tracepath_glGetSamplerParameterIivEXT(sampler, pname, params);
8686         goto finish;
8687
8688 finish:
8689         _COREGL_TRACEPATH_FUNC_END();
8690 }
8691
8692 void
8693 tracepath_glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname,
8694                                                                            GLuint *params)
8695 {
8696         _COREGL_TRACEPATH_FUNC_BEGIN();
8697         _orig_tracepath_glGetSamplerParameterIuivEXT(sampler, pname, params);
8698         goto finish;
8699
8700 finish:
8701         _COREGL_TRACEPATH_FUNC_END();
8702 }
8703
8704 void
8705 tracepath_glSamplerParameterIivEXT(GLuint sampler, GLenum pname,
8706                                                                    const GLint *param)
8707 {
8708         _COREGL_TRACEPATH_FUNC_BEGIN();
8709         _orig_tracepath_glSamplerParameterIivEXT(sampler, pname, param);
8710         goto finish;
8711
8712 finish:
8713         _COREGL_TRACEPATH_FUNC_END();
8714 }
8715
8716 void
8717 tracepath_glFramebufferTextureEXT(GLenum target, GLenum attachment,
8718                                                                   GLuint texture, GLint level)
8719 {
8720         _COREGL_TRACEPATH_FUNC_BEGIN();
8721
8722 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
8723         tracepath_fbdump_update(0);
8724 #endif
8725
8726         _orig_tracepath_glFramebufferTextureEXT(target, attachment, texture, level);
8727
8728 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
8729         tracepath_fbdump_update(1);
8730 #endif
8731
8732         goto finish;
8733
8734 finish:
8735         _COREGL_TRACEPATH_FUNC_END();
8736 }
8737
8738 void
8739 tracepath_glTexBufferRangeEXT(GLenum target, GLenum internalformat,
8740                                                           GLuint buffer, GLintptr offset, GLsizeiptr size)
8741 {
8742         _COREGL_TRACEPATH_FUNC_BEGIN();
8743         _orig_tracepath_glTexBufferRangeEXT(target, internalformat, buffer, offset,
8744                                                                                 size);
8745         goto finish;
8746
8747 finish:
8748         _COREGL_TRACEPATH_FUNC_END();
8749 }
8750
8751 void
8752 tracepath_glSamplerParameterIuivEXT(GLuint sampler, GLenum pname,
8753                                                                         const GLuint *param)
8754 {
8755         _COREGL_TRACEPATH_FUNC_BEGIN();
8756         _orig_tracepath_glSamplerParameterIuivEXT(sampler, pname, param);
8757         goto finish;
8758
8759 finish:
8760         _COREGL_TRACEPATH_FUNC_END();
8761 }
8762
8763 void
8764 tracepath_glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
8765 {
8766         _COREGL_TRACEPATH_FUNC_BEGIN();
8767         _orig_tracepath_glGetTexParameterIuivEXT(target, pname, params);
8768         goto finish;
8769
8770 finish:
8771         _COREGL_TRACEPATH_FUNC_END();
8772 }
8773
8774 void
8775 tracepath_glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
8776 {
8777         _COREGL_TRACEPATH_FUNC_BEGIN();
8778         _orig_tracepath_glGetTexParameterIivEXT(target, pname, params);
8779         goto finish;
8780
8781 finish:
8782         _COREGL_TRACEPATH_FUNC_END();
8783 }
8784
8785 void
8786 tracepath_glPatchParameteriEXT(GLenum pname, GLint value)
8787 {
8788         _COREGL_TRACEPATH_FUNC_BEGIN();
8789         _orig_tracepath_glPatchParameteriEXT(pname, value);
8790         goto finish;
8791
8792 finish:
8793         _COREGL_TRACEPATH_FUNC_END();
8794 }
8795
8796 void
8797 tracepath_glTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
8798 {
8799         _COREGL_TRACEPATH_FUNC_BEGIN();
8800         _orig_tracepath_glTexParameterIivEXT(target, pname, params);
8801         goto finish;
8802
8803 finish:
8804         _COREGL_TRACEPATH_FUNC_END();
8805 }
8806
8807 void
8808 tracepath_glTexParameterIuivEXT(GLenum target, GLenum pname,
8809                                                                 const GLuint *params)
8810 {
8811         _COREGL_TRACEPATH_FUNC_BEGIN();
8812         _orig_tracepath_glTexParameterIuivEXT(target, pname, params);
8813         goto finish;
8814
8815 finish:
8816         _COREGL_TRACEPATH_FUNC_END();
8817 }
8818 void
8819 tracepath_glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
8820 {
8821         _COREGL_TRACEPATH_FUNC_BEGIN();
8822         _orig_tracepath_glTexBufferOES(target, internalformat, buffer);
8823
8824         goto finish;
8825
8826 finish:
8827         _COREGL_TRACEPATH_FUNC_END();
8828 }
8829
8830 void
8831 tracepath_glFramebufferTextureMultiviewOVR(GLenum target, GLenum attachment,
8832                    GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews)
8833 {
8834         _COREGL_TRACEPATH_FUNC_BEGIN();
8835         _orig_tracepath_glFramebufferTextureMultiviewOVR(target, attachment, texture, level,
8836                                                              baseViewIndex, numViews);
8837         goto finish;
8838
8839 finish:
8840         _COREGL_TRACEPATH_FUNC_END();
8841 }
8842
8843 void
8844 tracepath_glFramebufferTextureMultisampleMultiviewOVR(GLenum target,
8845                    GLenum attachment, GLuint texture, GLint level, GLsizei samples,
8846                    GLint baseViewIndex, GLsizei numViews)
8847 {
8848         _COREGL_TRACEPATH_FUNC_BEGIN();
8849         _orig_tracepath_glFramebufferTextureMultisampleMultiviewOVR(target, attachment, texture, level,
8850                                                                         samples, baseViewIndex, numViews);
8851         goto finish;
8852
8853 finish:
8854         _COREGL_TRACEPATH_FUNC_END();
8855 }