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