src/modules/tracepath/coregl_tracepath_gl.c

   1 #include "coregl_tracepath.h"
   2
   3 #include <stdlib.h>
   4
   5 struct _Glbuf_Data
   6 {
   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         {
  22                 glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY] = target;
  23         }
  24         else
  25         {
  26                 while (data->next != NULL)
  27                 {
  28                         AST(data->obj_idx != target->obj_idx);
  29                         data = data->next;
  30                 }
  31                 AST(data->obj_idx != target->obj_idx);
  32                 data->next = target;
  33         }
  34         goto finish;
  35
  36 finish:
  37         return;
  38 }
  39
  40 static void
  41 __removehash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data **target)
  42 {
  43         Glbuf_Data *data = glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY];
  44         Glbuf_Data *prev = NULL;
  45         while (data != NULL)
  46         {
  47                 if (data->obj_idx == (*target)->obj_idx)
  48                 {
  49                         if (prev != NULL)
  50                                 prev->next = data->next;
  51                         else
  52                                 glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY] = data->next;
  53
  54                         free(*target);
  55                         *target = NULL;
  56                         break;
  57                 }
  58                 prev = data;
  59                 data = data->next;
  60         }
  61         goto finish;
  62
  63 finish:
  64         return;
  65 }
  66
  67 static Glbuf_Data *
  68 __findhash_glbuf_object(Glbuf_Data **glbuf, int obj_idx)
  69 {
  70         Glbuf_Data *data = glbuf[obj_idx % MTD_GLBUF_HASH_ARRAY];
  71         while (data != NULL)
  72         {
  73                 if (data->obj_idx == obj_idx)
  74                         break;
  75                 data = data->next;
  76         }
  77         goto finish;
  78
  79 finish:
  80         return data;
  81 }
  82
  83 void
  84 tracepath_glbuf_clear(Glbuf_Data **glbuf)
  85 {
  86         int i;
  87
  88         for (i = 0; i < MTD_GLBUF_HASH_ARRAY; i++)
  89         {
  90                 Glbuf_Data *data = glbuf[i];
  91
  92                 while (data)
  93                 {
  94                         Glbuf_Data *delitm = data;
  95                         data = data->next;
  96                         free(delitm);
  97                         delitm = NULL;
  98                 }
  99         }
 100 }
 101
 102 static void
 103 _add_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type, int width, int height, int bpp, const char *format)
 104 {
 105         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 106         if (data == NULL)
 107         {
 108                 data = (Glbuf_Data *)calloc(1, sizeof(Glbuf_Data));
 109                 data->obj_idx = obj_idx;
 110                 __addhash_glbuf_object(glbuf, data);
 111         }
 112         else
 113         {
 114                 // Update
 115                 {
 116                         char ment[MAX_TRACE_NAME_LENGTH];
 117                         sprintf(ment, "%s(%4dx%4d %s)", obj_type, data->width, data->height, data->format);
 118                         _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 119                 }
 120         }
 121
 122         data->width = width;
 123         data->height = height;
 124         data->bpp = bpp;
 125         sprintf(data->format, "%s", format);
 126
 127         {
 128                 char ment[MAX_TRACE_NAME_LENGTH];
 129                 sprintf(ment, "%s(%4dx%4d %s)", obj_type, data->width, data->height, data->format);
 130                 _COREGL_TRACE_MEM_ADD(ment, data->width * data->height * data->bpp);
 131         }
 132         goto finish;
 133
 134 finish:
 135         return;
 136 }
 137
 138 static void
 139 _remove_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type)
 140 {
 141         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 142         if (data == NULL)
 143         {
 144                 COREGL_WRN("\E[40;31;1mError deleting %s object %d. (is not created)\E[0m\n", obj_type, obj_idx);
 145                 return;
 146         }
 147
 148         {
 149                 char ment[MAX_TRACE_NAME_LENGTH];
 150                 sprintf(ment, "%s(%4dx%4d %s)", obj_type, data->width, data->height, data->format);
 151                 _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 152         }
 153
 154         __removehash_glbuf_object(glbuf, &data);
 155         goto finish;
 156
 157 finish:
 158         return;
 159 }
 160
 161
 162 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 163 void
 164 _surface_trace_set(int set, GLint fbname, GLenum attachment, MY_MODULE_TSTATE *tstate)
 165 {
 166         int atttype = _COREGL_INT_INIT_VALUE;
 167    _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &atttype);
 168         AST(atttype != _COREGL_INT_INIT_VALUE);
 169         int attname = _COREGL_INT_INIT_VALUE;
 170    _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &attname);
 171         AST(attname != _COREGL_INT_INIT_VALUE);
 172         if (set == 1)
 173         {
 174                 switch (atttype)
 175                 {
 176                         case GL_TEXTURE:
 177                                 //COREGL_LOG("FBO DUMPING BEGIN = (TEX)0x%X\n", attname);
 178                                 {
 179                                         char name[256];
 180                                         sprintf(name, "FBOTEX_0x%X", attname);
 181                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, fbname, attname, 0, -1, -1, -1, NULL);
 182                                 }
 183                                 break;
 184                         case GL_RENDERBUFFER:
 185                                 //COREGL_LOG("FBO DUMPING BEGIN = (RB)0x%X\n", attname);
 186                                 {
 187                                         char name[256];
 188                                         sprintf(name, "FBORB_0x%X", attname);
 189                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, fbname, 0, attname, -1, -1, -1, NULL);
 190                                 }
 191                                 break;
 192                 }
 193         }
 194         else
 195         {
 196                 switch (atttype)
 197                 {
 198                         case GL_TEXTURE:
 199                                 //COREGL_LOG("FBO DUMPING END = (TEX)0x%X\n", attname);
 200                                 {
 201                                         char name[256];
 202                                         sprintf(name, "FBOTEX_0x%X", attname);
 203                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, 0, attname, 0, -1, -1, -1, NULL);
 204                                 }
 205                                 break;
 206                         case GL_RENDERBUFFER:
 207                                 //COREGL_LOG("FBO DUMPING END = (RB)0x%X\n", attname);
 208                                 {
 209                                         char name[256];
 210                                         sprintf(name, "FBORB_0x%X", attname);
 211                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, 0, 0, attname, -1, -1, -1, NULL);
 212                                 }
 213                                 break;
 214                 }
 215         }
 216 }
 217
 218 void
 219 tracepath_fbdump_update(GLint set)
 220 {
 221         if (trace_surface_flag == 1)
 222         {
 223                 GLint fbname = _COREGL_INT_INIT_VALUE;
 224                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 225                 AST(fbname != _COREGL_INT_INIT_VALUE);
 226                 if (fbname != 0)
 227                 {
 228                         MY_MODULE_TSTATE *tstate = NULL;
 229
 230                         GET_MY_TSTATE(tstate, get_current_thread_state());
 231                         AST(tstate != NULL);
 232                         if (tstate->ctx != NULL)
 233                         {
 234                                 _surface_trace_set(set, fbname, GL_COLOR_ATTACHMENT0, tstate);
 235 //                              _surface_trace_set(set, fbname, GL_DEPTH_ATTACHMENT, tstate);
 236 //                              _surface_trace_set(set, fbname, GL_STENCIL_ATTACHMENT, tstate);
 237                         }
 238                 }
 239         }
 240 }
 241 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 242
 243
 244
 245
 246
 247
 248 /* OpenGL ES 2.0 */
 249
 250 void
 251 tracepath_glActiveTexture(GLenum texture)
 252 {
 253         _COREGL_TRACEPATH_FUNC_BEGIN();
 254         _orig_tracepath_glActiveTexture(texture);
 255
 256         goto finish;
 257
 258 finish:
 259         _COREGL_TRACEPATH_FUNC_END();
 260 }
 261
 262 void
 263 tracepath_glAttachShader(GLuint program, GLuint shader)
 264 {
 265         _COREGL_TRACEPATH_FUNC_BEGIN();
 266         _orig_tracepath_glAttachShader(program, shader);
 267
 268         goto finish;
 269
 270 finish:
 271         _COREGL_TRACEPATH_FUNC_END();
 272 }
 273
 274 void
 275 tracepath_glBindAttribLocation(GLuint program, GLuint index, const char* name)
 276 {
 277         _COREGL_TRACEPATH_FUNC_BEGIN();
 278         _orig_tracepath_glBindAttribLocation(program, index, name);
 279
 280         goto finish;
 281
 282 finish:
 283         _COREGL_TRACEPATH_FUNC_END();
 284 }
 285
 286 void
 287 tracepath_glBindBuffer(GLenum target, GLuint buffer)
 288 {
 289         _COREGL_TRACEPATH_FUNC_BEGIN();
 290         _orig_tracepath_glBindBuffer(target, buffer);
 291
 292         goto finish;
 293
 294 finish:
 295         _COREGL_TRACEPATH_FUNC_END();
 296 }
 297
 298 void
 299 tracepath_glBindFramebuffer(GLenum target, GLuint framebuffer)
 300 {
 301         _COREGL_TRACEPATH_FUNC_BEGIN();
 302
 303 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 304         if (unlikely(trace_surface_flag == 1))
 305         {
 306                 GLint oldfb;
 307                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb);
 308                 if (oldfb != 0)
 309                 {
 310                         _COREGL_TRACE_SURFACE(0, 2, "GLBINDFBO");
 311                 }
 312
 313                 tracepath_fbdump_update(0);
 314         }
 315 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 316
 317         _orig_tracepath_glBindFramebuffer(target, framebuffer);
 318
 319 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 320         if (unlikely(trace_surface_flag == 1))
 321         {
 322                 tracepath_fbdump_update(1);
 323         }
 324 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 325
 326         goto finish;
 327
 328 finish:
 329         _COREGL_TRACEPATH_FUNC_END();
 330 }
 331
 332 void
 333 tracepath_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 334 {
 335         _COREGL_TRACEPATH_FUNC_BEGIN();
 336         _orig_tracepath_glBindRenderbuffer(target, renderbuffer);
 337
 338         goto finish;
 339
 340 finish:
 341         _COREGL_TRACEPATH_FUNC_END();
 342 }
 343
 344 void
 345 tracepath_glBindTexture(GLenum target, GLuint texture)
 346 {
 347         _COREGL_TRACEPATH_FUNC_BEGIN();
 348
 349         _COREGL_TRACE_SURFACE(0, 1, "GLBINDTEXTURE");
 350         _orig_tracepath_glBindTexture(target, texture);
 351
 352         goto finish;
 353
 354 finish:
 355         _COREGL_TRACEPATH_FUNC_END();
 356 }
 357
 358 void
 359 tracepath_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 360 {
 361         _COREGL_TRACEPATH_FUNC_BEGIN();
 362         _orig_tracepath_glBlendColor(red, green, blue, alpha);
 363
 364         goto finish;
 365
 366 finish:
 367         _COREGL_TRACEPATH_FUNC_END();
 368 }
 369
 370 void
 371 tracepath_glBlendEquation(GLenum mode)
 372 {
 373         _COREGL_TRACEPATH_FUNC_BEGIN();
 374         _orig_tracepath_glBlendEquation(mode);
 375
 376         goto finish;
 377
 378 finish:
 379         _COREGL_TRACEPATH_FUNC_END();
 380 }
 381
 382 void
 383 tracepath_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 384 {
 385         _COREGL_TRACEPATH_FUNC_BEGIN();
 386         _orig_tracepath_glBlendEquationSeparate(modeRGB, modeAlpha);
 387
 388         goto finish;
 389
 390 finish:
 391         _COREGL_TRACEPATH_FUNC_END();
 392 }
 393
 394 void
 395 tracepath_glBlendFunc(GLenum sfactor, GLenum dfactor)
 396 {
 397         _COREGL_TRACEPATH_FUNC_BEGIN();
 398         _orig_tracepath_glBlendFunc(sfactor, dfactor);
 399
 400         goto finish;
 401
 402 finish:
 403         _COREGL_TRACEPATH_FUNC_END();
 404 }
 405
 406 void
 407 tracepath_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 408 {
 409         _COREGL_TRACEPATH_FUNC_BEGIN();
 410         _orig_tracepath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 411
 412         goto finish;
 413
 414 finish:
 415         _COREGL_TRACEPATH_FUNC_END();
 416 }
 417
 418 void
 419 tracepath_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
 420 {
 421         _COREGL_TRACEPATH_FUNC_BEGIN();
 422         _orig_tracepath_glBufferData(target, size, data, usage);
 423
 424         goto finish;
 425
 426 finish:
 427         _COREGL_TRACEPATH_FUNC_END();
 428 }
 429
 430 void
 431 tracepath_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
 432 {
 433         _COREGL_TRACEPATH_FUNC_BEGIN();
 434         _orig_tracepath_glBufferSubData(target, offset, size, data);
 435
 436         goto finish;
 437
 438 finish:
 439         _COREGL_TRACEPATH_FUNC_END();
 440 }
 441
 442 GLenum
 443 tracepath_glCheckFramebufferStatus(GLenum target)
 444 {
 445         GLenum ret = GL_NONE;
 446
 447         _COREGL_TRACEPATH_FUNC_BEGIN();
 448         ret = _orig_tracepath_glCheckFramebufferStatus(target);
 449
 450         goto finish;
 451
 452 finish:
 453         _COREGL_TRACEPATH_FUNC_END();
 454         return ret;
 455 }
 456
 457 void
 458 tracepath_glClear(GLbitfield mask)
 459 {
 460         _COREGL_TRACEPATH_FUNC_BEGIN();
 461         _orig_tracepath_glClear(mask);
 462
 463         goto finish;
 464
 465 finish:
 466         _COREGL_TRACEPATH_FUNC_END();
 467 }
 468
 469 void
 470 tracepath_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 471 {
 472         _COREGL_TRACEPATH_FUNC_BEGIN();
 473         _orig_tracepath_glClearColor(red, green, blue, alpha);
 474
 475         goto finish;
 476
 477 finish:
 478         _COREGL_TRACEPATH_FUNC_END();
 479 }
 480
 481 void
 482 tracepath_glClearDepthf(GLclampf depth)
 483 {
 484         _COREGL_TRACEPATH_FUNC_BEGIN();
 485         _orig_tracepath_glClearDepthf(depth);
 486
 487         goto finish;
 488
 489 finish:
 490         _COREGL_TRACEPATH_FUNC_END();
 491 }
 492
 493 void
 494 tracepath_glClearStencil(GLint s)
 495 {
 496         _COREGL_TRACEPATH_FUNC_BEGIN();
 497         _orig_tracepath_glClearStencil(s);
 498
 499         goto finish;
 500
 501 finish:
 502         _COREGL_TRACEPATH_FUNC_END();
 503 }
 504
 505 void
 506 tracepath_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 507 {
 508         _COREGL_TRACEPATH_FUNC_BEGIN();
 509         _orig_tracepath_glColorMask(red, green, blue, alpha);
 510
 511         goto finish;
 512
 513 finish:
 514         _COREGL_TRACEPATH_FUNC_END();
 515 }
 516
 517 void
 518 tracepath_glCompileShader(GLuint shader)
 519 {
 520         _COREGL_TRACEPATH_FUNC_BEGIN();
 521         _orig_tracepath_glCompileShader(shader);
 522
 523         goto finish;
 524
 525 finish:
 526         _COREGL_TRACEPATH_FUNC_END();
 527 }
 528
 529 void
 530 tracepath_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 531 {
 532         _COREGL_TRACEPATH_FUNC_BEGIN();
 533         _orig_tracepath_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 534
 535         goto finish;
 536
 537 finish:
 538         _COREGL_TRACEPATH_FUNC_END();
 539 }
 540
 541 void
 542 tracepath_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
 543 {
 544         _COREGL_TRACEPATH_FUNC_BEGIN();
 545         _orig_tracepath_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 546
 547         goto finish;
 548
 549 finish:
 550         _COREGL_TRACEPATH_FUNC_END();
 551 }
 552
 553 void
 554 tracepath_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 555 {
 556         _COREGL_TRACEPATH_FUNC_BEGIN();
 557         _orig_tracepath_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 558
 559         goto finish;
 560
 561 finish:
 562         _COREGL_TRACEPATH_FUNC_END();
 563 }
 564
 565 void
 566 tracepath_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 567 {
 568         _COREGL_TRACEPATH_FUNC_BEGIN();
 569         _orig_tracepath_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 570
 571         goto finish;
 572
 573 finish:
 574         _COREGL_TRACEPATH_FUNC_END();
 575 }
 576
 577 GLuint
 578 tracepath_glCreateProgram(void)
 579 {
 580         GLuint ret = _COREGL_INT_INIT_VALUE;
 581
 582         _COREGL_TRACEPATH_FUNC_BEGIN();
 583         ret = _orig_tracepath_glCreateProgram();
 584
 585         goto finish;
 586
 587 finish:
 588         _COREGL_TRACEPATH_FUNC_END();
 589         return ret;
 590 }
 591
 592 GLuint
 593 tracepath_glCreateShader(GLenum type)
 594 {
 595         GLuint ret = _COREGL_INT_INIT_VALUE;
 596         _COREGL_TRACEPATH_FUNC_BEGIN();
 597         ret = _orig_tracepath_glCreateShader(type);
 598
 599         goto finish;
 600
 601 finish:
 602         _COREGL_TRACEPATH_FUNC_END();
 603         return ret;
 604 }
 605
 606 void
 607 tracepath_glCullFace(GLenum mode)
 608 {
 609         _COREGL_TRACEPATH_FUNC_BEGIN();
 610         _orig_tracepath_glCullFace(mode);
 611
 612         goto finish;
 613
 614 finish:
 615         _COREGL_TRACEPATH_FUNC_END();
 616 }
 617
 618 void
 619 tracepath_glDeleteBuffers(GLsizei n, const GLuint* buffers)
 620 {
 621         _COREGL_TRACEPATH_FUNC_BEGIN();
 622         _orig_tracepath_glDeleteBuffers(n, buffers);
 623
 624         goto finish;
 625
 626 finish:
 627         _COREGL_TRACEPATH_FUNC_END();
 628 }
 629
 630 void
 631 tracepath_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 632 {
 633         _COREGL_TRACEPATH_FUNC_BEGIN();
 634
 635 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 636         tracepath_fbdump_update(0);
 637 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 638
 639         _orig_tracepath_glDeleteFramebuffers(n, framebuffers);
 640
 641 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 642         tracepath_fbdump_update(1);
 643 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 644
 645         goto finish;
 646
 647 finish:
 648         _COREGL_TRACEPATH_FUNC_END();
 649 }
 650
 651 void
 652 tracepath_glDeleteProgram(GLuint program)
 653 {
 654         _COREGL_TRACEPATH_FUNC_BEGIN();
 655         _orig_tracepath_glDeleteProgram(program);
 656
 657         goto finish;
 658
 659 finish:
 660         _COREGL_TRACEPATH_FUNC_END();
 661 }
 662
 663 void
 664 tracepath_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 665 {
 666         _COREGL_TRACEPATH_FUNC_BEGIN();
 667
 668 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 669         tracepath_fbdump_update(0);
 670 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 671
 672         _orig_tracepath_glDeleteRenderbuffers(n, renderbuffers);
 673
 674 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 675         tracepath_fbdump_update(1);
 676 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 677
 678         goto finish;
 679
 680 finish:
 681         _COREGL_TRACEPATH_FUNC_END();
 682 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 683         if (trace_mem_flag == 1)
 684         {
 685                 MY_MODULE_TSTATE *tstate = NULL;
 686
 687                 GET_MY_TSTATE(tstate, get_current_thread_state());
 688                 AST(tstate != NULL);
 689                 if (tstate->ctx != NULL)
 690                 {
 691                         for (int i = 0; i < n; i++)
 692                         {
 693                                 if (renderbuffers[i] == 0) continue;
 694                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i], "Renderbuffer");
 695                         }
 696                 }
 697         }
 698 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 699 }
 700
 701 void
 702 tracepath_glDeleteShader(GLuint shader)
 703 {
 704         _COREGL_TRACEPATH_FUNC_BEGIN();
 705         _orig_tracepath_glDeleteShader(shader);
 706
 707         goto finish;
 708
 709 finish:
 710         _COREGL_TRACEPATH_FUNC_END();
 711 }
 712
 713 void
 714 tracepath_glDeleteTextures(GLsizei n, const GLuint* textures)
 715 {
 716         _COREGL_TRACEPATH_FUNC_BEGIN();
 717
 718 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 719         tracepath_fbdump_update(0);
 720 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 721
 722         _orig_tracepath_glDeleteTextures(n, textures);
 723
 724 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 725         tracepath_fbdump_update(1);
 726 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 727
 728         goto finish;
 729
 730 finish:
 731         _COREGL_TRACEPATH_FUNC_END();
 732 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 733         if (trace_mem_flag == 1)
 734         {
 735                 MY_MODULE_TSTATE *tstate = NULL;
 736
 737                 GET_MY_TSTATE(tstate, get_current_thread_state());
 738                 AST(tstate != NULL);
 739                 if (tstate->ctx != NULL)
 740                 {
 741                         for (int i = 0; i < n; i++)
 742                         {
 743                                 if (textures[i] == 0) continue;
 744                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture");
 745                         }
 746                 }
 747         }
 748 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 749 }
 750
 751 void
 752 tracepath_glDepthFunc(GLenum func)
 753 {
 754         _COREGL_TRACEPATH_FUNC_BEGIN();
 755         _orig_tracepath_glDepthFunc(func);
 756
 757         goto finish;
 758
 759 finish:
 760         _COREGL_TRACEPATH_FUNC_END();
 761 }
 762
 763 void
 764 tracepath_glDepthMask(GLboolean flag)
 765 {
 766         _COREGL_TRACEPATH_FUNC_BEGIN();
 767         _orig_tracepath_glDepthMask(flag);
 768
 769         goto finish;
 770
 771 finish:
 772         _COREGL_TRACEPATH_FUNC_END();
 773 }
 774
 775 void
 776 tracepath_glDepthRangef(GLclampf zNear, GLclampf zFar)
 777 {
 778         _COREGL_TRACEPATH_FUNC_BEGIN();
 779         _orig_tracepath_glDepthRangef(zNear, zFar);
 780
 781         goto finish;
 782
 783 finish:
 784         _COREGL_TRACEPATH_FUNC_END();
 785 }
 786
 787 void
 788 tracepath_glDetachShader(GLuint program, GLuint shader)
 789 {
 790         _COREGL_TRACEPATH_FUNC_BEGIN();
 791         _orig_tracepath_glDetachShader(program, shader);
 792
 793         goto finish;
 794
 795 finish:
 796         _COREGL_TRACEPATH_FUNC_END();
 797 }
 798
 799 void
 800 tracepath_glDisable(GLenum cap)
 801 {
 802         _COREGL_TRACEPATH_FUNC_BEGIN();
 803         _orig_tracepath_glDisable(cap);
 804
 805         goto finish;
 806
 807 finish:
 808         _COREGL_TRACEPATH_FUNC_END();
 809 }
 810
 811 void
 812 tracepath_glDisableVertexAttribArray(GLuint index)
 813 {
 814         _COREGL_TRACEPATH_FUNC_BEGIN();
 815         _orig_tracepath_glDisableVertexAttribArray(index);
 816
 817         goto finish;
 818
 819 finish:
 820         _COREGL_TRACEPATH_FUNC_END();
 821 }
 822
 823 void
 824 tracepath_glDrawArrays(GLenum mode, GLint first, GLsizei count)
 825 {
 826         _COREGL_TRACEPATH_FUNC_BEGIN();
 827         _orig_tracepath_glDrawArrays(mode, first, count);
 828
 829         goto finish;
 830
 831 finish:
 832         _COREGL_TRACEPATH_FUNC_END();
 833 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 834         if (trace_surface_flag == 1)
 835         {
 836                 GLint fbname = _COREGL_INT_INIT_VALUE;
 837                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 838                 AST(fbname != _COREGL_INT_INIT_VALUE);
 839                 if (fbname == 0)
 840                 {
 841                         char name[256];
 842                         EGLint btype;
 843                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
 844                         if (btype == EGL_SINGLE_BUFFER)
 845                                 sprintf(name, "EGLPIXMAP_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 846                         else
 847                                 sprintf(name, "EGLWINDOW_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 848                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentContext(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
 849                 }
 850    }
 851 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 852 }
 853
 854 void
 855 tracepath_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
 856 {
 857         _COREGL_TRACEPATH_FUNC_BEGIN();
 858         _orig_tracepath_glDrawElements(mode, count, type, indices);
 859
 860         goto finish;
 861
 862 finish:
 863         _COREGL_TRACEPATH_FUNC_END();
 864 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 865         if (trace_surface_flag == 1)
 866         {
 867                 GLint fbname = _COREGL_INT_INIT_VALUE;
 868                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 869                 AST(fbname != _COREGL_INT_INIT_VALUE);
 870                 if (fbname == 0)
 871                 {
 872                         char name[256];
 873                         EGLint btype;
 874                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
 875                         if (btype == EGL_SINGLE_BUFFER)
 876                                 sprintf(name, "EGLPIXMAP_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 877                         else
 878                                 sprintf(name, "EGLWINDOW_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 879                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentContext(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
 880                 }
 881    }
 882 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 883 }
 884
 885 void
 886 tracepath_glEnable(GLenum cap)
 887 {
 888         _COREGL_TRACEPATH_FUNC_BEGIN();
 889         _orig_tracepath_glEnable(cap);
 890
 891         goto finish;
 892
 893 finish:
 894         _COREGL_TRACEPATH_FUNC_END();
 895 }
 896
 897 void
 898 tracepath_glEnableVertexAttribArray(GLuint index)
 899 {
 900         _COREGL_TRACEPATH_FUNC_BEGIN();
 901         _orig_tracepath_glEnableVertexAttribArray(index);
 902
 903         goto finish;
 904
 905 finish:
 906         _COREGL_TRACEPATH_FUNC_END();
 907 }
 908
 909 void
 910 tracepath_glFinish(void)
 911 {
 912         _COREGL_TRACEPATH_FUNC_BEGIN();
 913         _orig_tracepath_glFinish();
 914
 915         _COREGL_TRACE_SURFACE(0, 0, "GLFINISH");
 916
 917         goto finish;
 918
 919 finish:
 920         _COREGL_TRACEPATH_FUNC_END();
 921         _COREGL_TRACE_API_OUTPUT(0);
 922         _COREGL_TRACE_MEM_OUTPUT(0);
 923 }
 924
 925 void
 926 tracepath_glFlush(void)
 927 {
 928         _COREGL_TRACEPATH_FUNC_BEGIN();
 929         _orig_tracepath_glFlush();
 930
 931         _COREGL_TRACE_SURFACE(0, 0, "GLFLUSH");
 932
 933         goto finish;
 934
 935 finish:
 936         _COREGL_TRACEPATH_FUNC_END();
 937         _COREGL_TRACE_API_OUTPUT(0);
 938         _COREGL_TRACE_MEM_OUTPUT(0);
 939 }
 940
 941 void
 942 tracepath_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 943 {
 944         _COREGL_TRACEPATH_FUNC_BEGIN();
 945
 946 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 947         tracepath_fbdump_update(0);
 948 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 949
 950         _orig_tracepath_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 951
 952 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 953         tracepath_fbdump_update(1);
 954 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 955
 956         goto finish;
 957
 958 finish:
 959         _COREGL_TRACEPATH_FUNC_END();
 960 }
 961
 962 void
 963 tracepath_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 964 {
 965         _COREGL_TRACEPATH_FUNC_BEGIN();
 966
 967 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 968         tracepath_fbdump_update(0);
 969 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 970
 971         _orig_tracepath_glFramebufferTexture2D(target, attachment, textarget, texture, level);
 972
 973 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 974         tracepath_fbdump_update(1);
 975 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 976
 977         goto finish;
 978
 979 finish:
 980         _COREGL_TRACEPATH_FUNC_END();
 981 }
 982
 983 void
 984 tracepath_glFrontFace(GLenum mode)
 985 {
 986         _COREGL_TRACEPATH_FUNC_BEGIN();
 987         _orig_tracepath_glFrontFace(mode);
 988
 989         goto finish;
 990
 991 finish:
 992         _COREGL_TRACEPATH_FUNC_END();
 993 }
 994
 995 void
 996 tracepath_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 997 {
 998         _COREGL_TRACEPATH_FUNC_BEGIN();
 999         _orig_tracepath_glGetVertexAttribfv(index, pname, params);
1000
1001
1002         goto finish;
1003
1004 finish:
1005         _COREGL_TRACEPATH_FUNC_END();
1006 }
1007
1008 void
1009 tracepath_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
1010 {
1011         _COREGL_TRACEPATH_FUNC_BEGIN();
1012         _orig_tracepath_glGetVertexAttribiv(index, pname, params);
1013
1014
1015         goto finish;
1016
1017 finish:
1018         _COREGL_TRACEPATH_FUNC_END();
1019 }
1020
1021 void
1022 tracepath_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
1023 {
1024         _COREGL_TRACEPATH_FUNC_BEGIN();
1025         _orig_tracepath_glGetVertexAttribPointerv(index, pname, pointer);
1026
1027
1028
1029         goto finish;
1030
1031 finish:
1032         _COREGL_TRACEPATH_FUNC_END();
1033 }
1034
1035 void
1036 tracepath_glHint(GLenum target, GLenum mode)
1037 {
1038         _COREGL_TRACEPATH_FUNC_BEGIN();
1039         _orig_tracepath_glHint(target, mode);
1040
1041         goto finish;
1042
1043 finish:
1044         _COREGL_TRACEPATH_FUNC_END();
1045 }
1046
1047 void
1048 tracepath_glGenBuffers(GLsizei n, GLuint* buffers)
1049 {
1050         _COREGL_TRACEPATH_FUNC_BEGIN();
1051         _orig_tracepath_glGenBuffers(n, buffers);
1052
1053         goto finish;
1054
1055 finish:
1056         _COREGL_TRACEPATH_FUNC_END();
1057 }
1058
1059 void
1060 tracepath_glGenerateMipmap(GLenum target)
1061 {
1062         _COREGL_TRACEPATH_FUNC_BEGIN();
1063         _orig_tracepath_glGenerateMipmap(target);
1064
1065         goto finish;
1066
1067 finish:
1068         _COREGL_TRACEPATH_FUNC_END();
1069 }
1070
1071 void
1072 tracepath_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
1073 {
1074         _COREGL_TRACEPATH_FUNC_BEGIN();
1075         _orig_tracepath_glGenFramebuffers(n, framebuffers);
1076
1077         goto finish;
1078
1079 finish:
1080         _COREGL_TRACEPATH_FUNC_END();
1081 }
1082
1083 void
1084 tracepath_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1085 {
1086         _COREGL_TRACEPATH_FUNC_BEGIN();
1087         _orig_tracepath_glGenRenderbuffers(n, renderbuffers);
1088
1089         goto finish;
1090
1091 finish:
1092         _COREGL_TRACEPATH_FUNC_END();
1093 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1094         if (trace_mem_flag == 1)
1095         {
1096                 MY_MODULE_TSTATE *tstate = NULL;
1097
1098                 GET_MY_TSTATE(tstate, get_current_thread_state());
1099                 AST(tstate != NULL);
1100                 if (tstate->ctx != NULL)
1101                 {
1102                         for (int i = 0; i < n; i++)
1103                         {
1104                                 if (renderbuffers[i] == 0) continue;
1105                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i], "Renderbuffer", 0, 0, 0, "Unknown");
1106                         }
1107                 }
1108         }
1109 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1110 }
1111
1112 void
1113 tracepath_glGenTextures(GLsizei n, GLuint* textures)
1114 {
1115         _COREGL_TRACEPATH_FUNC_BEGIN();
1116         _orig_tracepath_glGenTextures(n, textures);
1117
1118         goto finish;
1119
1120 finish:
1121         _COREGL_TRACEPATH_FUNC_END();
1122 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1123         if (trace_mem_flag == 1)
1124         {
1125                 MY_MODULE_TSTATE *tstate = NULL;
1126
1127                 GET_MY_TSTATE(tstate, get_current_thread_state());
1128                 AST(tstate != NULL);
1129                 if (tstate->ctx != NULL)
1130                 {
1131                         for (int i = 0; i < n; i++)
1132                         {
1133                                 if (textures[i] == 0) continue;
1134                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture", 0, 0, 0, "Unknown");
1135                         }
1136                 }
1137         }
1138 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1139 }
1140
1141 void
1142 tracepath_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
1143 {
1144         _COREGL_TRACEPATH_FUNC_BEGIN();
1145         _orig_tracepath_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
1146
1147         goto finish;
1148
1149 finish:
1150         _COREGL_TRACEPATH_FUNC_END();
1151 }
1152
1153 void
1154 tracepath_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
1155 {
1156         _COREGL_TRACEPATH_FUNC_BEGIN();
1157         _orig_tracepath_glGetActiveUniform(program, index, bufsize, length, size, type, name);
1158
1159         goto finish;
1160
1161 finish:
1162         _COREGL_TRACEPATH_FUNC_END();
1163 }
1164
1165 void
1166 tracepath_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
1167 {
1168         _COREGL_TRACEPATH_FUNC_BEGIN();
1169         _orig_tracepath_glGetAttachedShaders(program, maxcount, count, shaders);
1170
1171         goto finish;
1172
1173 finish:
1174         _COREGL_TRACEPATH_FUNC_END();
1175 }
1176
1177 int
1178 tracepath_glGetAttribLocation(GLuint program, const char* name)
1179 {
1180         int ret = _COREGL_INT_INIT_VALUE;
1181         _COREGL_TRACEPATH_FUNC_BEGIN();
1182         ret = _orig_tracepath_glGetAttribLocation(program, name);
1183
1184         goto finish;
1185
1186 finish:
1187         _COREGL_TRACEPATH_FUNC_END();
1188         return ret;
1189 }
1190
1191 void
1192 tracepath_glGetBooleanv(GLenum pname, GLboolean* params)
1193 {
1194         _COREGL_TRACEPATH_FUNC_BEGIN();
1195         _orig_tracepath_glGetBooleanv(pname, params);
1196
1197         goto finish;
1198
1199 finish:
1200         _COREGL_TRACEPATH_FUNC_END();
1201 }
1202
1203 void
1204 tracepath_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1205 {
1206         _COREGL_TRACEPATH_FUNC_BEGIN();
1207         _orig_tracepath_glGetBufferParameteriv(target, pname, params);
1208
1209         goto finish;
1210
1211 finish:
1212         _COREGL_TRACEPATH_FUNC_END();
1213 }
1214
1215 GLenum
1216 tracepath_glGetError(void)
1217 {
1218         GLenum ret = GL_NONE;
1219
1220         _COREGL_TRACEPATH_FUNC_BEGIN();
1221         ret = _orig_tracepath_glGetError();
1222         goto finish;
1223
1224 finish:
1225         _COREGL_TRACEPATH_FUNC_END();
1226         return ret;
1227 }
1228
1229 void
1230 tracepath_glGetFloatv(GLenum pname, GLfloat* params)
1231 {
1232         _COREGL_TRACEPATH_FUNC_BEGIN();
1233         _orig_tracepath_glGetFloatv(pname, params);
1234
1235         goto finish;
1236
1237 finish:
1238         _COREGL_TRACEPATH_FUNC_END();
1239 }
1240
1241 void
1242 tracepath_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1243 {
1244         _COREGL_TRACEPATH_FUNC_BEGIN();
1245         _orig_tracepath_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
1246
1247         goto finish;
1248
1249 finish:
1250         _COREGL_TRACEPATH_FUNC_END();
1251 }
1252
1253 void
1254 tracepath_glGetIntegerv(GLenum pname, GLint* params)
1255 {
1256         _COREGL_TRACEPATH_FUNC_BEGIN();
1257         _orig_tracepath_glGetIntegerv(pname, params);
1258
1259         goto finish;
1260
1261 finish:
1262         _COREGL_TRACEPATH_FUNC_END();
1263 }
1264
1265 void
1266 tracepath_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
1267 {
1268         _COREGL_TRACEPATH_FUNC_BEGIN();
1269         _orig_tracepath_glGetProgramiv(program, pname, params);
1270
1271         goto finish;
1272
1273 finish:
1274         _COREGL_TRACEPATH_FUNC_END();
1275 }
1276
1277 void
1278 tracepath_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
1279 {
1280         _COREGL_TRACEPATH_FUNC_BEGIN();
1281         _orig_tracepath_glGetProgramInfoLog(program, bufsize, length, infolog);
1282
1283         goto finish;
1284
1285 finish:
1286         _COREGL_TRACEPATH_FUNC_END();
1287 }
1288
1289 void
1290 tracepath_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1291 {
1292         _COREGL_TRACEPATH_FUNC_BEGIN();
1293         _orig_tracepath_glGetRenderbufferParameteriv(target, pname, params);
1294
1295         goto finish;
1296
1297 finish:
1298         _COREGL_TRACEPATH_FUNC_END();
1299 }
1300
1301 void
1302 tracepath_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
1303 {
1304         _COREGL_TRACEPATH_FUNC_BEGIN();
1305         _orig_tracepath_glGetShaderiv(shader, pname, params);
1306
1307         goto finish;
1308
1309 finish:
1310         _COREGL_TRACEPATH_FUNC_END();
1311 }
1312
1313 void
1314 tracepath_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
1315 {
1316         _COREGL_TRACEPATH_FUNC_BEGIN();
1317         _orig_tracepath_glGetShaderInfoLog(shader, bufsize, length, infolog);
1318
1319         goto finish;
1320
1321 finish:
1322         _COREGL_TRACEPATH_FUNC_END();
1323 }
1324
1325 void
1326 tracepath_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
1327 {
1328         _COREGL_TRACEPATH_FUNC_BEGIN();
1329         _orig_tracepath_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
1330
1331         goto finish;
1332
1333 finish:
1334         _COREGL_TRACEPATH_FUNC_END();
1335 }
1336
1337 void
1338 tracepath_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
1339 {
1340         _COREGL_TRACEPATH_FUNC_BEGIN();
1341         _orig_tracepath_glGetShaderSource(shader, bufsize, length, source);
1342
1343         goto finish;
1344
1345 finish:
1346         _COREGL_TRACEPATH_FUNC_END();
1347 }
1348
1349 const GLubyte *
1350 tracepath_glGetString(GLenum name)
1351 {
1352         const GLubyte *ret = NULL;
1353
1354         _COREGL_TRACEPATH_FUNC_BEGIN();
1355         ret = _orig_tracepath_glGetString(name);
1356
1357         goto finish;
1358
1359 finish:
1360         _COREGL_TRACEPATH_FUNC_END();
1361         return ret;
1362 }
1363
1364 void
1365 tracepath_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1366 {
1367         _COREGL_TRACEPATH_FUNC_BEGIN();
1368         _orig_tracepath_glGetTexParameterfv(target, pname, params);
1369
1370         goto finish;
1371
1372 finish:
1373         _COREGL_TRACEPATH_FUNC_END();
1374 }
1375
1376 void
1377 tracepath_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1378 {
1379         _COREGL_TRACEPATH_FUNC_BEGIN();
1380         _orig_tracepath_glGetTexParameteriv(target, pname, params);
1381
1382         goto finish;
1383
1384 finish:
1385         _COREGL_TRACEPATH_FUNC_END();
1386 }
1387
1388 void
1389 tracepath_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
1390 {
1391         _COREGL_TRACEPATH_FUNC_BEGIN();
1392         _orig_tracepath_glGetUniformfv(program, location, params);
1393
1394         goto finish;
1395
1396 finish:
1397         _COREGL_TRACEPATH_FUNC_END();
1398 }
1399
1400 void
1401 tracepath_glGetUniformiv(GLuint program, GLint location, GLint* params)
1402 {
1403         _COREGL_TRACEPATH_FUNC_BEGIN();
1404         _orig_tracepath_glGetUniformiv(program, location, params);
1405
1406         goto finish;
1407
1408 finish:
1409         _COREGL_TRACEPATH_FUNC_END();
1410 }
1411 int
1412 tracepath_glGetUniformLocation(GLuint program, const char* name)
1413 {
1414         int ret = _COREGL_INT_INIT_VALUE;
1415
1416         _COREGL_TRACEPATH_FUNC_BEGIN();
1417         ret = _orig_tracepath_glGetUniformLocation(program, name);
1418
1419         goto finish;
1420
1421 finish:
1422         _COREGL_TRACEPATH_FUNC_END();
1423         return ret;
1424 }
1425
1426 GLboolean
1427 tracepath_glIsBuffer(GLuint buffer)
1428 {
1429         GLboolean ret = GL_FALSE;
1430
1431         _COREGL_TRACEPATH_FUNC_BEGIN();
1432         ret = _orig_tracepath_glIsBuffer(buffer);
1433
1434         goto finish;
1435
1436 finish:
1437         _COREGL_TRACEPATH_FUNC_END();
1438         return ret;
1439 }
1440
1441 GLboolean
1442 tracepath_glIsEnabled(GLenum cap)
1443 {
1444         GLboolean ret = GL_FALSE;
1445
1446         _COREGL_TRACEPATH_FUNC_BEGIN();
1447         ret = _orig_tracepath_glIsEnabled(cap);
1448
1449         goto finish;
1450
1451 finish:
1452         _COREGL_TRACEPATH_FUNC_END();
1453         return ret;
1454 }
1455
1456 GLboolean
1457 tracepath_glIsFramebuffer(GLuint framebuffer)
1458 {
1459         GLboolean ret = GL_FALSE;
1460
1461         _COREGL_TRACEPATH_FUNC_BEGIN();
1462         ret = _orig_tracepath_glIsFramebuffer(framebuffer);
1463
1464         goto finish;
1465
1466 finish:
1467         _COREGL_TRACEPATH_FUNC_END();
1468         return ret;
1469 }
1470
1471 GLboolean
1472 tracepath_glIsProgram(GLuint program)
1473 {
1474         GLboolean ret;
1475         _COREGL_TRACEPATH_FUNC_BEGIN();
1476         ret = _orig_tracepath_glIsProgram(program);
1477
1478         goto finish;
1479
1480 finish:
1481         _COREGL_TRACEPATH_FUNC_END();
1482         return ret;
1483 }
1484
1485 GLboolean
1486 tracepath_glIsRenderbuffer(GLuint renderbuffer)
1487 {
1488         GLboolean ret;
1489         _COREGL_TRACEPATH_FUNC_BEGIN();
1490         ret = _orig_tracepath_glIsRenderbuffer(renderbuffer);
1491
1492         goto finish;
1493
1494 finish:
1495         _COREGL_TRACEPATH_FUNC_END();
1496         return ret;
1497 }
1498
1499 GLboolean
1500 tracepath_glIsShader(GLuint shader)
1501 {
1502         GLboolean ret;
1503         _COREGL_TRACEPATH_FUNC_BEGIN();
1504         ret = _orig_tracepath_glIsShader(shader);
1505
1506         goto finish;
1507
1508 finish:
1509         _COREGL_TRACEPATH_FUNC_END();
1510         return ret;
1511 }
1512
1513 GLboolean
1514 tracepath_glIsTexture(GLuint texture)
1515 {
1516         GLboolean ret;
1517         _COREGL_TRACEPATH_FUNC_BEGIN();
1518         ret = _orig_tracepath_glIsTexture(texture);
1519
1520         goto finish;
1521
1522 finish:
1523         _COREGL_TRACEPATH_FUNC_END();
1524         return ret;
1525 }
1526
1527 void
1528 tracepath_glLineWidth(GLfloat width)
1529 {
1530         _COREGL_TRACEPATH_FUNC_BEGIN();
1531         _orig_tracepath_glLineWidth(width);
1532
1533         goto finish;
1534
1535 finish:
1536         _COREGL_TRACEPATH_FUNC_END();
1537 }
1538
1539 void
1540 tracepath_glLinkProgram(GLuint program)
1541 {
1542         _COREGL_TRACEPATH_FUNC_BEGIN();
1543         _orig_tracepath_glLinkProgram(program);
1544
1545         goto finish;
1546
1547 finish:
1548         _COREGL_TRACEPATH_FUNC_END();
1549 }
1550
1551 void
1552 tracepath_glPixelStorei(GLenum pname, GLint param)
1553 {
1554         _COREGL_TRACEPATH_FUNC_BEGIN();
1555         _orig_tracepath_glPixelStorei(pname, param);
1556
1557         goto finish;
1558
1559 finish:
1560         _COREGL_TRACEPATH_FUNC_END();
1561 }
1562
1563 void
1564 tracepath_glPolygonOffset(GLfloat factor, GLfloat units)
1565 {
1566         _COREGL_TRACEPATH_FUNC_BEGIN();
1567         _orig_tracepath_glPolygonOffset(factor, units);
1568
1569         goto finish;
1570
1571 finish:
1572         _COREGL_TRACEPATH_FUNC_END();
1573 }
1574
1575 void
1576 tracepath_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
1577 {
1578         _COREGL_TRACEPATH_FUNC_BEGIN();
1579         _orig_tracepath_glReadPixels(x, y, width, height, format, type, pixels);
1580
1581         goto finish;
1582
1583 finish:
1584         _COREGL_TRACEPATH_FUNC_END();
1585 }
1586
1587 void
1588 tracepath_glReleaseShaderCompiler(void)
1589 {
1590         _COREGL_TRACEPATH_FUNC_BEGIN();
1591         _orig_tracepath_glReleaseShaderCompiler();
1592
1593         goto finish;
1594
1595 finish:
1596         _COREGL_TRACEPATH_FUNC_END();
1597 }
1598
1599 void
1600 tracepath_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1601 {
1602         _COREGL_TRACEPATH_FUNC_BEGIN();
1603
1604         _orig_tracepath_glRenderbufferStorage(target, internalformat, width, height);
1605
1606         goto finish;
1607
1608 finish:
1609         _COREGL_TRACEPATH_FUNC_END();
1610 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1611         if (trace_mem_flag == 1)
1612         {
1613                 MY_MODULE_TSTATE *tstate = NULL;
1614
1615                 GET_MY_TSTATE(tstate, get_current_thread_state());
1616                 AST(tstate != NULL);
1617                 if (tstate->ctx != NULL)
1618                 {
1619                         int objidx = _COREGL_INT_INIT_VALUE;
1620                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
1621                         AST(objidx != _COREGL_INT_INIT_VALUE);
1622
1623                         // Detect byte per pixel
1624                         int bpp = 0;
1625                         char formatment[80];
1626                         switch (internalformat)
1627                         {
1628                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
1629                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
1630                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
1631                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
1632                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
1633                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
1634                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
1635                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
1636                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
1637                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
1638                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
1639                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
1640                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
1641                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
1642                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
1643                         }
1644
1645                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
1646                 }
1647         }
1648 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1649 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1650         if (trace_surface_flag == 1)
1651         {
1652                 MY_MODULE_TSTATE *tstate = NULL;
1653
1654                 GET_MY_TSTATE(tstate, get_current_thread_state());
1655                 AST(tstate != NULL);
1656                 if (tstate->ctx != NULL)
1657                 {
1658                         int objidx = _COREGL_INT_INIT_VALUE;
1659                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
1660                         AST(objidx != _COREGL_INT_INIT_VALUE);
1661
1662                         {
1663                                 int channel = 0;
1664                                 switch (internalformat)
1665                                 {
1666                                         case GL_ALPHA:
1667                                         case GL_LUMINANCE:
1668                                         case GL_DEPTH_COMPONENT :
1669                                         case 0x81A5:
1670                                         case 0x81A6:
1671                                         case 0x81A7:
1672                                         case 0x8D46 :
1673                                         case 0x8D47 :
1674                                         case 0x8D48 : channel = 1; break;
1675                                         case GL_LUMINANCE_ALPHA:
1676                                         case 0x84F9: channel = 2; break;
1677                                         case GL_RGB: channel = 3; break;
1678                                         case GL_RGBA:
1679                                         case 0x80E1: channel = 4; break;
1680                                 }
1681
1682                                 char name[256];
1683                                 sprintf(name, "FBORB_%d", objidx);
1684                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
1685                         }
1686                 }
1687         }
1688 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1689 }
1690
1691 void
1692 tracepath_glSampleCoverage(GLclampf value, GLboolean invert)
1693 {
1694         _COREGL_TRACEPATH_FUNC_BEGIN();
1695         _orig_tracepath_glSampleCoverage(value, invert);
1696
1697         goto finish;
1698
1699 finish:
1700         _COREGL_TRACEPATH_FUNC_END();
1701 }
1702
1703 void
1704 tracepath_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1705 {
1706         _COREGL_TRACEPATH_FUNC_BEGIN();
1707         _orig_tracepath_glScissor(x, y, width, height);
1708
1709         goto finish;
1710
1711 finish:
1712         _COREGL_TRACEPATH_FUNC_END();
1713 }
1714
1715 void
1716 tracepath_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
1717 {
1718         _COREGL_TRACEPATH_FUNC_BEGIN();
1719         _orig_tracepath_glShaderBinary(n, shaders, binaryformat, binary, length);
1720
1721         goto finish;
1722
1723 finish:
1724         _COREGL_TRACEPATH_FUNC_END();
1725 }
1726
1727 void
1728 tracepath_glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
1729 {
1730         _COREGL_TRACEPATH_FUNC_BEGIN();
1731         _orig_tracepath_glShaderSource(shader, count, string, length);
1732
1733         goto finish;
1734
1735 finish:
1736         _COREGL_TRACEPATH_FUNC_END();
1737 }
1738
1739 void
1740 tracepath_glStencilFunc(GLenum func, GLint ref, GLuint mask)
1741 {
1742         _COREGL_TRACEPATH_FUNC_BEGIN();
1743         _orig_tracepath_glStencilFunc(func, ref, mask);
1744
1745         goto finish;
1746
1747 finish:
1748         _COREGL_TRACEPATH_FUNC_END();
1749 }
1750
1751 void
1752 tracepath_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1753 {
1754         _COREGL_TRACEPATH_FUNC_BEGIN();
1755         _orig_tracepath_glStencilFuncSeparate(face, func, ref, mask);
1756
1757         goto finish;
1758
1759 finish:
1760         _COREGL_TRACEPATH_FUNC_END();
1761 }
1762
1763 void
1764 tracepath_glStencilMask(GLuint mask)
1765 {
1766         _COREGL_TRACEPATH_FUNC_BEGIN();
1767         _orig_tracepath_glStencilMask(mask);
1768
1769         goto finish;
1770
1771 finish:
1772         _COREGL_TRACEPATH_FUNC_END();
1773 }
1774
1775 void
1776 tracepath_glStencilMaskSeparate(GLenum face, GLuint mask)
1777 {
1778         _COREGL_TRACEPATH_FUNC_BEGIN();
1779         _orig_tracepath_glStencilMaskSeparate(face, mask);
1780
1781         goto finish;
1782
1783 finish:
1784         _COREGL_TRACEPATH_FUNC_END();
1785 }
1786
1787 void
1788 tracepath_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1789 {
1790         _COREGL_TRACEPATH_FUNC_BEGIN();
1791         _orig_tracepath_glStencilOp(fail, zfail, zpass);
1792
1793         goto finish;
1794
1795 finish:
1796         _COREGL_TRACEPATH_FUNC_END();
1797 }
1798
1799 void
1800 tracepath_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1801 {
1802         _COREGL_TRACEPATH_FUNC_BEGIN();
1803         _orig_tracepath_glStencilOpSeparate(face, fail, zfail, zpass);
1804
1805         goto finish;
1806
1807 finish:
1808         _COREGL_TRACEPATH_FUNC_END();
1809 }
1810
1811 void
1812 tracepath_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
1813 {
1814         _COREGL_TRACEPATH_FUNC_BEGIN();
1815         _orig_tracepath_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
1816
1817         goto finish;
1818
1819 finish:
1820         _COREGL_TRACEPATH_FUNC_END();
1821 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1822         if (trace_mem_flag == 1)
1823         {
1824                 MY_MODULE_TSTATE *tstate = NULL;
1825
1826                 GET_MY_TSTATE(tstate, get_current_thread_state());
1827                 AST(tstate != NULL);
1828                 if (tstate->ctx != NULL)
1829                 {
1830                         int objidx = _COREGL_INT_INIT_VALUE;
1831                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
1832                         AST(objidx != _COREGL_INT_INIT_VALUE);
1833
1834                         // Detect byte per pixel
1835                         int bpp = 0;
1836                         char formatment[80];
1837                         switch (internalformat)
1838                         {
1839                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
1840                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
1841                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
1842                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
1843                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
1844                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
1845                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
1846                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
1847                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
1848                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
1849                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
1850                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
1851                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
1852                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
1853                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
1854                         }
1855
1856                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", width, height, bpp, formatment);
1857                 }
1858         }
1859 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1860 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1861         if (trace_surface_flag == 1)
1862         {
1863                 MY_MODULE_TSTATE *tstate = NULL;
1864
1865                 GET_MY_TSTATE(tstate, get_current_thread_state());
1866                 AST(tstate != NULL);
1867                 if (tstate->ctx != NULL)
1868                 {
1869                         int objidx = _COREGL_INT_INIT_VALUE;
1870                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
1871                         AST(objidx != _COREGL_INT_INIT_VALUE);
1872
1873                         {
1874                                 int channel = 0;
1875                                 switch (internalformat)
1876                                 {
1877                                         case GL_ALPHA:
1878                                         case GL_LUMINANCE:
1879                                         case GL_DEPTH_COMPONENT :
1880                                         case 0x81A5:
1881                                         case 0x81A6:
1882                                         case 0x81A7:
1883                                         case 0x8D46 :
1884                                         case 0x8D47 :
1885                                         case 0x8D48 : channel = 1; break;
1886                                         case GL_LUMINANCE_ALPHA:
1887                                         case 0x84F9: channel = 2; break;
1888                                         case GL_RGB: channel = 3; break;
1889                                         case GL_RGBA:
1890                                         case 0x80E1: channel = 4; break;
1891                                 }
1892
1893                                 char name[256];
1894                                 sprintf(name, "FBOTEX_0x%X", objidx);
1895                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, objidx, 0, width, height, channel, NULL);
1896                         }
1897                 }
1898         }
1899 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1900 }
1901
1902 void
1903 tracepath_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
1904 {
1905         _COREGL_TRACEPATH_FUNC_BEGIN();
1906         _orig_tracepath_glTexParameterf(target, pname, param);
1907
1908         goto finish;
1909
1910 finish:
1911         _COREGL_TRACEPATH_FUNC_END();
1912 }
1913
1914 void
1915 tracepath_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1916 {
1917         _COREGL_TRACEPATH_FUNC_BEGIN();
1918         _orig_tracepath_glTexParameterfv(target, pname, params);
1919
1920         goto finish;
1921
1922 finish:
1923         _COREGL_TRACEPATH_FUNC_END();
1924 }
1925
1926 void
1927 tracepath_glTexParameteri(GLenum target, GLenum pname, GLint param)
1928 {
1929         _COREGL_TRACEPATH_FUNC_BEGIN();
1930         _orig_tracepath_glTexParameteri(target, pname, param);
1931
1932         goto finish;
1933
1934 finish:
1935         _COREGL_TRACEPATH_FUNC_END();
1936 }
1937
1938 void
1939 tracepath_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
1940 {
1941         _COREGL_TRACEPATH_FUNC_BEGIN();
1942         _orig_tracepath_glTexParameteriv(target, pname, params);
1943
1944         goto finish;
1945
1946 finish:
1947         _COREGL_TRACEPATH_FUNC_END();
1948 }
1949
1950 void
1951 tracepath_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
1952 {
1953         _COREGL_TRACEPATH_FUNC_BEGIN();
1954         _orig_tracepath_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
1955
1956         goto finish;
1957
1958 finish:
1959         _COREGL_TRACEPATH_FUNC_END();
1960 }
1961
1962 void
1963 tracepath_glUniform1f(GLint location, GLfloat x)
1964 {
1965         _COREGL_TRACEPATH_FUNC_BEGIN();
1966         _orig_tracepath_glUniform1f(location, x);
1967
1968         goto finish;
1969
1970 finish:
1971         _COREGL_TRACEPATH_FUNC_END();
1972 }
1973
1974 void
1975 tracepath_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
1976 {
1977         _COREGL_TRACEPATH_FUNC_BEGIN();
1978         _orig_tracepath_glUniform1fv(location, count, v);
1979
1980         goto finish;
1981
1982 finish:
1983         _COREGL_TRACEPATH_FUNC_END();
1984 }
1985
1986 void
1987 tracepath_glUniform1i(GLint location, GLint x)
1988 {
1989         _COREGL_TRACEPATH_FUNC_BEGIN();
1990         _orig_tracepath_glUniform1i(location, x);
1991
1992         goto finish;
1993
1994 finish:
1995         _COREGL_TRACEPATH_FUNC_END();
1996 }
1997
1998 void
1999 tracepath_glUniform1iv(GLint location, GLsizei count, const GLint* v)
2000 {
2001         _COREGL_TRACEPATH_FUNC_BEGIN();
2002         _orig_tracepath_glUniform1iv(location, count, v);
2003
2004         goto finish;
2005
2006 finish:
2007         _COREGL_TRACEPATH_FUNC_END();
2008 }
2009
2010 void
2011 tracepath_glUniform2f(GLint location, GLfloat x, GLfloat y)
2012 {
2013         _COREGL_TRACEPATH_FUNC_BEGIN();
2014         _orig_tracepath_glUniform2f(location, x, y);
2015
2016         goto finish;
2017
2018 finish:
2019         _COREGL_TRACEPATH_FUNC_END();
2020 }
2021
2022 void
2023 tracepath_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
2024 {
2025         _COREGL_TRACEPATH_FUNC_BEGIN();
2026         _orig_tracepath_glUniform2fv(location, count, v);
2027
2028         goto finish;
2029
2030 finish:
2031         _COREGL_TRACEPATH_FUNC_END();
2032 }
2033
2034 void
2035 tracepath_glUniform2i(GLint location, GLint x, GLint y)
2036 {
2037         _COREGL_TRACEPATH_FUNC_BEGIN();
2038         _orig_tracepath_glUniform2i(location, x, y);
2039
2040         goto finish;
2041
2042 finish:
2043         _COREGL_TRACEPATH_FUNC_END();
2044 }
2045
2046 void
2047 tracepath_glUniform2iv(GLint location, GLsizei count, const GLint* v)
2048 {
2049         _COREGL_TRACEPATH_FUNC_BEGIN();
2050         _orig_tracepath_glUniform2iv(location, count, v);
2051
2052         goto finish;
2053
2054 finish:
2055         _COREGL_TRACEPATH_FUNC_END();
2056 }
2057
2058 void
2059 tracepath_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
2060 {
2061         _COREGL_TRACEPATH_FUNC_BEGIN();
2062         _orig_tracepath_glUniform3f(location, x, y, z);
2063
2064         goto finish;
2065
2066 finish:
2067         _COREGL_TRACEPATH_FUNC_END();
2068 }
2069
2070 void
2071 tracepath_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
2072 {
2073         _COREGL_TRACEPATH_FUNC_BEGIN();
2074         _orig_tracepath_glUniform3fv(location, count, v);
2075
2076         goto finish;
2077
2078 finish:
2079         _COREGL_TRACEPATH_FUNC_END();
2080 }
2081
2082 void
2083 tracepath_glUniform3i(GLint location, GLint x, GLint y, GLint z)
2084 {
2085         _COREGL_TRACEPATH_FUNC_BEGIN();
2086         _orig_tracepath_glUniform3i(location, x, y, z);
2087
2088         goto finish;
2089
2090 finish:
2091         _COREGL_TRACEPATH_FUNC_END();
2092 }
2093
2094 void
2095 tracepath_glUniform3iv(GLint location, GLsizei count, const GLint* v)
2096 {
2097         _COREGL_TRACEPATH_FUNC_BEGIN();
2098         _orig_tracepath_glUniform3iv(location, count, v);
2099
2100         goto finish;
2101
2102 finish:
2103         _COREGL_TRACEPATH_FUNC_END();
2104 }
2105
2106 void
2107 tracepath_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2108 {
2109         _COREGL_TRACEPATH_FUNC_BEGIN();
2110         _orig_tracepath_glUniform4f(location, x, y, z, w);
2111
2112         goto finish;
2113
2114 finish:
2115         _COREGL_TRACEPATH_FUNC_END();
2116 }
2117
2118 void
2119 tracepath_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
2120 {
2121         _COREGL_TRACEPATH_FUNC_BEGIN();
2122         _orig_tracepath_glUniform4fv(location, count, v);
2123
2124         goto finish;
2125
2126 finish:
2127         _COREGL_TRACEPATH_FUNC_END();
2128 }
2129
2130 void
2131 tracepath_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
2132 {
2133         _COREGL_TRACEPATH_FUNC_BEGIN();
2134         _orig_tracepath_glUniform4i(location, x, y, z, w);
2135
2136         goto finish;
2137
2138 finish:
2139         _COREGL_TRACEPATH_FUNC_END();
2140 }
2141
2142 void
2143 tracepath_glUniform4iv(GLint location, GLsizei count, const GLint* v)
2144 {
2145         _COREGL_TRACEPATH_FUNC_BEGIN();
2146         _orig_tracepath_glUniform4iv(location, count, v);
2147
2148         goto finish;
2149
2150 finish:
2151         _COREGL_TRACEPATH_FUNC_END();
2152 }
2153
2154 void
2155 tracepath_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2156 {
2157         _COREGL_TRACEPATH_FUNC_BEGIN();
2158         _orig_tracepath_glUniformMatrix2fv(location, count, transpose, value);
2159
2160         goto finish;
2161
2162 finish:
2163         _COREGL_TRACEPATH_FUNC_END();
2164 }
2165
2166 void
2167 tracepath_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2168 {
2169         _COREGL_TRACEPATH_FUNC_BEGIN();
2170         _orig_tracepath_glUniformMatrix3fv(location, count, transpose, value);
2171
2172         goto finish;
2173
2174 finish:
2175         _COREGL_TRACEPATH_FUNC_END();
2176 }
2177
2178 void
2179 tracepath_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2180 {
2181         _COREGL_TRACEPATH_FUNC_BEGIN();
2182         _orig_tracepath_glUniformMatrix4fv(location, count, transpose, value);
2183
2184         goto finish;
2185
2186 finish:
2187         _COREGL_TRACEPATH_FUNC_END();
2188 }
2189
2190 void
2191 tracepath_glUseProgram(GLuint program)
2192 {
2193         _COREGL_TRACEPATH_FUNC_BEGIN();
2194         _orig_tracepath_glUseProgram(program);
2195
2196         goto finish;
2197
2198 finish:
2199         _COREGL_TRACEPATH_FUNC_END();
2200 }
2201
2202 void
2203 tracepath_glValidateProgram(GLuint program)
2204 {
2205         _COREGL_TRACEPATH_FUNC_BEGIN();
2206         _orig_tracepath_glValidateProgram(program);
2207
2208         goto finish;
2209
2210 finish:
2211         _COREGL_TRACEPATH_FUNC_END();
2212 }
2213
2214 void
2215 tracepath_glVertexAttrib1f(GLuint index, GLfloat x)
2216 {
2217         _COREGL_TRACEPATH_FUNC_BEGIN();
2218         _orig_tracepath_glVertexAttrib1f(index, x);
2219
2220         goto finish;
2221
2222 finish:
2223         _COREGL_TRACEPATH_FUNC_END();
2224 }
2225
2226 void
2227 tracepath_glVertexAttrib1fv(GLuint index, const GLfloat* values)
2228 {
2229         _COREGL_TRACEPATH_FUNC_BEGIN();
2230         _orig_tracepath_glVertexAttrib1fv(index, values);
2231
2232         goto finish;
2233
2234 finish:
2235         _COREGL_TRACEPATH_FUNC_END();
2236 }
2237
2238 void
2239 tracepath_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
2240 {
2241         _COREGL_TRACEPATH_FUNC_BEGIN();
2242         _orig_tracepath_glVertexAttrib2f(index, x, y);
2243
2244         goto finish;
2245
2246 finish:
2247         _COREGL_TRACEPATH_FUNC_END();
2248 }
2249
2250 void
2251 tracepath_glVertexAttrib2fv(GLuint index, const GLfloat* values)
2252 {
2253         _COREGL_TRACEPATH_FUNC_BEGIN();
2254         _orig_tracepath_glVertexAttrib2fv(index, values);
2255
2256         goto finish;
2257
2258 finish:
2259         _COREGL_TRACEPATH_FUNC_END();
2260 }
2261
2262 void
2263 tracepath_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
2264 {
2265         _COREGL_TRACEPATH_FUNC_BEGIN();
2266         _orig_tracepath_glVertexAttrib3f(index, x, y, z);
2267
2268         goto finish;
2269
2270 finish:
2271         _COREGL_TRACEPATH_FUNC_END();
2272 }
2273
2274 void
2275 tracepath_glVertexAttrib3fv(GLuint index, const GLfloat* values)
2276 {
2277         _COREGL_TRACEPATH_FUNC_BEGIN();
2278         _orig_tracepath_glVertexAttrib3fv(index, values);
2279
2280         goto finish;
2281
2282 finish:
2283         _COREGL_TRACEPATH_FUNC_END();
2284 }
2285
2286 void
2287 tracepath_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2288 {
2289         _COREGL_TRACEPATH_FUNC_BEGIN();
2290         _orig_tracepath_glVertexAttrib4f(index, x, y, z, w);
2291
2292         goto finish;
2293
2294 finish:
2295         _COREGL_TRACEPATH_FUNC_END();
2296 }
2297
2298 void
2299 tracepath_glVertexAttrib4fv(GLuint index, const GLfloat* values)
2300 {
2301         _COREGL_TRACEPATH_FUNC_BEGIN();
2302         _orig_tracepath_glVertexAttrib4fv(index, values);
2303
2304         goto finish;
2305
2306 finish:
2307         _COREGL_TRACEPATH_FUNC_END();
2308 }
2309
2310 void
2311 tracepath_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer)
2312 {
2313         _COREGL_TRACEPATH_FUNC_BEGIN();
2314         _orig_tracepath_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
2315
2316         goto finish;
2317
2318 finish:
2319         _COREGL_TRACEPATH_FUNC_END();
2320 }
2321
2322 void
2323 tracepath_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2324 {
2325         _COREGL_TRACEPATH_FUNC_BEGIN();
2326         _orig_tracepath_glViewport(x, y, width, height);
2327
2328         goto finish;
2329
2330 finish:
2331         _COREGL_TRACEPATH_FUNC_END();
2332 }
2333
2334
2335 /* OpenGL ES 3.0 */
2336 void
2337 tracepath_glReadBuffer(GLenum mode)
2338 {
2339         _COREGL_TRACEPATH_FUNC_BEGIN();
2340         _orig_tracepath_glReadBuffer(mode);
2341
2342         goto finish;
2343
2344 finish:
2345         _COREGL_TRACEPATH_FUNC_END();
2346 }
2347
2348 void
2349 tracepath_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
2350 {
2351         _COREGL_TRACEPATH_FUNC_BEGIN();
2352         _orig_tracepath_glDrawRangeElements(mode, start, end, count, type, indices);
2353
2354         goto finish;
2355
2356 finish:
2357         _COREGL_TRACEPATH_FUNC_END();
2358 }
2359
2360 void
2361 tracepath_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2362 {
2363         _COREGL_TRACEPATH_FUNC_BEGIN();
2364         _orig_tracepath_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border, format, type, pixels);
2365
2366         goto finish;
2367
2368 finish:
2369         _COREGL_TRACEPATH_FUNC_END();
2370 }
2371
2372 void
2373 tracepath_glTexImage3DOES(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2374 {
2375         _COREGL_TRACEPATH_FUNC_BEGIN();
2376         _orig_tracepath_glTexImage3DOES(target, level, GLinternalFormat, width, height, depth, border, format, type, pixels);
2377
2378         goto finish;
2379
2380 finish:
2381         _COREGL_TRACEPATH_FUNC_END();
2382 }
2383
2384 void
2385 tracepath_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
2386 {
2387         _COREGL_TRACEPATH_FUNC_BEGIN();
2388         _orig_tracepath_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
2389
2390         goto finish;
2391
2392 finish:
2393         _COREGL_TRACEPATH_FUNC_END();
2394 }
2395
2396 void
2397 tracepath_glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
2398 {
2399         _COREGL_TRACEPATH_FUNC_BEGIN();
2400         _orig_tracepath_glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
2401
2402         goto finish;
2403
2404 finish:
2405         _COREGL_TRACEPATH_FUNC_END();
2406 }
2407
2408 void
2409 tracepath_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2410 {
2411         _COREGL_TRACEPATH_FUNC_BEGIN();
2412         _orig_tracepath_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
2413
2414         goto finish;
2415
2416 finish:
2417         _COREGL_TRACEPATH_FUNC_END();
2418 }
2419
2420 void
2421 tracepath_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2422 {
2423         _COREGL_TRACEPATH_FUNC_BEGIN();
2424         _orig_tracepath_glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
2425
2426         goto finish;
2427
2428 finish:
2429         _COREGL_TRACEPATH_FUNC_END();
2430 }
2431
2432 void
2433 tracepath_glCompressedTexImage3D(GLenum target, GLint level, GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
2434 {
2435         _COREGL_TRACEPATH_FUNC_BEGIN();
2436         _orig_tracepath_glCompressedTexImage3D(target, level, GLinternalformat, width, height, depth, border, imageSize, data);
2437
2438         goto finish;
2439
2440 finish:
2441         _COREGL_TRACEPATH_FUNC_END();
2442 }
2443
2444 void
2445 tracepath_glCompressedTexImage3DOES(GLenum target, GLint level, GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
2446 {
2447         _COREGL_TRACEPATH_FUNC_BEGIN();
2448         _orig_tracepath_glCompressedTexImage3DOES(target, level, GLinternalformat, width, height, depth, border, imageSize, data);
2449
2450         goto finish;
2451
2452 finish:
2453         _COREGL_TRACEPATH_FUNC_END();
2454 }
2455
2456 void
2457 tracepath_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
2458 {
2459         _COREGL_TRACEPATH_FUNC_BEGIN();
2460         _orig_tracepath_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
2461
2462         goto finish;
2463
2464 finish:
2465         _COREGL_TRACEPATH_FUNC_END();
2466 }
2467
2468 void
2469 tracepath_glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
2470 {
2471         _COREGL_TRACEPATH_FUNC_BEGIN();
2472         _orig_tracepath_glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
2473
2474         goto finish;
2475
2476 finish:
2477         _COREGL_TRACEPATH_FUNC_END();
2478 }
2479
2480 void
2481 tracepath_glGenQueries(GLsizei n, GLuint* ids)
2482 {
2483         _COREGL_TRACEPATH_FUNC_BEGIN();
2484         _orig_tracepath_glGenQueries(n, ids);
2485
2486         goto finish;
2487
2488 finish:
2489         _COREGL_TRACEPATH_FUNC_END();
2490 }
2491
2492 void
2493 tracepath_glDeleteQueries(GLsizei n, const GLuint* ids)
2494 {
2495         _COREGL_TRACEPATH_FUNC_BEGIN();
2496         _orig_tracepath_glDeleteQueries(n, ids);
2497
2498         goto finish;
2499
2500 finish:
2501         _COREGL_TRACEPATH_FUNC_END();
2502 }
2503
2504 GLboolean
2505 tracepath_glIsQuery(GLuint id)
2506 {
2507         GLboolean ret = GL_FALSE;
2508
2509         _COREGL_TRACEPATH_FUNC_BEGIN();
2510         ret = _orig_tracepath_glIsQuery(id);
2511
2512         goto finish;
2513
2514 finish:
2515         _COREGL_TRACEPATH_FUNC_END();
2516         return ret;
2517 }
2518
2519 void
2520 tracepath_glBeginQuery(GLenum target, GLuint id)
2521 {
2522         _COREGL_TRACEPATH_FUNC_BEGIN();
2523         _orig_tracepath_glBeginQuery(target, id);
2524
2525         goto finish;
2526
2527 finish:
2528         _COREGL_TRACEPATH_FUNC_END();
2529 }
2530
2531 void
2532 tracepath_glEndQuery(GLenum target)
2533 {
2534         _COREGL_TRACEPATH_FUNC_BEGIN();
2535         _orig_tracepath_glEndQuery(target);
2536
2537         goto finish;
2538
2539 finish:
2540         _COREGL_TRACEPATH_FUNC_END();
2541 }
2542
2543 void
2544 tracepath_glGetQueryiv(GLenum target, GLenum pname, GLint* params)
2545 {
2546         _COREGL_TRACEPATH_FUNC_BEGIN();
2547         _orig_tracepath_glGetQueryiv(target, pname, params);
2548
2549         goto finish;
2550
2551 finish:
2552         _COREGL_TRACEPATH_FUNC_END();
2553 }
2554
2555 void
2556 tracepath_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
2557 {
2558         _COREGL_TRACEPATH_FUNC_BEGIN();
2559         _orig_tracepath_glGetQueryObjectuiv(id, pname, params);
2560
2561         goto finish;
2562
2563 finish:
2564         _COREGL_TRACEPATH_FUNC_END();
2565 }
2566
2567 GLboolean
2568 tracepath_glUnmapBuffer(GLenum target)
2569 {
2570         GLboolean ret = GL_FALSE;
2571
2572         _COREGL_TRACEPATH_FUNC_BEGIN();
2573         ret = _orig_tracepath_glUnmapBuffer(target);
2574
2575         goto finish;
2576
2577 finish:
2578         _COREGL_TRACEPATH_FUNC_END();
2579         return ret;
2580 }
2581
2582 void
2583 tracepath_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
2584 {
2585         _COREGL_TRACEPATH_FUNC_BEGIN();
2586         _orig_tracepath_glGetBufferPointerv(target, pname, params);
2587
2588         goto finish;
2589
2590 finish:
2591         _COREGL_TRACEPATH_FUNC_END();
2592 }
2593
2594 void
2595 tracepath_glDrawBuffers(GLsizei n, const GLenum* bufs)
2596 {
2597         _COREGL_TRACEPATH_FUNC_BEGIN();
2598         _orig_tracepath_glDrawBuffers(n, bufs);
2599
2600         goto finish;
2601
2602 finish:
2603         _COREGL_TRACEPATH_FUNC_END();
2604 }
2605
2606 void
2607 tracepath_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2608 {
2609         _COREGL_TRACEPATH_FUNC_BEGIN();
2610         _orig_tracepath_glUniformMatrix2x3fv(location, count, transpose, value);
2611
2612         goto finish;
2613
2614 finish:
2615         _COREGL_TRACEPATH_FUNC_END();
2616 }
2617
2618 void
2619 tracepath_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2620 {
2621         _COREGL_TRACEPATH_FUNC_BEGIN();
2622         _orig_tracepath_glUniformMatrix3x2fv(location, count, transpose, value);
2623
2624         goto finish;
2625
2626 finish:
2627         _COREGL_TRACEPATH_FUNC_END();
2628 }
2629
2630 void
2631 tracepath_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2632 {
2633         _COREGL_TRACEPATH_FUNC_BEGIN();
2634         _orig_tracepath_glUniformMatrix2x4fv(location, count, transpose, value);
2635
2636         goto finish;
2637
2638 finish:
2639         _COREGL_TRACEPATH_FUNC_END();
2640 }
2641
2642 void
2643 tracepath_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2644 {
2645         _COREGL_TRACEPATH_FUNC_BEGIN();
2646         _orig_tracepath_glUniformMatrix4x2fv(location, count, transpose, value);
2647
2648         goto finish;
2649
2650 finish:
2651         _COREGL_TRACEPATH_FUNC_END();
2652 }
2653
2654 void
2655 tracepath_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2656 {
2657         _COREGL_TRACEPATH_FUNC_BEGIN();
2658         _orig_tracepath_glUniformMatrix3x4fv(location, count, transpose, value);
2659
2660         goto finish;
2661
2662 finish:
2663         _COREGL_TRACEPATH_FUNC_END();
2664 }
2665
2666 void
2667 tracepath_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2668 {
2669         _COREGL_TRACEPATH_FUNC_BEGIN();
2670         _orig_tracepath_glUniformMatrix4x3fv(location, count, transpose, value);
2671
2672         goto finish;
2673
2674 finish:
2675         _COREGL_TRACEPATH_FUNC_END();
2676 }
2677
2678 void
2679 tracepath_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
2680 {
2681         _COREGL_TRACEPATH_FUNC_BEGIN();
2682         _orig_tracepath_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
2683
2684         goto finish;
2685
2686 finish:
2687         _COREGL_TRACEPATH_FUNC_END();
2688 }
2689
2690 void
2691 tracepath_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
2692 {
2693         _COREGL_TRACEPATH_FUNC_BEGIN();
2694         _orig_tracepath_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
2695
2696         goto finish;
2697
2698 finish:
2699         _COREGL_TRACEPATH_FUNC_END();
2700 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2701         if (trace_mem_flag == 1)
2702         {
2703                 MY_MODULE_TSTATE *tstate = NULL;
2704
2705                 GET_MY_TSTATE(tstate, get_current_thread_state());
2706                 AST(tstate != NULL);
2707                 if (tstate->ctx != NULL)
2708                 {
2709                         int objidx = _COREGL_INT_INIT_VALUE;
2710                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2711                         AST(objidx != _COREGL_INT_INIT_VALUE);
2712
2713                         // Detect byte per pixel
2714                         int bpp = 0;
2715                         char formatment[80];
2716                         switch (internalformat)
2717                         {
2718                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
2719                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
2720                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
2721                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
2722                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
2723                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
2724                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
2725                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
2726                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
2727                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
2728                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
2729                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
2730                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
2731                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
2732                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
2733                         }
2734
2735                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
2736                 }
2737         }
2738 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2739 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2740         if (trace_surface_flag == 1)
2741         {
2742                 MY_MODULE_TSTATE *tstate = NULL;
2743
2744                 GET_MY_TSTATE(tstate, get_current_thread_state());
2745                 AST(tstate != NULL);
2746                 if (tstate->ctx != NULL)
2747                 {
2748                         int objidx = _COREGL_INT_INIT_VALUE;
2749                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2750                         AST(objidx != _COREGL_INT_INIT_VALUE);
2751
2752                         {
2753                                 int channel = 0;
2754                                 switch (internalformat)
2755                                 {
2756                                         case GL_ALPHA:
2757                                         case GL_LUMINANCE:
2758                                         case GL_DEPTH_COMPONENT :
2759                                         case 0x81A5:
2760                                         case 0x81A6:
2761                                         case 0x81A7:
2762                                         case 0x8D46 :
2763                                         case 0x8D47 :
2764                                         case 0x8D48 : channel = 1; break;
2765                                         case GL_LUMINANCE_ALPHA:
2766                                         case 0x84F9: channel = 2; break;
2767                                         case GL_RGB: channel = 3; break;
2768                                         case GL_RGBA:
2769                                         case 0x80E1: channel = 4; break;
2770                                 }
2771
2772                                 char name[256];
2773                                 sprintf(name, "FBORB_0x%X", objidx);
2774                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
2775                         }
2776                 }
2777         }
2778 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2779 }
2780
2781 void
2782 tracepath_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
2783 {
2784         _COREGL_TRACEPATH_FUNC_BEGIN();
2785         _orig_tracepath_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
2786
2787         goto finish;
2788
2789 finish:
2790         _COREGL_TRACEPATH_FUNC_END();
2791 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2792         if (trace_mem_flag == 1)
2793         {
2794                 MY_MODULE_TSTATE *tstate = NULL;
2795
2796                 GET_MY_TSTATE(tstate, get_current_thread_state());
2797                 AST(tstate != NULL);
2798                 if (tstate->ctx != NULL)
2799                 {
2800                         int objidx = _COREGL_INT_INIT_VALUE;
2801                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2802                         AST(objidx != _COREGL_INT_INIT_VALUE);
2803
2804                         // Detect byte per pixel
2805                         int bpp = 0;
2806                         char formatment[80];
2807                         switch (internalformat)
2808                         {
2809                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
2810                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
2811                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
2812                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
2813                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
2814                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
2815                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
2816                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
2817                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
2818                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
2819                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
2820                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
2821                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
2822                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
2823                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
2824                         }
2825
2826                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
2827                 }
2828         }
2829 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2830 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2831         if (trace_surface_flag == 1)
2832         {
2833                 MY_MODULE_TSTATE *tstate = NULL;
2834
2835                 GET_MY_TSTATE(tstate, get_current_thread_state());
2836                 AST(tstate != NULL);
2837                 if (tstate->ctx != NULL)
2838                 {
2839                         int objidx = _COREGL_INT_INIT_VALUE;
2840                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2841                         AST(objidx != _COREGL_INT_INIT_VALUE);
2842
2843                         {
2844                                 int channel = 0;
2845                                 switch (internalformat)
2846                                 {
2847                                         case GL_ALPHA:
2848                                         case GL_LUMINANCE:
2849                                         case GL_DEPTH_COMPONENT :
2850                                         case 0x81A5:
2851                                         case 0x81A6:
2852                                         case 0x81A7:
2853                                         case 0x8D46 :
2854                                         case 0x8D47 :
2855                                         case 0x8D48 : channel = 1; break;
2856                                         case GL_LUMINANCE_ALPHA:
2857                                         case 0x84F9: channel = 2; break;
2858                                         case GL_RGB: channel = 3; break;
2859                                         case GL_RGBA:
2860                                         case 0x80E1: channel = 4; break;
2861                                 }
2862
2863                                 char name[256];
2864                                 sprintf(name, "FBORB_0x%X", objidx);
2865                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
2866                         }
2867                 }
2868         }
2869 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2870 }
2871
2872 void
2873 tracepath_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
2874 {
2875         _COREGL_TRACEPATH_FUNC_BEGIN();
2876
2877 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2878         tracepath_fbdump_update(0);
2879 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2880
2881         _orig_tracepath_glFramebufferTextureLayer(target, attachment, texture, level, layer);
2882
2883 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2884         tracepath_fbdump_update(1);
2885 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2886
2887         goto finish;
2888
2889 finish:
2890         _COREGL_TRACEPATH_FUNC_END();
2891 }
2892
2893 GLvoid*
2894 tracepath_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
2895 {
2896         GLvoid* ret = NULL;
2897
2898         _COREGL_TRACEPATH_FUNC_BEGIN();
2899         ret = _orig_tracepath_glMapBufferRange(target, offset, length, access);
2900
2901         goto finish;
2902
2903 finish:
2904         _COREGL_TRACEPATH_FUNC_END();
2905         return ret;
2906 }
2907
2908 void
2909 tracepath_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
2910 {
2911         _COREGL_TRACEPATH_FUNC_BEGIN();
2912         _orig_tracepath_glFlushMappedBufferRange(target, offset, length);
2913
2914         goto finish;
2915
2916 finish:
2917         _COREGL_TRACEPATH_FUNC_END();
2918 }
2919
2920 void
2921 tracepath_glBindVertexArray(GLuint array)
2922 {
2923         _COREGL_TRACEPATH_FUNC_BEGIN();
2924         _orig_tracepath_glBindVertexArray(array);
2925
2926         goto finish;
2927
2928 finish:
2929         _COREGL_TRACEPATH_FUNC_END();
2930 }
2931
2932 void
2933 tracepath_glDeleteVertexArrays(GLsizei n, const GLuint* arrays)
2934 {
2935         _COREGL_TRACEPATH_FUNC_BEGIN();
2936         _orig_tracepath_glDeleteVertexArrays(n, arrays);
2937
2938         goto finish;
2939
2940 finish:
2941         _COREGL_TRACEPATH_FUNC_END();
2942 }
2943
2944 void
2945 tracepath_glGenVertexArrays(GLsizei n, GLuint* arrays)
2946 {
2947         _COREGL_TRACEPATH_FUNC_BEGIN();
2948         _orig_tracepath_glGenVertexArrays(n, arrays);
2949
2950         goto finish;
2951
2952 finish:
2953         _COREGL_TRACEPATH_FUNC_END();
2954 }
2955
2956 GLboolean
2957 tracepath_glIsVertexArray(GLuint array)
2958 {
2959         GLboolean ret = GL_FALSE;
2960
2961         _COREGL_TRACEPATH_FUNC_BEGIN();
2962         ret = _orig_tracepath_glIsVertexArray(array);
2963
2964         goto finish;
2965
2966 finish:
2967         _COREGL_TRACEPATH_FUNC_END();
2968         return ret;
2969 }
2970
2971 void
2972 tracepath_glGetIntegeri_v(GLenum target, GLuint index, GLint* data)
2973 {
2974         _COREGL_TRACEPATH_FUNC_BEGIN();
2975         _orig_tracepath_glGetIntegeri_v(target, index, data);
2976
2977         goto finish;
2978
2979 finish:
2980         _COREGL_TRACEPATH_FUNC_END();
2981 }
2982
2983 void
2984 tracepath_glBeginTransformFeedback(GLenum primitiveMode)
2985 {
2986         _COREGL_TRACEPATH_FUNC_BEGIN();
2987         _orig_tracepath_glBeginTransformFeedback(primitiveMode);
2988
2989         goto finish;
2990
2991 finish:
2992         _COREGL_TRACEPATH_FUNC_END();
2993 }
2994
2995 void
2996 tracepath_glEndTransformFeedback()
2997 {
2998         _COREGL_TRACEPATH_FUNC_BEGIN();
2999         _orig_tracepath_glEndTransformFeedback();
3000
3001         goto finish;
3002
3003 finish:
3004         _COREGL_TRACEPATH_FUNC_END();
3005 }
3006
3007 void
3008 tracepath_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
3009 {
3010         _COREGL_TRACEPATH_FUNC_BEGIN();
3011         _orig_tracepath_glBindBufferRange(target, index, buffer, offset, size);
3012
3013         goto finish;
3014
3015 finish:
3016         _COREGL_TRACEPATH_FUNC_END();
3017 }
3018
3019 void
3020 tracepath_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
3021 {
3022         _COREGL_TRACEPATH_FUNC_BEGIN();
3023         _orig_tracepath_glBindBufferBase(target, index, buffer);
3024
3025         goto finish;
3026
3027 finish:
3028         _COREGL_TRACEPATH_FUNC_END();
3029 }
3030
3031 void
3032 tracepath_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
3033 {
3034         _COREGL_TRACEPATH_FUNC_BEGIN();
3035         _orig_tracepath_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
3036
3037         goto finish;
3038
3039 finish:
3040         _COREGL_TRACEPATH_FUNC_END();
3041 }
3042
3043 void
3044 tracepath_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
3045 {
3046         _COREGL_TRACEPATH_FUNC_BEGIN();
3047         _orig_tracepath_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
3048
3049         goto finish;
3050
3051 finish:
3052         _COREGL_TRACEPATH_FUNC_END();
3053 }
3054
3055 void
3056 tracepath_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
3057 {
3058         _COREGL_TRACEPATH_FUNC_BEGIN();
3059         _orig_tracepath_glVertexAttribIPointer(index, size, type, stride, pointer);
3060
3061         goto finish;
3062
3063 finish:
3064         _COREGL_TRACEPATH_FUNC_END();
3065 }
3066
3067 void
3068 tracepath_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
3069 {
3070         _COREGL_TRACEPATH_FUNC_BEGIN();
3071         _orig_tracepath_glGetVertexAttribIiv(index, pname, params);
3072
3073         goto finish;
3074
3075 finish:
3076         _COREGL_TRACEPATH_FUNC_END();
3077 }
3078
3079 void
3080 tracepath_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
3081 {
3082         _COREGL_TRACEPATH_FUNC_BEGIN();
3083         _orig_tracepath_glGetVertexAttribIuiv(index, pname, params);
3084
3085         goto finish;
3086
3087 finish:
3088         _COREGL_TRACEPATH_FUNC_END();
3089 }
3090
3091 void
3092 tracepath_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
3093 {
3094         _COREGL_TRACEPATH_FUNC_BEGIN();
3095         _orig_tracepath_glVertexAttribI4i(index, x, y, z, w);
3096
3097         goto finish;
3098
3099 finish:
3100         _COREGL_TRACEPATH_FUNC_END();
3101 }
3102
3103 void
3104 tracepath_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
3105 {
3106         _COREGL_TRACEPATH_FUNC_BEGIN();
3107         _orig_tracepath_glVertexAttribI4ui(index, x, y, z, w);
3108
3109         goto finish;
3110
3111 finish:
3112         _COREGL_TRACEPATH_FUNC_END();
3113 }
3114
3115 void
3116 tracepath_glVertexAttribI4iv(GLuint index, const GLint* v)
3117 {
3118         _COREGL_TRACEPATH_FUNC_BEGIN();
3119         _orig_tracepath_glVertexAttribI4iv(index, v);
3120
3121         goto finish;
3122
3123 finish:
3124         _COREGL_TRACEPATH_FUNC_END();
3125 }
3126
3127 void
3128 tracepath_glVertexAttribI4uiv(GLuint index, const GLuint* v)
3129 {
3130         _COREGL_TRACEPATH_FUNC_BEGIN();
3131         _orig_tracepath_glVertexAttribI4uiv(index, v);
3132
3133         goto finish;
3134
3135 finish:
3136         _COREGL_TRACEPATH_FUNC_END();
3137 }
3138
3139 void
3140 tracepath_glGetUniformuiv(GLuint program, GLint location, GLuint* params)
3141 {
3142         _COREGL_TRACEPATH_FUNC_BEGIN();
3143         _orig_tracepath_glGetUniformuiv(program, location, params);
3144
3145         goto finish;
3146
3147 finish:
3148         _COREGL_TRACEPATH_FUNC_END();
3149 }
3150
3151 GLint
3152 tracepath_glGetFragDataLocation(GLuint program, const GLchar *name)
3153 {
3154         GLint ret = _COREGL_INT_INIT_VALUE;
3155
3156         _COREGL_TRACEPATH_FUNC_BEGIN();
3157         ret = _orig_tracepath_glGetFragDataLocation(program, name);
3158
3159         goto finish;
3160
3161 finish:
3162         _COREGL_TRACEPATH_FUNC_END();
3163         return ret;
3164 }
3165
3166 void
3167 tracepath_glUniform1ui(GLint location, GLuint v0)
3168 {
3169         _COREGL_TRACEPATH_FUNC_BEGIN();
3170         _orig_tracepath_glUniform1ui(location, v0);
3171
3172         goto finish;
3173
3174 finish:
3175         _COREGL_TRACEPATH_FUNC_END();
3176 }
3177
3178 void
3179 tracepath_glUniform2ui(GLint location, GLuint v0, GLuint v1)
3180 {
3181         _COREGL_TRACEPATH_FUNC_BEGIN();
3182         _orig_tracepath_glUniform2ui(location, v0, v1);
3183
3184         goto finish;
3185
3186 finish:
3187         _COREGL_TRACEPATH_FUNC_END();
3188 }
3189
3190 void
3191 tracepath_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
3192 {
3193         _COREGL_TRACEPATH_FUNC_BEGIN();
3194         _orig_tracepath_glUniform3ui(location, v0, v1, v2);
3195
3196         goto finish;
3197
3198 finish:
3199         _COREGL_TRACEPATH_FUNC_END();
3200 }
3201
3202 void
3203 tracepath_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
3204 {
3205         _COREGL_TRACEPATH_FUNC_BEGIN();
3206         _orig_tracepath_glUniform4ui(location, v0, v1, v2, v3);
3207
3208         goto finish;
3209
3210 finish:
3211         _COREGL_TRACEPATH_FUNC_END();
3212 }
3213
3214 void
3215 tracepath_glUniform1uiv(GLint location, GLsizei count, const GLuint* value)
3216 {
3217         _COREGL_TRACEPATH_FUNC_BEGIN();
3218         _orig_tracepath_glUniform1uiv(location, count, value);
3219
3220         goto finish;
3221
3222 finish:
3223         _COREGL_TRACEPATH_FUNC_END();
3224 }
3225
3226 void
3227 tracepath_glUniform2uiv(GLint location, GLsizei count, const GLuint* value)
3228 {
3229         _COREGL_TRACEPATH_FUNC_BEGIN();
3230         _orig_tracepath_glUniform2uiv(location, count, value);
3231
3232         goto finish;
3233
3234 finish:
3235         _COREGL_TRACEPATH_FUNC_END();
3236 }
3237
3238 void
3239 tracepath_glUniform3uiv(GLint location, GLsizei count, const GLuint* value)
3240 {
3241         _COREGL_TRACEPATH_FUNC_BEGIN();
3242         _orig_tracepath_glUniform3uiv(location, count, value);
3243
3244         goto finish;
3245
3246 finish:
3247         _COREGL_TRACEPATH_FUNC_END();
3248 }
3249
3250 void
3251 tracepath_glUniform4uiv(GLint location, GLsizei count, const GLuint* value)
3252 {
3253         _COREGL_TRACEPATH_FUNC_BEGIN();
3254         _orig_tracepath_glUniform4uiv(location, count, value);
3255
3256         goto finish;
3257
3258 finish:
3259         _COREGL_TRACEPATH_FUNC_END();
3260 }
3261
3262 void
3263 tracepath_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
3264 {
3265         _COREGL_TRACEPATH_FUNC_BEGIN();
3266         _orig_tracepath_glClearBufferiv(buffer, drawbuffer, value);
3267
3268         goto finish;
3269
3270 finish:
3271         _COREGL_TRACEPATH_FUNC_END();
3272 }
3273
3274 void
3275 tracepath_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
3276 {
3277         _COREGL_TRACEPATH_FUNC_BEGIN();
3278         _orig_tracepath_glClearBufferuiv(buffer, drawbuffer, value);
3279
3280         goto finish;
3281
3282 finish:
3283         _COREGL_TRACEPATH_FUNC_END();
3284 }
3285
3286 void
3287 tracepath_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
3288 {
3289         _COREGL_TRACEPATH_FUNC_BEGIN();
3290         _orig_tracepath_glClearBufferfv(buffer, drawbuffer, value);
3291
3292         goto finish;
3293
3294 finish:
3295         _COREGL_TRACEPATH_FUNC_END();
3296 }
3297
3298 void
3299 tracepath_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
3300 {
3301         _COREGL_TRACEPATH_FUNC_BEGIN();
3302         _orig_tracepath_glClearBufferfi(buffer, drawbuffer, depth, stencil);
3303
3304         goto finish;
3305
3306 finish:
3307         _COREGL_TRACEPATH_FUNC_END();
3308 }
3309
3310 const GLubyte*
3311 tracepath_glGetStringi(GLenum name, GLuint index)
3312 {
3313         const GLubyte* ret = NULL;
3314
3315         _COREGL_TRACEPATH_FUNC_BEGIN();
3316         ret = _orig_tracepath_glGetStringi(name, index);
3317
3318         goto finish;
3319
3320 finish:
3321         _COREGL_TRACEPATH_FUNC_END();
3322         return ret;
3323 }
3324
3325 void
3326 tracepath_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
3327 {
3328         _COREGL_TRACEPATH_FUNC_BEGIN();
3329         _orig_tracepath_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
3330
3331         goto finish;
3332
3333 finish:
3334         _COREGL_TRACEPATH_FUNC_END();
3335 }
3336
3337 void
3338 tracepath_glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
3339 {
3340         _COREGL_TRACEPATH_FUNC_BEGIN();
3341         _orig_tracepath_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
3342
3343         goto finish;
3344
3345 finish:
3346         _COREGL_TRACEPATH_FUNC_END();
3347 }
3348
3349 void
3350 tracepath_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
3351 {
3352         _COREGL_TRACEPATH_FUNC_BEGIN();
3353         _orig_tracepath_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
3354
3355         goto finish;
3356
3357 finish:
3358         _COREGL_TRACEPATH_FUNC_END();
3359 }
3360
3361 GLuint
3362 tracepath_glGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
3363 {
3364         GLuint ret = _COREGL_INT_INIT_VALUE;
3365
3366         _COREGL_TRACEPATH_FUNC_BEGIN();
3367         ret = _orig_tracepath_glGetUniformBlockIndex(program, uniformBlockName);
3368
3369         goto finish;
3370
3371 finish:
3372         _COREGL_TRACEPATH_FUNC_END();
3373         return ret;
3374 }
3375
3376 void
3377 tracepath_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
3378 {
3379         _COREGL_TRACEPATH_FUNC_BEGIN();
3380         _orig_tracepath_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
3381
3382         goto finish;
3383
3384 finish:
3385         _COREGL_TRACEPATH_FUNC_END();
3386 }
3387
3388 void
3389 tracepath_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
3390 {
3391         _COREGL_TRACEPATH_FUNC_BEGIN();
3392         _orig_tracepath_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
3393
3394         goto finish;
3395
3396 finish:
3397         _COREGL_TRACEPATH_FUNC_END();
3398 }
3399
3400 void
3401 tracepath_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
3402 {
3403         _COREGL_TRACEPATH_FUNC_BEGIN();
3404         _orig_tracepath_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
3405
3406         goto finish;
3407
3408 finish:
3409         _COREGL_TRACEPATH_FUNC_END();
3410 }
3411
3412 void
3413 tracepath_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
3414 {
3415         _COREGL_TRACEPATH_FUNC_BEGIN();
3416         _orig_tracepath_glDrawArraysInstanced(mode, first, count, instanceCount);
3417
3418         goto finish;
3419
3420 finish:
3421         _COREGL_TRACEPATH_FUNC_END();
3422 }
3423
3424 void
3425 tracepath_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
3426 {
3427         _COREGL_TRACEPATH_FUNC_BEGIN();
3428         _orig_tracepath_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
3429
3430         goto finish;
3431
3432 finish:
3433         _COREGL_TRACEPATH_FUNC_END();
3434 }
3435
3436 GLsync
3437 tracepath_glFenceSync(GLenum condition, GLbitfield flags)
3438 {
3439         GLsync ret = NULL;
3440
3441         _COREGL_TRACEPATH_FUNC_BEGIN();
3442         ret = _orig_tracepath_glFenceSync(condition, flags);
3443
3444         goto finish;
3445
3446 finish:
3447         _COREGL_TRACEPATH_FUNC_END();
3448         return ret;
3449 }
3450
3451 GLboolean
3452 tracepath_glIsSync(GLsync sync)
3453 {
3454         GLboolean ret = GL_FALSE;
3455
3456         _COREGL_TRACEPATH_FUNC_BEGIN();
3457         ret = _orig_tracepath_glIsSync(sync);
3458
3459         goto finish;
3460
3461 finish:
3462         _COREGL_TRACEPATH_FUNC_END();
3463         return ret;
3464 }
3465
3466 void
3467 tracepath_glDeleteSync(GLsync sync)
3468 {
3469         _COREGL_TRACEPATH_FUNC_BEGIN();
3470         _orig_tracepath_glDeleteSync(sync);
3471
3472         goto finish;
3473
3474 finish:
3475         _COREGL_TRACEPATH_FUNC_END();
3476 }
3477
3478 GLenum
3479 tracepath_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3480 {
3481         GLenum ret = _COREGL_INT_INIT_VALUE;
3482
3483         _COREGL_TRACEPATH_FUNC_BEGIN();
3484         ret = _orig_tracepath_glClientWaitSync(sync, flags, timeout);
3485
3486         goto finish;
3487
3488 finish:
3489         _COREGL_TRACEPATH_FUNC_END();
3490         return ret;
3491 }
3492
3493 void
3494 tracepath_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3495 {
3496         _COREGL_TRACEPATH_FUNC_BEGIN();
3497         _orig_tracepath_glWaitSync(sync, flags, timeout);
3498
3499         goto finish;
3500
3501 finish:
3502         _COREGL_TRACEPATH_FUNC_END();
3503 }
3504
3505 void
3506 tracepath_glGetInteger64v(GLenum pname, GLint64* params)
3507 {
3508         _COREGL_TRACEPATH_FUNC_BEGIN();
3509         _orig_tracepath_glGetInteger64v(pname, params);
3510
3511         goto finish;
3512
3513 finish:
3514         _COREGL_TRACEPATH_FUNC_END();
3515 }
3516
3517 void
3518 tracepath_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
3519 {
3520         _COREGL_TRACEPATH_FUNC_BEGIN();
3521         _orig_tracepath_glGetSynciv(sync, pname, bufSize, length, values);
3522
3523         goto finish;
3524
3525 finish:
3526         _COREGL_TRACEPATH_FUNC_END();
3527 }
3528
3529 void
3530 tracepath_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data)
3531 {
3532         _COREGL_TRACEPATH_FUNC_BEGIN();
3533         _orig_tracepath_glGetInteger64i_v(target, index, data);
3534
3535         goto finish;
3536
3537 finish:
3538         _COREGL_TRACEPATH_FUNC_END();
3539 }
3540
3541 void
3542 tracepath_glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
3543 {
3544         _COREGL_TRACEPATH_FUNC_BEGIN();
3545         _orig_tracepath_glGetBufferParameteri64v(target, pname, params);
3546
3547         goto finish;
3548
3549 finish:
3550         _COREGL_TRACEPATH_FUNC_END();
3551 }
3552
3553 void
3554 tracepath_glGenSamplers(GLsizei n, GLuint* samplers)
3555 {
3556         _COREGL_TRACEPATH_FUNC_BEGIN();
3557         _orig_tracepath_glGenSamplers(n, samplers);
3558
3559         goto finish;
3560
3561 finish:
3562         _COREGL_TRACEPATH_FUNC_END();
3563 }
3564
3565 void
3566 tracepath_glDeleteSamplers(GLsizei n, const GLuint* samplers)
3567 {
3568         _COREGL_TRACEPATH_FUNC_BEGIN();
3569         _orig_tracepath_glDeleteSamplers(n, samplers);
3570
3571         goto finish;
3572
3573 finish:
3574         _COREGL_TRACEPATH_FUNC_END();
3575 }
3576
3577 GLboolean
3578 tracepath_glIsSampler(GLuint sampler)
3579 {
3580         GLboolean ret = GL_FALSE;
3581
3582         _COREGL_TRACEPATH_FUNC_BEGIN();
3583         ret = _orig_tracepath_glIsSampler(sampler);
3584
3585         goto finish;
3586
3587 finish:
3588         _COREGL_TRACEPATH_FUNC_END();
3589         return ret;
3590 }
3591
3592 void
3593 tracepath_glBindSampler(GLuint unit, GLuint sampler)
3594 {
3595         _COREGL_TRACEPATH_FUNC_BEGIN();
3596         _orig_tracepath_glBindSampler(unit, sampler);
3597
3598         goto finish;
3599
3600 finish:
3601         _COREGL_TRACEPATH_FUNC_END();
3602 }
3603
3604 void
3605 tracepath_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
3606 {
3607         _COREGL_TRACEPATH_FUNC_BEGIN();
3608         _orig_tracepath_glSamplerParameteri(sampler, pname, param);
3609
3610         goto finish;
3611
3612 finish:
3613         _COREGL_TRACEPATH_FUNC_END();
3614 }
3615
3616 void
3617 tracepath_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
3618 {
3619         _COREGL_TRACEPATH_FUNC_BEGIN();
3620         _orig_tracepath_glSamplerParameteriv(sampler, pname, param);
3621
3622         goto finish;
3623
3624 finish:
3625         _COREGL_TRACEPATH_FUNC_END();
3626 }
3627
3628 void
3629 tracepath_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
3630 {
3631         _COREGL_TRACEPATH_FUNC_BEGIN();
3632         _orig_tracepath_glSamplerParameterf(sampler, pname, param);
3633
3634         goto finish;
3635
3636 finish:
3637         _COREGL_TRACEPATH_FUNC_END();
3638 }
3639
3640 void
3641 tracepath_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
3642 {
3643         _COREGL_TRACEPATH_FUNC_BEGIN();
3644         _orig_tracepath_glSamplerParameterfv(sampler, pname, param);
3645
3646         goto finish;
3647
3648 finish:
3649         _COREGL_TRACEPATH_FUNC_END();
3650 }
3651
3652 void
3653 tracepath_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
3654 {
3655         _COREGL_TRACEPATH_FUNC_BEGIN();
3656         _orig_tracepath_glGetSamplerParameteriv(sampler, pname, params);
3657
3658         goto finish;
3659
3660 finish:
3661         _COREGL_TRACEPATH_FUNC_END();
3662 }
3663
3664 void
3665 tracepath_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
3666 {
3667         _COREGL_TRACEPATH_FUNC_BEGIN();
3668         _orig_tracepath_glGetSamplerParameterfv(sampler, pname, params);
3669
3670         goto finish;
3671
3672 finish:
3673         _COREGL_TRACEPATH_FUNC_END();
3674 }
3675
3676 void
3677 tracepath_glVertexAttribDivisor(GLuint index, GLuint divisor)
3678 {
3679         _COREGL_TRACEPATH_FUNC_BEGIN();
3680         _orig_tracepath_glVertexAttribDivisor(index, divisor);
3681
3682         goto finish;
3683
3684 finish:
3685         _COREGL_TRACEPATH_FUNC_END();
3686 }
3687
3688 void
3689 tracepath_glBindTransformFeedback(GLenum target, GLuint id)
3690 {
3691         _COREGL_TRACEPATH_FUNC_BEGIN();
3692         _orig_tracepath_glBindTransformFeedback(target, id);
3693
3694         goto finish;
3695
3696 finish:
3697         _COREGL_TRACEPATH_FUNC_END();
3698 }
3699
3700 void
3701 tracepath_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
3702 {
3703         _COREGL_TRACEPATH_FUNC_BEGIN();
3704         _orig_tracepath_glDeleteTransformFeedbacks(n, ids);
3705
3706         goto finish;
3707
3708 finish:
3709         _COREGL_TRACEPATH_FUNC_END();
3710 }
3711
3712 void
3713 tracepath_glGenTransformFeedbacks(GLsizei n, GLuint* ids)
3714 {
3715         _COREGL_TRACEPATH_FUNC_BEGIN();
3716         _orig_tracepath_glGenTransformFeedbacks(n, ids);
3717
3718         goto finish;
3719
3720 finish:
3721         _COREGL_TRACEPATH_FUNC_END();
3722 }
3723
3724 GLboolean
3725 tracepath_glIsTransformFeedback(GLuint id)
3726 {
3727         GLboolean ret = GL_FALSE;
3728
3729         _COREGL_TRACEPATH_FUNC_BEGIN();
3730         ret = _orig_tracepath_glIsTransformFeedback(id);
3731
3732         goto finish;
3733
3734 finish:
3735         _COREGL_TRACEPATH_FUNC_END();
3736         return ret;
3737 }
3738
3739 void
3740 tracepath_glPauseTransformFeedback()
3741 {
3742         _COREGL_TRACEPATH_FUNC_BEGIN();
3743         _orig_tracepath_glPauseTransformFeedback();
3744
3745         goto finish;
3746
3747 finish:
3748         _COREGL_TRACEPATH_FUNC_END();
3749 }
3750
3751 void
3752 tracepath_glResumeTransformFeedback()
3753 {
3754         _COREGL_TRACEPATH_FUNC_BEGIN();
3755         _orig_tracepath_glResumeTransformFeedback();
3756
3757         goto finish;
3758
3759 finish:
3760         _COREGL_TRACEPATH_FUNC_END();
3761 }
3762
3763 void
3764 tracepath_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
3765 {
3766         _COREGL_TRACEPATH_FUNC_BEGIN();
3767         _orig_tracepath_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
3768
3769         goto finish;
3770
3771 finish:
3772         _COREGL_TRACEPATH_FUNC_END();
3773 }
3774
3775 void
3776 tracepath_glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
3777 {
3778         _COREGL_TRACEPATH_FUNC_BEGIN();
3779         _orig_tracepath_glGetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
3780
3781         goto finish;
3782
3783 finish:
3784         _COREGL_TRACEPATH_FUNC_END();
3785 }
3786
3787 void
3788 tracepath_glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
3789 {
3790         _COREGL_TRACEPATH_FUNC_BEGIN();
3791         _orig_tracepath_glProgramBinary(program, binaryFormat, binary, length);
3792
3793         goto finish;
3794
3795 finish:
3796         _COREGL_TRACEPATH_FUNC_END();
3797 }
3798
3799 void
3800 tracepath_glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
3801 {
3802         _COREGL_TRACEPATH_FUNC_BEGIN();
3803         _orig_tracepath_glProgramBinaryOES(program, binaryFormat, binary, length);
3804
3805         goto finish;
3806
3807 finish:
3808         _COREGL_TRACEPATH_FUNC_END();
3809 }
3810
3811 void
3812 tracepath_glProgramParameteri(GLuint program, GLenum pname, GLint value)
3813 {
3814         _COREGL_TRACEPATH_FUNC_BEGIN();
3815         _orig_tracepath_glProgramParameteri(program, pname, value);
3816
3817         goto finish;
3818
3819 finish:
3820         _COREGL_TRACEPATH_FUNC_END();
3821 }
3822
3823 void
3824 tracepath_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
3825 {
3826         _COREGL_TRACEPATH_FUNC_BEGIN();
3827         _orig_tracepath_glInvalidateFramebuffer(target, numAttachments, attachments);
3828
3829         goto finish;
3830
3831 finish:
3832         _COREGL_TRACEPATH_FUNC_END();
3833 }
3834
3835 void
3836 tracepath_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
3837 {
3838         _COREGL_TRACEPATH_FUNC_BEGIN();
3839         _orig_tracepath_glDiscardFramebufferEXT(target, numAttachments, attachments);
3840
3841         goto finish;
3842
3843 finish:
3844         _COREGL_TRACEPATH_FUNC_END();
3845 }
3846
3847 void
3848 tracepath_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
3849 {
3850         _COREGL_TRACEPATH_FUNC_BEGIN();
3851         _orig_tracepath_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
3852
3853         goto finish;
3854
3855 finish:
3856         _COREGL_TRACEPATH_FUNC_END();
3857 }
3858
3859 void
3860 tracepath_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
3861 {
3862         _COREGL_TRACEPATH_FUNC_BEGIN();
3863         _orig_tracepath_glTexStorage2D(target, levels, internalformat, width, height);
3864
3865         goto finish;
3866
3867 finish:
3868         _COREGL_TRACEPATH_FUNC_END();
3869 }
3870
3871 void
3872 tracepath_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
3873 {
3874         _COREGL_TRACEPATH_FUNC_BEGIN();
3875         _orig_tracepath_glTexStorage3D(target, levels, internalformat, width, height, depth);
3876
3877         goto finish;
3878
3879 finish:
3880         _COREGL_TRACEPATH_FUNC_END();
3881 }
3882
3883 void
3884 tracepath_glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
3885 {
3886         _COREGL_TRACEPATH_FUNC_BEGIN();
3887         _orig_tracepath_glGetInternalformativ(target, internalformat, pname, bufSize, params);
3888
3889         goto finish;
3890
3891 finish:
3892         _COREGL_TRACEPATH_FUNC_END();
3893 }
3894
3895
3896 /* GLES Extensions */
3897 void
3898 tracepath_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
3899 {
3900         _COREGL_TRACEPATH_FUNC_BEGIN();
3901         _COREGL_TRACE_SURFACE(0, 1, "TEXTURE2DOES");
3902         _orig_tracepath_glEGLImageTargetTexture2DOES(target, image);
3903         goto finish;
3904
3905 finish:
3906         _COREGL_TRACEPATH_FUNC_END();
3907 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3908         if (trace_mem_flag == 1)
3909         {
3910                 MY_MODULE_TSTATE *tstate = NULL;
3911
3912                 GET_MY_TSTATE(tstate, get_current_thread_state());
3913                 AST(tstate != NULL);
3914                 if (tstate->ctx != NULL)
3915                 {
3916                         int objidx = _COREGL_INT_INIT_VALUE;
3917                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
3918                         AST(objidx != _COREGL_INT_INIT_VALUE);
3919
3920                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", 0, 0, 0, "Unknown");
3921                 }
3922         }
3923 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3924 }
3925
3926 void
3927 tracepath_glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
3928 {
3929         _COREGL_TRACEPATH_FUNC_BEGIN();
3930         _orig_tracepath_glEGLImageTargetRenderbufferStorageOES(target, image);
3931         goto finish;
3932
3933 finish:
3934         _COREGL_TRACEPATH_FUNC_END();
3935 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3936         if (trace_mem_flag == 1)
3937         {
3938                 MY_MODULE_TSTATE *tstate = NULL;
3939
3940                 GET_MY_TSTATE(tstate, get_current_thread_state());
3941                 AST(tstate != NULL);
3942                 if (tstate->ctx != NULL)
3943                 {
3944                         int objidx = _COREGL_INT_INIT_VALUE;
3945                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
3946                         AST(objidx != _COREGL_INT_INIT_VALUE);
3947
3948                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", 0, 0, 0, "Unknown");
3949                 }
3950         }
3951 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3952 }
3953
3954 void
3955 tracepath_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program)
3956 {
3957         _COREGL_TRACEPATH_FUNC_BEGIN();
3958         _orig_tracepath_glUseProgramStagesEXT(pipeline, stages, program);
3959
3960         goto finish;
3961
3962 finish:
3963         _COREGL_TRACEPATH_FUNC_END();
3964 }
3965
3966 void
3967 tracepath_glActiveShaderProgramEXT(GLuint pipeline, GLuint program)
3968 {
3969         _COREGL_TRACEPATH_FUNC_BEGIN();
3970         _orig_tracepath_glActiveShaderProgramEXT(pipeline, program);
3971
3972         goto finish;
3973
3974 finish:
3975         _COREGL_TRACEPATH_FUNC_END();
3976 }
3977
3978 GLuint
3979 tracepath_glCreateShaderProgramvEXT(GLenum type, GLsizei count, const char **strings)
3980 {
3981         GLuint ret = _COREGL_INT_INIT_VALUE;
3982
3983         _COREGL_TRACEPATH_FUNC_BEGIN();
3984         ret = _orig_tracepath_glCreateShaderProgramvEXT(type, count, strings);
3985
3986         goto finish;
3987
3988 finish:
3989         _COREGL_TRACEPATH_FUNC_END();
3990    return ret;
3991 }
3992
3993 void
3994 tracepath_glBindProgramPipelineEXT(GLuint pipeline)
3995 {
3996         _COREGL_TRACEPATH_FUNC_BEGIN();
3997         _orig_tracepath_glBindProgramPipelineEXT(pipeline);
3998
3999         goto finish;
4000
4001 finish:
4002         _COREGL_TRACEPATH_FUNC_END();
4003 }
4004
4005 void
4006 tracepath_glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
4007 {
4008         _COREGL_TRACEPATH_FUNC_BEGIN();
4009         _orig_tracepath_glDeleteProgramPipelinesEXT(n, pipelines);
4010
4011         goto finish;
4012
4013 finish:
4014         _COREGL_TRACEPATH_FUNC_END();
4015 }
4016
4017 void
4018 tracepath_glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
4019 {
4020         _COREGL_TRACEPATH_FUNC_BEGIN();
4021         _orig_tracepath_glGenProgramPipelinesEXT(n, pipelines);
4022
4023         goto finish;
4024
4025 finish:
4026         _COREGL_TRACEPATH_FUNC_END();
4027 }
4028
4029 GLboolean
4030 tracepath_glIsProgramPipelineEXT(GLuint pipeline)
4031 {
4032         GLboolean ret = _COREGL_INT_INIT_VALUE;
4033
4034         _COREGL_TRACEPATH_FUNC_BEGIN();
4035         ret = _orig_tracepath_glIsProgramPipelineEXT(pipeline);
4036
4037         goto finish;
4038
4039 finish:
4040         _COREGL_TRACEPATH_FUNC_END();
4041    return ret;
4042 }
4043
4044 void
4045 tracepath_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
4046 {
4047         _COREGL_TRACEPATH_FUNC_BEGIN();
4048         _orig_tracepath_glProgramParameteriEXT(program, pname, value);
4049
4050         goto finish;
4051
4052 finish:
4053         _COREGL_TRACEPATH_FUNC_END();
4054 }
4055
4056 void
4057 tracepath_glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params)
4058 {
4059         _COREGL_TRACEPATH_FUNC_BEGIN();
4060         _orig_tracepath_glGetProgramPipelineivEXT(pipeline, pname, params);
4061
4062         goto finish;
4063
4064 finish:
4065         _COREGL_TRACEPATH_FUNC_END();
4066 }
4067
4068 void
4069 tracepath_glProgramUniform1iEXT(GLuint program, GLint location, GLint x)
4070 {
4071         _COREGL_TRACEPATH_FUNC_BEGIN();
4072         _orig_tracepath_glProgramUniform1iEXT(program, location, x);
4073
4074         goto finish;
4075
4076 finish:
4077         _COREGL_TRACEPATH_FUNC_END();
4078 }
4079
4080 void
4081 tracepath_glProgramUniform2iEXT(GLuint program, GLint location, GLint x, GLint y)
4082 {
4083         _COREGL_TRACEPATH_FUNC_BEGIN();
4084         _orig_tracepath_glProgramUniform2iEXT(program, location, x, y);
4085
4086         goto finish;
4087
4088 finish:
4089         _COREGL_TRACEPATH_FUNC_END();
4090 }
4091
4092 void
4093 tracepath_glProgramUniform3iEXT(GLuint program, GLint location, GLint x, GLint y, GLint z)
4094 {
4095         _COREGL_TRACEPATH_FUNC_BEGIN();
4096         _orig_tracepath_glProgramUniform3iEXT(program, location, x, y, z);
4097
4098         goto finish;
4099
4100 finish:
4101         _COREGL_TRACEPATH_FUNC_END();
4102 }
4103
4104 void
4105 tracepath_glProgramUniform4iEXT(GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w)
4106 {
4107         _COREGL_TRACEPATH_FUNC_BEGIN();
4108         _orig_tracepath_glProgramUniform4iEXT(program, location, x, y, z, w);
4109
4110         goto finish;
4111
4112 finish:
4113         _COREGL_TRACEPATH_FUNC_END();
4114 }
4115
4116 void
4117 tracepath_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat x)
4118 {
4119         _COREGL_TRACEPATH_FUNC_BEGIN();
4120         _orig_tracepath_glProgramUniform1fEXT(program, location, x);
4121
4122         goto finish;
4123
4124 finish:
4125         _COREGL_TRACEPATH_FUNC_END();
4126 }
4127
4128 void
4129 tracepath_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x, GLfloat y)
4130 {
4131         _COREGL_TRACEPATH_FUNC_BEGIN();
4132         _orig_tracepath_glProgramUniform2fEXT(program, location, x, y);
4133
4134         goto finish;
4135
4136 finish:
4137         _COREGL_TRACEPATH_FUNC_END();
4138 }
4139
4140 void
4141 tracepath_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z)
4142 {
4143         _COREGL_TRACEPATH_FUNC_BEGIN();
4144         _orig_tracepath_glProgramUniform3fEXT(program, location, x, y, z);
4145
4146         goto finish;
4147
4148 finish:
4149         _COREGL_TRACEPATH_FUNC_END();
4150 }
4151
4152 void
4153 tracepath_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4154 {
4155         _COREGL_TRACEPATH_FUNC_BEGIN();
4156         _orig_tracepath_glProgramUniform4fEXT(program, location, x, y, z, w);
4157
4158         goto finish;
4159
4160 finish:
4161         _COREGL_TRACEPATH_FUNC_END();
4162 }
4163
4164 void
4165 tracepath_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4166 {
4167         _COREGL_TRACEPATH_FUNC_BEGIN();
4168         _orig_tracepath_glProgramUniform1ivEXT(program, location, count, value);
4169
4170         goto finish;
4171
4172 finish:
4173         _COREGL_TRACEPATH_FUNC_END();
4174 }
4175
4176 void
4177 tracepath_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4178 {
4179         _COREGL_TRACEPATH_FUNC_BEGIN();
4180         _orig_tracepath_glProgramUniform2ivEXT(program, location, count, value);
4181
4182         goto finish;
4183
4184 finish:
4185         _COREGL_TRACEPATH_FUNC_END();
4186 }
4187
4188 void
4189 tracepath_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4190 {
4191         _COREGL_TRACEPATH_FUNC_BEGIN();
4192         _orig_tracepath_glProgramUniform3ivEXT(program, location, count, value);
4193
4194         goto finish;
4195
4196 finish:
4197         _COREGL_TRACEPATH_FUNC_END();
4198 }
4199
4200 void
4201 tracepath_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4202 {
4203         _COREGL_TRACEPATH_FUNC_BEGIN();
4204         _orig_tracepath_glProgramUniform4ivEXT(program, location, count, value);
4205
4206         goto finish;
4207
4208 finish:
4209         _COREGL_TRACEPATH_FUNC_END();
4210 }
4211
4212 void
4213 tracepath_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4214 {
4215         _COREGL_TRACEPATH_FUNC_BEGIN();
4216         _orig_tracepath_glProgramUniform1fvEXT(program, location, count, value);
4217
4218         goto finish;
4219
4220 finish:
4221         _COREGL_TRACEPATH_FUNC_END();
4222 }
4223
4224 void
4225 tracepath_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4226 {
4227         _COREGL_TRACEPATH_FUNC_BEGIN();
4228         _orig_tracepath_glProgramUniform2fvEXT(program, location, count, value);
4229
4230         goto finish;
4231
4232 finish:
4233         _COREGL_TRACEPATH_FUNC_END();
4234 }
4235
4236 void
4237 tracepath_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4238 {
4239         _COREGL_TRACEPATH_FUNC_BEGIN();
4240         _orig_tracepath_glProgramUniform3fvEXT(program, location, count, value);
4241
4242         goto finish;
4243
4244 finish:
4245         _COREGL_TRACEPATH_FUNC_END();
4246 }
4247
4248 void
4249 tracepath_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4250 {
4251         _COREGL_TRACEPATH_FUNC_BEGIN();
4252         _orig_tracepath_glProgramUniform4fvEXT(program, location, count, value);
4253
4254         goto finish;
4255
4256 finish:
4257         _COREGL_TRACEPATH_FUNC_END();
4258 }
4259
4260 void
4261 tracepath_glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4262 {
4263         _COREGL_TRACEPATH_FUNC_BEGIN();
4264         _orig_tracepath_glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
4265
4266         goto finish;
4267
4268 finish:
4269         _COREGL_TRACEPATH_FUNC_END();
4270 }
4271
4272 void
4273 tracepath_glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4274 {
4275         _COREGL_TRACEPATH_FUNC_BEGIN();
4276         _orig_tracepath_glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
4277
4278         goto finish;
4279
4280 finish:
4281         _COREGL_TRACEPATH_FUNC_END();
4282 }
4283
4284 void
4285 tracepath_glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4286 {
4287         _COREGL_TRACEPATH_FUNC_BEGIN();
4288         _orig_tracepath_glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
4289
4290         goto finish;
4291
4292 finish:
4293         _COREGL_TRACEPATH_FUNC_END();
4294 }
4295
4296 void
4297 tracepath_glValidateProgramPipelineEXT(GLuint pipeline)
4298 {
4299         _COREGL_TRACEPATH_FUNC_BEGIN();
4300         _orig_tracepath_glValidateProgramPipelineEXT(pipeline);
4301
4302         goto finish;
4303
4304 finish:
4305         _COREGL_TRACEPATH_FUNC_END();
4306 }
4307
4308 void
4309 tracepath_glGetProgramPipelineInfoLogEXT(GLuint pipeline, GLsizei bufSize, GLsizei *length, char *infoLog)
4310 {
4311         _COREGL_TRACEPATH_FUNC_BEGIN();
4312         _orig_tracepath_glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
4313
4314         goto finish;
4315
4316 finish:
4317         _COREGL_TRACEPATH_FUNC_END();
4318 }
4319
4320
4321 void
4322 tracepath_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
4323 {
4324         _COREGL_TRACEPATH_FUNC_BEGIN();
4325
4326 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4327         tracepath_fbdump_update(0);
4328 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4329
4330         _orig_tracepath_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
4331
4332 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4333         tracepath_fbdump_update(1);
4334 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4335
4336         goto finish;
4337
4338 finish:
4339         _COREGL_TRACEPATH_FUNC_END();
4340 }
4341
4342 void
4343 tracepath_glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
4344 {
4345         _COREGL_TRACEPATH_FUNC_BEGIN();
4346         _orig_tracepath_glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
4347
4348         goto finish;
4349
4350 finish:
4351         _COREGL_TRACEPATH_FUNC_END();
4352 }
4353
4354 void
4355 tracepath_glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
4356 {
4357         _COREGL_TRACEPATH_FUNC_BEGIN();
4358         _orig_tracepath_glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
4359
4360         goto finish;
4361
4362 finish:
4363         _COREGL_TRACEPATH_FUNC_END();
4364 }
4365
4366 void
4367 tracepath_glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
4368 {
4369         _COREGL_TRACEPATH_FUNC_BEGIN();
4370
4371         _orig_tracepath_glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
4372
4373         goto finish;
4374
4375 finish:
4376         _COREGL_TRACEPATH_FUNC_END();
4377 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4378         if (trace_mem_flag == 1)
4379         {
4380                 MY_MODULE_TSTATE *tstate = NULL;
4381
4382                 GET_MY_TSTATE(tstate, get_current_thread_state());
4383                 AST(tstate != NULL);
4384                 if (tstate->ctx != NULL)
4385                 {
4386                         int objidx = _COREGL_INT_INIT_VALUE;
4387                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4388                         AST(objidx != _COREGL_INT_INIT_VALUE);
4389
4390                         // Detect byte per pixel
4391                         int bpp = 0;
4392                         char formatment[80];
4393                         switch (internalformat)
4394                         {
4395                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
4396                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
4397                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
4398                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
4399                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
4400                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
4401                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
4402                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
4403                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
4404                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
4405                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
4406                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
4407                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
4408                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
4409                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
4410                         }
4411
4412                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
4413                 }
4414         }
4415 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4416 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4417         if (trace_surface_flag == 1)
4418         {
4419                 MY_MODULE_TSTATE *tstate = NULL;
4420
4421                 GET_MY_TSTATE(tstate, get_current_thread_state());
4422                 AST(tstate != NULL);
4423                 if (tstate->ctx != NULL)
4424                 {
4425                         int objidx = _COREGL_INT_INIT_VALUE;
4426                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4427                         AST(objidx != _COREGL_INT_INIT_VALUE);
4428
4429                         {
4430                                 int channel = 0;
4431                                 switch (internalformat)
4432                                 {
4433                                         case GL_ALPHA:
4434                                         case GL_LUMINANCE:
4435                                         case GL_DEPTH_COMPONENT :
4436                                         case 0x81A5:
4437                                         case 0x81A6:
4438                                         case 0x81A7:
4439                                         case 0x8D46 :
4440                                         case 0x8D47 :
4441                                         case 0x8D48 : channel = 1; break;
4442                                         case GL_LUMINANCE_ALPHA:
4443                                         case 0x84F9: channel = 2; break;
4444                                         case GL_RGB: channel = 3; break;
4445                                         case GL_RGBA:
4446                                         case 0x80E1: channel = 4; break;
4447                                 }
4448
4449                                 char name[256];
4450                                 sprintf(name, "FBORB_%d", objidx);
4451                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
4452                         }
4453                 }
4454         }
4455 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4456 }
4457
4458
4459 void
4460 tracepath_glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params)
4461 {
4462         _COREGL_TRACEPATH_FUNC_BEGIN();
4463         _orig_tracepath_glGetBufferPointervOES(target, pname, params);
4464
4465         goto finish;
4466
4467 finish:
4468         _COREGL_TRACEPATH_FUNC_END();
4469 }
4470
4471
4472 void *
4473 tracepath_glMapBufferOES(GLenum target, GLenum access)
4474 {
4475         void *ret = NULL;
4476
4477         _COREGL_TRACEPATH_FUNC_BEGIN();
4478         ret = _orig_tracepath_glMapBufferOES(target, access);
4479
4480         goto finish;
4481
4482 finish:
4483         _COREGL_TRACEPATH_FUNC_END();
4484    return ret;
4485 }
4486
4487
4488 GLboolean
4489 tracepath_glUnmapBufferOES(GLenum target)
4490 {
4491         GLboolean ret = GL_FALSE;
4492
4493         _COREGL_TRACEPATH_FUNC_BEGIN();
4494         ret = _orig_tracepath_glUnmapBufferOES(target);
4495
4496         goto finish;
4497
4498 finish:
4499         _COREGL_TRACEPATH_FUNC_END();
4500    return ret;
4501 }
4502
4503 /* GLES3.1 API */
4504 void
4505 tracepath_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
4506 {
4507         _COREGL_TRACEPATH_FUNC_BEGIN();
4508         _orig_tracepath_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
4509
4510         goto finish;
4511
4512 finish:
4513         _COREGL_TRACEPATH_FUNC_END();
4514 }
4515
4516 GLuint
4517 tracepath_glCreateShaderProgramv(GLenum type,  GLsizei count,  const GLchar *const*strings)
4518 {
4519         GLboolean ret = GL_FALSE;
4520         _COREGL_TRACEPATH_FUNC_BEGIN();
4521         ret = _orig_tracepath_glCreateShaderProgramv(type, count, strings);
4522
4523         goto finish;
4524
4525 finish:
4526         _COREGL_TRACEPATH_FUNC_END();
4527    return ret;
4528 }
4529
4530 void
4531 tracepath_glGenProgramPipelines( GLsizei n,  GLuint *pipelines)
4532 {
4533         _COREGL_TRACEPATH_FUNC_BEGIN();
4534         _orig_tracepath_glGenProgramPipelines(n, pipelines);
4535
4536         goto finish;
4537
4538 finish:
4539         _COREGL_TRACEPATH_FUNC_END();
4540 }
4541
4542 void
4543 tracepath_glBindProgramPipeline( GLuint pipeline)
4544 {
4545         _COREGL_TRACEPATH_FUNC_BEGIN();
4546         _orig_tracepath_glBindProgramPipeline(pipeline);
4547
4548         goto finish;
4549
4550 finish:
4551         _COREGL_TRACEPATH_FUNC_END();
4552 }
4553
4554 void
4555 tracepath_glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
4556 {
4557         _COREGL_TRACEPATH_FUNC_BEGIN();
4558         _orig_tracepath_glGetProgramPipelineiv(pipeline, pname, params);
4559
4560         goto finish;
4561
4562 finish:
4563         _COREGL_TRACEPATH_FUNC_END();
4564 }
4565
4566 void
4567 tracepath_glDeleteProgramPipelines(GLsizei n, GLuint const *pipelines)
4568 {
4569         _COREGL_TRACEPATH_FUNC_BEGIN();
4570         _orig_tracepath_glDeleteProgramPipelines(n, pipelines);
4571
4572         goto finish;
4573
4574 finish:
4575         _COREGL_TRACEPATH_FUNC_END();
4576 }
4577
4578 GLboolean
4579 tracepath_glIsProgramPipeline( GLuint pipeline)
4580 {
4581         GLboolean ret = GL_FALSE;
4582
4583         _COREGL_TRACEPATH_FUNC_BEGIN();
4584         ret = _orig_tracepath_glIsProgramPipeline(pipeline);
4585
4586         goto finish;
4587
4588 finish:
4589         _COREGL_TRACEPATH_FUNC_END();
4590         return ret;
4591 }
4592
4593 void
4594 tracepath_glValidateProgramPipeline(GLuint pipeline)
4595 {
4596         _COREGL_TRACEPATH_FUNC_BEGIN();
4597         _orig_tracepath_glValidateProgramPipeline(pipeline);
4598
4599         goto finish;
4600
4601 finish:
4602         _COREGL_TRACEPATH_FUNC_END();
4603 }
4604
4605 void
4606 tracepath_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
4607 {
4608         _COREGL_TRACEPATH_FUNC_BEGIN();
4609         _orig_tracepath_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
4610
4611         goto finish;
4612
4613 finish:
4614         _COREGL_TRACEPATH_FUNC_END();
4615 }
4616
4617 void
4618 tracepath_glDispatchComputeIndirect( GLintptr indirect)
4619 {
4620         _COREGL_TRACEPATH_FUNC_BEGIN();
4621         _orig_tracepath_glDispatchComputeIndirect(indirect);
4622
4623         goto finish;
4624
4625 finish:
4626         _COREGL_TRACEPATH_FUNC_END();
4627 }
4628
4629 void
4630 tracepath_glDrawArraysIndirect(GLenum mode, GLvoid const *indirect)
4631 {
4632         _COREGL_TRACEPATH_FUNC_BEGIN();
4633         _orig_tracepath_glDrawArraysIndirect(mode, indirect);
4634
4635         goto finish;
4636
4637 finish:
4638         _COREGL_TRACEPATH_FUNC_END();
4639 }
4640
4641 void
4642 tracepath_glDrawElementsIndirect(GLenum mode, GLenum type, GLvoid const *indirect)
4643 {
4644         _COREGL_TRACEPATH_FUNC_BEGIN();
4645         _orig_tracepath_glDrawElementsIndirect(mode, type, indirect);
4646
4647         goto finish;
4648
4649 finish:
4650         _COREGL_TRACEPATH_FUNC_END();
4651 }
4652
4653 void
4654 tracepath_glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
4655 {
4656         _COREGL_TRACEPATH_FUNC_BEGIN();
4657         _orig_tracepath_glFramebufferParameteri(target, pname, param);
4658
4659         goto finish;
4660
4661 finish:
4662         _COREGL_TRACEPATH_FUNC_END();
4663 }
4664
4665 void
4666 tracepath_glGetFramebufferParameteriv( GLenum target,  GLenum pname,  GLint * params)
4667 {
4668         _COREGL_TRACEPATH_FUNC_BEGIN();
4669         _orig_tracepath_glGetFramebufferParameteriv(target,  pname,  params);
4670
4671         goto finish;
4672
4673 finish:
4674         _COREGL_TRACEPATH_FUNC_END();
4675 }
4676
4677 void
4678 tracepath_glGetProgramInterfaceiv(GLuint program,  GLenum programInterface,  GLenum pname,  GLint * params)
4679 {
4680         _COREGL_TRACEPATH_FUNC_BEGIN();
4681         _orig_tracepath_glGetProgramInterfaceiv(program, programInterface, pname, params);
4682
4683         goto finish;
4684
4685 finish:
4686         _COREGL_TRACEPATH_FUNC_END();
4687 }
4688
4689 GLuint
4690 tracepath_glGetProgramResourceIndex( GLuint program,  GLenum programInterface,  const char * name)
4691 {
4692         GLuint ret = GL_INVALID_INDEX;
4693         _COREGL_TRACEPATH_FUNC_BEGIN();
4694         ret =  _orig_tracepath_glGetProgramResourceIndex(program,  programInterface,  name);
4695
4696         goto finish;
4697
4698 finish:
4699         _COREGL_TRACEPATH_FUNC_END();
4700         return ret;
4701 }
4702
4703 void
4704 tracepath_glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
4705 {
4706         _COREGL_TRACEPATH_FUNC_BEGIN();
4707
4708         _orig_tracepath_glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
4709
4710         goto finish;
4711
4712 finish:
4713         _COREGL_TRACEPATH_FUNC_END();
4714 }
4715
4716 void
4717 tracepath_glGetProgramResourceiv( GLuint program,  GLenum programInterface,  GLuint index,  GLsizei propCount,  const GLenum * props,  GLsizei bufSize,  GLsizei * length,  GLint * params)
4718 {
4719         _COREGL_TRACEPATH_FUNC_BEGIN();
4720
4721         _orig_tracepath_glGetProgramResourceiv(program,  programInterface,  index,  propCount,  props,  bufSize,  length,  params);
4722
4723         goto finish;
4724
4725 finish:
4726         _COREGL_TRACEPATH_FUNC_END();
4727 }
4728
4729 GLint
4730 tracepath_glGetProgramResourceLocation(GLuint program, GLenum programInterface, GLchar const *name)
4731 {
4732         GLuint ret = -1;
4733         _COREGL_TRACEPATH_FUNC_BEGIN();
4734
4735         ret = _orig_tracepath_glGetProgramResourceLocation(program, programInterface, name);
4736
4737         goto finish;
4738
4739 finish:
4740         _COREGL_TRACEPATH_FUNC_END();
4741         return ret;
4742 }
4743
4744 void
4745 tracepath_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
4746 {
4747         _COREGL_TRACEPATH_FUNC_BEGIN();
4748         _orig_tracepath_glUseProgramStages(pipeline, stages, program);
4749
4750         goto finish;
4751
4752 finish:
4753         _COREGL_TRACEPATH_FUNC_END();
4754 }
4755
4756 void
4757 tracepath_glActiveShaderProgram(GLuint pipeline, GLuint program)
4758 {
4759         _COREGL_TRACEPATH_FUNC_BEGIN();
4760         _orig_tracepath_glActiveShaderProgram(pipeline, program);
4761
4762         goto finish;
4763
4764 finish:
4765         _COREGL_TRACEPATH_FUNC_END();
4766 }
4767
4768 void
4769 tracepath_glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
4770 {
4771         _COREGL_TRACEPATH_FUNC_BEGIN();
4772         _orig_tracepath_glProgramUniform1iv(program, location, count, value);
4773
4774         goto finish;
4775
4776 finish:
4777         _COREGL_TRACEPATH_FUNC_END();
4778 }
4779
4780 void
4781 tracepath_glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
4782 {
4783         _COREGL_TRACEPATH_FUNC_BEGIN();
4784         _orig_tracepath_glProgramUniform2iv(program, location, count, value);
4785
4786         goto finish;
4787
4788 finish:
4789         _COREGL_TRACEPATH_FUNC_END();
4790 }
4791
4792 void
4793 tracepath_glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
4794 {
4795         _COREGL_TRACEPATH_FUNC_BEGIN();
4796         _orig_tracepath_glProgramUniform3iv(program, location, count, value);
4797
4798         goto finish;
4799
4800 finish:
4801         _COREGL_TRACEPATH_FUNC_END();
4802 }
4803
4804 void
4805 tracepath_glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
4806 {
4807         _COREGL_TRACEPATH_FUNC_BEGIN();
4808         _orig_tracepath_glProgramUniform4iv(program, location, count, value);
4809
4810         goto finish;
4811
4812 finish:
4813         _COREGL_TRACEPATH_FUNC_END();
4814 }
4815
4816 void
4817 tracepath_glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4818 {
4819         _COREGL_TRACEPATH_FUNC_BEGIN();
4820         _orig_tracepath_glProgramUniform1fv(program, location, count, value);
4821
4822         goto finish;
4823
4824 finish:
4825         _COREGL_TRACEPATH_FUNC_END();
4826 }
4827
4828 void
4829 tracepath_glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4830 {
4831         _COREGL_TRACEPATH_FUNC_BEGIN();
4832         _orig_tracepath_glProgramUniform2fv(program, location, count, value);
4833
4834         goto finish;
4835
4836 finish:
4837         _COREGL_TRACEPATH_FUNC_END();
4838 }
4839
4840 void
4841 tracepath_glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4842 {
4843         _COREGL_TRACEPATH_FUNC_BEGIN();
4844         _orig_tracepath_glProgramUniform3fv(program, location, count, value);
4845
4846         goto finish;
4847
4848 finish:
4849         _COREGL_TRACEPATH_FUNC_END();
4850 }
4851
4852 void
4853 tracepath_glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4854 {
4855         _COREGL_TRACEPATH_FUNC_BEGIN();
4856         _orig_tracepath_glProgramUniform4fv(program, location, count, value);
4857
4858         goto finish;
4859
4860 finish:
4861         _COREGL_TRACEPATH_FUNC_END();
4862 }
4863
4864 void
4865 tracepath_glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4866 {
4867         _COREGL_TRACEPATH_FUNC_BEGIN();
4868         _orig_tracepath_glProgramUniformMatrix2fv(program, location, count, transpose, value);
4869
4870         goto finish;
4871
4872 finish:
4873         _COREGL_TRACEPATH_FUNC_END();
4874 }
4875
4876 void
4877 tracepath_glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4878 {
4879         _COREGL_TRACEPATH_FUNC_BEGIN();
4880         _orig_tracepath_glProgramUniformMatrix3fv(program, location, count, transpose, value);
4881
4882         goto finish;
4883
4884 finish:
4885         _COREGL_TRACEPATH_FUNC_END();
4886 }
4887
4888 void
4889 tracepath_glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4890 {
4891         _COREGL_TRACEPATH_FUNC_BEGIN();
4892         _orig_tracepath_glProgramUniformMatrix4fv(program, location, count, transpose, value);
4893
4894         goto finish;
4895
4896 finish:
4897         _COREGL_TRACEPATH_FUNC_END();
4898 }
4899
4900 void
4901 tracepath_glProgramUniform1i(GLuint program, GLint location, GLint x)
4902 {
4903         _COREGL_TRACEPATH_FUNC_BEGIN();
4904         _orig_tracepath_glProgramUniform1i(program, location, x);
4905
4906         goto finish;
4907
4908 finish:
4909         _COREGL_TRACEPATH_FUNC_END();
4910 }
4911
4912 void
4913 tracepath_glProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
4914 {
4915         _COREGL_TRACEPATH_FUNC_BEGIN();
4916         _orig_tracepath_glProgramUniform2i(program, location, x, y);
4917
4918         goto finish;
4919
4920 finish:
4921         _COREGL_TRACEPATH_FUNC_END();
4922 }
4923
4924 void
4925 tracepath_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y, GLint z)
4926 {
4927         _COREGL_TRACEPATH_FUNC_BEGIN();
4928         _orig_tracepath_glProgramUniform3i(program, location, x, y, z);
4929
4930         goto finish;
4931
4932 finish:
4933         _COREGL_TRACEPATH_FUNC_END();
4934 }
4935
4936 void
4937 tracepath_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w)
4938 {
4939         _COREGL_TRACEPATH_FUNC_BEGIN();
4940         _orig_tracepath_glProgramUniform4i(program, location, x, y, z, w);
4941
4942         goto finish;
4943
4944 finish:
4945         _COREGL_TRACEPATH_FUNC_END();
4946 }
4947
4948 void
4949 tracepath_glProgramUniform1f(GLuint program, GLint location, GLfloat x)
4950 {
4951         _COREGL_TRACEPATH_FUNC_BEGIN();
4952         _orig_tracepath_glProgramUniform1f(program, location, x);
4953
4954         goto finish;
4955
4956 finish:
4957         _COREGL_TRACEPATH_FUNC_END();
4958 }
4959
4960 void
4961 tracepath_glProgramUniform2f(GLuint program, GLint location, GLfloat x, GLfloat y)
4962 {
4963         _COREGL_TRACEPATH_FUNC_BEGIN();
4964         _orig_tracepath_glProgramUniform2f(program, location, x, y);
4965
4966         goto finish;
4967
4968 finish:
4969         _COREGL_TRACEPATH_FUNC_END();
4970 }
4971
4972 void
4973 tracepath_glProgramUniform3f(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z)
4974 {
4975         _COREGL_TRACEPATH_FUNC_BEGIN();
4976         _orig_tracepath_glProgramUniform3f(program, location, x, y, z);
4977
4978         goto finish;
4979
4980 finish:
4981         _COREGL_TRACEPATH_FUNC_END();
4982 }
4983
4984 void
4985 tracepath_glProgramUniform4f(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4986 {
4987         _COREGL_TRACEPATH_FUNC_BEGIN();
4988         _orig_tracepath_glProgramUniform4f(program, location, x, y, z, w);
4989
4990         goto finish;
4991
4992 finish:
4993         _COREGL_TRACEPATH_FUNC_END();
4994 }
4995
4996 void
4997 tracepath_glProgramUniform1ui(GLuint program, GLint location, GLuint x)
4998 {
4999         _COREGL_TRACEPATH_FUNC_BEGIN();
5000         _orig_tracepath_glProgramUniform1ui(program, location, x);
5001
5002         goto finish;
5003
5004 finish:
5005         _COREGL_TRACEPATH_FUNC_END();
5006 }
5007
5008 void
5009 tracepath_glProgramUniform2ui(GLuint program, GLint location, GLuint x, GLuint y)
5010 {
5011         _COREGL_TRACEPATH_FUNC_BEGIN();
5012         _orig_tracepath_glProgramUniform2ui(program, location, x, y);
5013
5014         goto finish;
5015
5016 finish:
5017         _COREGL_TRACEPATH_FUNC_END();
5018 }
5019
5020 void
5021 tracepath_glProgramUniform3ui(GLuint program, GLint location, GLuint x, GLuint y, GLuint z)
5022 {
5023         _COREGL_TRACEPATH_FUNC_BEGIN();
5024         _orig_tracepath_glProgramUniform3ui(program, location, x, y, z);
5025
5026         goto finish;
5027
5028 finish:
5029         _COREGL_TRACEPATH_FUNC_END();
5030 }
5031
5032 void
5033 tracepath_glProgramUniform4ui(GLuint program, GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
5034 {
5035         _COREGL_TRACEPATH_FUNC_BEGIN();
5036         _orig_tracepath_glProgramUniform4ui(program, location, x, y, z, w);
5037
5038         goto finish;
5039
5040 finish:
5041         _COREGL_TRACEPATH_FUNC_END();
5042 }
5043
5044 void
5045 tracepath_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
5046 {
5047         _COREGL_TRACEPATH_FUNC_BEGIN();
5048         _orig_tracepath_glProgramUniform1uiv(program, location, count, value);
5049
5050         goto finish;
5051
5052 finish:
5053         _COREGL_TRACEPATH_FUNC_END();
5054 }
5055
5056 void
5057 tracepath_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
5058 {
5059         _COREGL_TRACEPATH_FUNC_BEGIN();
5060         _orig_tracepath_glProgramUniform2uiv(program, location, count, value);
5061
5062         goto finish;
5063
5064 finish:
5065         _COREGL_TRACEPATH_FUNC_END();
5066 }
5067
5068 void
5069 tracepath_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
5070 {
5071         _COREGL_TRACEPATH_FUNC_BEGIN();
5072         _orig_tracepath_glProgramUniform3uiv(program, location, count, value);
5073
5074         goto finish;
5075
5076 finish:
5077         _COREGL_TRACEPATH_FUNC_END();
5078 }
5079
5080 void
5081 tracepath_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
5082 {
5083         _COREGL_TRACEPATH_FUNC_BEGIN();
5084         _orig_tracepath_glProgramUniform4uiv(program, location, count, value);
5085
5086         goto finish;
5087
5088 finish:
5089         _COREGL_TRACEPATH_FUNC_END();
5090 }
5091
5092 void
5093 tracepath_glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5094 {
5095         _COREGL_TRACEPATH_FUNC_BEGIN();
5096         _orig_tracepath_glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
5097
5098         goto finish;
5099
5100 finish:
5101         _COREGL_TRACEPATH_FUNC_END();
5102 }
5103
5104 void
5105 tracepath_glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5106 {
5107         _COREGL_TRACEPATH_FUNC_BEGIN();
5108         _orig_tracepath_glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
5109
5110         goto finish;
5111
5112 finish:
5113         _COREGL_TRACEPATH_FUNC_END();
5114 }
5115
5116 void
5117 tracepath_glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5118 {
5119         _COREGL_TRACEPATH_FUNC_BEGIN();
5120         _orig_tracepath_glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
5121
5122         goto finish;
5123
5124 finish:
5125         _COREGL_TRACEPATH_FUNC_END();
5126 }
5127
5128 void
5129 tracepath_glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5130 {
5131         _COREGL_TRACEPATH_FUNC_BEGIN();
5132         _orig_tracepath_glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
5133
5134         goto finish;
5135
5136 finish:
5137         _COREGL_TRACEPATH_FUNC_END();
5138 }
5139
5140 void
5141 tracepath_glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5142 {
5143         _COREGL_TRACEPATH_FUNC_BEGIN();
5144         _orig_tracepath_glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
5145
5146         goto finish;
5147
5148 finish:
5149         _COREGL_TRACEPATH_FUNC_END();
5150 }
5151
5152 void
5153 tracepath_glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5154 {
5155         _COREGL_TRACEPATH_FUNC_BEGIN();
5156         _orig_tracepath_glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
5157
5158         goto finish;
5159
5160 finish:
5161         _COREGL_TRACEPATH_FUNC_END();
5162 }
5163
5164 void
5165 tracepath_glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
5166 {
5167         _COREGL_TRACEPATH_FUNC_BEGIN();
5168
5169         _orig_tracepath_glBindImageTexture(unit, texture, level, layered, layer, access, format);
5170
5171         goto finish;
5172
5173 finish:
5174         _COREGL_TRACEPATH_FUNC_END();
5175 }
5176
5177 void
5178 tracepath_glGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
5179 {
5180         _COREGL_TRACEPATH_FUNC_BEGIN();
5181         _orig_tracepath_glGetBooleani_v (target, index, data);
5182
5183         goto finish;
5184
5185 finish:
5186         _COREGL_TRACEPATH_FUNC_END();
5187 }
5188
5189 void
5190 tracepath_glMemoryBarrier (GLbitfield barriers)
5191 {
5192         _COREGL_TRACEPATH_FUNC_BEGIN();
5193         _orig_tracepath_glMemoryBarrier (barriers);
5194
5195         goto finish;
5196
5197 finish:
5198         _COREGL_TRACEPATH_FUNC_END();
5199 }
5200
5201 void tracepath_glMemoryBarrierByRegion (GLbitfield barriers)
5202 {
5203         _COREGL_TRACEPATH_FUNC_BEGIN();
5204         _orig_tracepath_glMemoryBarrierByRegion (barriers);
5205
5206         goto finish;
5207
5208 finish:
5209         _COREGL_TRACEPATH_FUNC_END();
5210 }
5211
5212 void
5213 tracepath_glTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
5214 {
5215         _COREGL_TRACEPATH_FUNC_BEGIN();
5216         _orig_tracepath_glTexStorage2DMultisample (target, samples, internalformat, width, height, fixedsamplelocations);
5217
5218         goto finish;
5219
5220 finish:
5221         _COREGL_TRACEPATH_FUNC_END();
5222 }
5223
5224 void
5225 tracepath_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
5226 {
5227         _COREGL_TRACEPATH_FUNC_BEGIN();
5228         _orig_tracepath_glGetMultisamplefv (pname, index, val);
5229
5230         goto finish;
5231
5232 finish:
5233         _COREGL_TRACEPATH_FUNC_END();
5234 }
5235
5236 void
5237 tracepath_glSampleMaski (GLuint maskNumber, GLbitfield mask)
5238 {
5239         _COREGL_TRACEPATH_FUNC_BEGIN();
5240         _orig_tracepath_glSampleMaski (maskNumber, mask);
5241
5242         goto finish;
5243
5244 finish:
5245         _COREGL_TRACEPATH_FUNC_END();
5246 }
5247
5248 void
5249 tracepath_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
5250 {
5251         _COREGL_TRACEPATH_FUNC_BEGIN();
5252         _orig_tracepath_glGetTexLevelParameteriv (target, level, pname, params);
5253
5254         goto finish;
5255
5256 finish:
5257         _COREGL_TRACEPATH_FUNC_END();
5258 }
5259
5260 void
5261 tracepath_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
5262 {
5263         _COREGL_TRACEPATH_FUNC_BEGIN();
5264         _orig_tracepath_glGetTexLevelParameterfv (target, level, pname, params);
5265
5266         goto finish;
5267
5268 finish:
5269         _COREGL_TRACEPATH_FUNC_END();
5270 }
5271
5272 void
5273 tracepath_glBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
5274 {
5275         _COREGL_TRACEPATH_FUNC_BEGIN();
5276         _orig_tracepath_glBindVertexBuffer (bindingindex, buffer, offset, stride);
5277
5278         goto finish;
5279
5280 finish:
5281         _COREGL_TRACEPATH_FUNC_END();
5282 }
5283
5284
5285 void tracepath_glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
5286 {
5287         _COREGL_TRACEPATH_FUNC_BEGIN();
5288         _orig_tracepath_glVertexAttribFormat (attribindex, size, type, normalized, relativeoffset);
5289
5290         goto finish;
5291
5292 finish:
5293         _COREGL_TRACEPATH_FUNC_END();
5294 }
5295
5296 void tracepath_glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5297 {
5298         _COREGL_TRACEPATH_FUNC_BEGIN();
5299         _orig_tracepath_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
5300
5301         goto finish;
5302
5303 finish:
5304         _COREGL_TRACEPATH_FUNC_END();
5305 }
5306
5307 void tracepath_glVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
5308 {
5309         _COREGL_TRACEPATH_FUNC_BEGIN();
5310         _orig_tracepath_glVertexAttribBinding (attribindex, bindingindex);
5311
5312         goto finish;
5313
5314 finish:
5315         _COREGL_TRACEPATH_FUNC_END();
5316 }
5317
5318 void tracepath_glVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
5319 {
5320         _COREGL_TRACEPATH_FUNC_BEGIN();
5321         _orig_tracepath_glVertexBindingDivisor (bindingindex, divisor);
5322
5323         goto finish;
5324
5325 finish:
5326         _COREGL_TRACEPATH_FUNC_END();
5327 }