probe_graphics/da_gles20.inc

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Sanghyun Lee <sanghyunnim.lee@samsung.com>
   9  * Juyoung Kim <j0.kim@samsung.com>
  10  * Vitaliy Cherepanov <v.cherepanov@samsung.com>
  11  *
  12  * This library is free software; you can redistribute it and/or modify it under
  13  * the terms of the GNU Lesser General Public License as published by the
  14  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  20  * License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  24  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  * - Samsung RnD Institute Russia
  29  *
  30  */
  31 #include "da_gles20.h"
  32 #include "daprobe.h"
  33 #include "binproto.h"
  34 #include "real_functions.h"
  35 #include "common_probe_init.h"
  36
  37 static char contextValue[MAX_GL_CONTEXT_VALUE_SIZE]; /* maybe it should not be gobal static variable */
  38 static __thread GLenum gl_error_external = GL_NO_ERROR;
  39 static __thread int is_gl_error_external = 1;
  40
  41 static void __ui_array_to_str(char *to, GLuint *arr ,int count, size_t bufsize)
  42 {
  43         int i = 0, len = 0;
  44
  45         for (i = 0; i < count; i++) {
  46                 if (bufsize < sizeof(GLuint) * 4) {
  47                         PRINTERR("too small buffer.");
  48                         break;
  49                 }
  50
  51                 len = snprintf(to, bufsize,"%u, ", *arr++);
  52
  53                 to += len;
  54                 bufsize -= len;
  55         }
  56
  57         if (count != 0) {
  58                 to -= 2;
  59                 *to = '\0';
  60         }
  61 }
  62
  63
  64 static void __get_context_buf_data(GLenum target, char *buf, int buf_size)
  65 {
  66        GLint n_buffer_size, n_buffer_usage_size;
  67        int print_size;
  68
  69        if (buf == NULL)
  70                return;
  71
  72        real_glGetBufferParameteriv(target, GL_BUFFER_SIZE,
  73                                    &n_buffer_size);
  74        real_glGetBufferParameteriv(target, GL_BUFFER_USAGE,
  75                                    &n_buffer_usage_size);
  76
  77        print_size = snprintf(buf, buf_size, "%u,%u,%u",
  78                              target, n_buffer_size, n_buffer_usage_size);
  79
  80        if (print_size >= buf_size) {
  81                /* data was truncated. so data is invalid */
  82                buf[0]='\0';
  83        }
  84 }
  85
  86 // ==================================================================
  87 // A 2
  88 // ==================================================================
  89
  90 DECLARE_NOARGS(GLenum, glGetError)
  91 {
  92         TYPEDEF(GLenum (*methodType)(void));
  93         BEFORE(glGetError);
  94         GLenum ret = CALL_ORIG(glGetError,);
  95
  96         if (gl_error_external == GL_NO_ERROR)
  97                 gl_error_external = ret;
  98
  99         if (is_gl_error_external && blockresult) {
 100                 //external call
 101                 ret = gl_error_external;
 102                 gl_error_external = GL_NO_ERROR;
 103
 104                 AFTER_NO_PARAM('d', ret, APITYPE_CONTEXT, "");
 105         }
 106
 107
 108         return ret;
 109 }
 110 DECLARE(void, glActiveTexture, GLenum texture)
 111 {
 112         TYPEDEF(void (*methodType)(GLenum));
 113         BEFORE(glActiveTexture);
 114         CALL_ORIG(glActiveTexture, texture);
 115         GL_GET_ERROR();
 116         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 117               (uint64_t)(texture));
 118 }
 119
 120 DECLARE(void, glAttachShader, GLuint program, GLuint shader)
 121 {
 122         TYPEDEF(void (*methodType)(GLuint, GLuint));
 123         BEFORE(glAttachShader);
 124         CALL_ORIG(glAttachShader, program, shader);
 125         GL_GET_ERROR();
 126         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd", program, shader);
 127 }
 128
 129 // ==================================================================
 130 // B 12
 131 // ==================================================================
 132
 133 DECLARE(void, glBindAttribLocation, GLuint program, GLuint index, const char *name)
 134 {
 135         TYPEDEF(void (*methodType)(GLuint, GLuint, const char *));
 136         BEFORE(glBindAttribLocation);
 137         CALL_ORIG(glBindAttribLocation, program, index, name);
 138         GL_GET_ERROR();
 139         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dds",
 140               program, index, name);
 141 }
 142
 143 DECLARE(void, glBindBuffer, GLenum target, GLuint buffer)
 144 {
 145         char context_value[MAX_GL_CONTEXT_VALUE_SIZE] = {0,};
 146
 147         TYPEDEF(void (*methodType)(GLenum, GLuint));
 148         BEFORE(glBindBuffer);
 149         CALL_ORIG(glBindBuffer, target, buffer);
 150         if (blockresult && buffer)
 151                 __get_context_buf_data(target, &context_value[0],
 152                                        sizeof(context_value));
 153
 154         GL_GET_ERROR();
 155         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, context_value, "xd",
 156               (uint64_t)(target), buffer);
 157 }
 158
 159 DECLARE(void, glBindFramebuffer, GLenum target, GLuint framebuffer)
 160 {
 161         TYPEDEF(void (*methodType)(GLenum, GLuint));
 162         BEFORE(glBindFramebuffer);
 163         CALL_ORIG(glBindFramebuffer, target, framebuffer);
 164         GL_GET_ERROR();
 165         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
 166               (uint64_t)(target), framebuffer);
 167 }
 168
 169 DECLARE(void, glBindRenderbuffer, GLenum target, GLuint renderbuffer)
 170 {
 171         TYPEDEF(void (*methodType)(GLenum, GLuint));
 172         BEFORE(glBindRenderbuffer);
 173         CALL_ORIG(glBindRenderbuffer, target, renderbuffer);
 174         GL_GET_ERROR();
 175         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
 176               (uint64_t)(target), renderbuffer);
 177 }
 178
 179 DECLARE(void, glBindTexture, GLenum target, GLuint texture)
 180 {
 181         TYPEDEF(void (*methodType)(GLenum, GLuint));
 182         BEFORE(glBindTexture);
 183         CALL_ORIG(glBindTexture, target, texture);
 184         GL_GET_ERROR();
 185         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
 186               (uint64_t)(target), texture);
 187 }
 188
 189 DECLARE(void, glBlendColor, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 190 {
 191         TYPEDEF(void (*methodType)(GLclampf, GLclampf, GLclampf, GLclampf));
 192         BEFORE(glBlendColor);
 193         CALL_ORIG(glBlendColor, red, green, blue, alpha);
 194         GL_GET_ERROR();
 195         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
 196               red, green, blue, alpha);
 197 }
 198
 199 DECLARE(void, glBlendEquation, GLenum mode)
 200 {
 201         TYPEDEF(void (*methodType)(GLenum));
 202         BEFORE(glBlendEquation);
 203         CALL_ORIG(glBlendEquation, mode);
 204         GL_GET_ERROR();
 205         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 206               (uint64_t)(mode));
 207 }
 208
 209 DECLARE(void, glBlendEquationSeparate, GLenum modeRGB, GLenum modeAlpha)
 210 {
 211         TYPEDEF(void (*methodType)(GLenum, GLenum));
 212         BEFORE(glBlendEquationSeparate);
 213         CALL_ORIG(glBlendEquationSeparate, modeRGB, modeAlpha);
 214         GL_GET_ERROR();
 215         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 216               (uint64_t)(modeRGB), (uint64_t)(modeAlpha));
 217 }
 218
 219 DECLARE(void, glBlendFunc, GLenum sfactor, GLenum dfactor)
 220 {
 221         TYPEDEF(void (*methodType)(GLenum, GLenum));
 222         BEFORE(glBlendFunc);
 223         CALL_ORIG(glBlendFunc, sfactor, dfactor);
 224         GL_GET_ERROR();
 225         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 226               (uint64_t)(sfactor), (uint64_t)(dfactor));
 227 }
 228
 229 DECLARE(void, glBlendFuncSeparate, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
 230                          GLenum dstAlpha)
 231 {
 232         TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLenum));
 233         BEFORE(glBlendFuncSeparate);
 234         CALL_ORIG(glBlendFuncSeparate, srcRGB, dstRGB, srcAlpha, dstAlpha);
 235         GL_GET_ERROR();
 236         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
 237               (uint64_t)(srcRGB), (uint64_t)(dstRGB),
 238               (uint64_t)(srcAlpha), (uint64_t)(dstAlpha));
 239 }
 240
 241 DECLARE(void, glBufferData, GLenum target, GLsizeiptr size, const GLvoid * data,
 242                   GLenum usage)
 243 {
 244         TYPEDEF(void (*methodType)(GLenum, GLsizeiptr, const GLvoid *, GLenum));
 245         BEFORE(glBufferData);
 246         CALL_ORIG(glBufferData, target, size, data, usage);
 247
 248         char context_value[MAX_GL_CONTEXT_VALUE_SIZE];
 249         if (blockresult)
 250                 __get_context_buf_data(target, &context_value[0],
 251                                        sizeof(context_value));
 252         GL_GET_ERROR();
 253         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, context_value, "xxpx",
 254               (uint64_t)(target), (uint64_t)(size),
 255               voidp_to_uint64(data), (uint64_t)(usage));
 256 }
 257
 258 DECLARE(void, glBufferSubData, GLenum target, GLintptr offset, GLsizeiptr size,
 259                      const GLvoid * data)
 260 {
 261         TYPEDEF(void (*methodType)(GLenum, GLintptr, GLsizeiptr,
 262                                    const GLvoid *));
 263         BEFORE(glBufferSubData);
 264
 265         char context_value[MAX_GL_CONTEXT_VALUE_SIZE];
 266         if (blockresult)
 267                 __get_context_buf_data(target, &context_value[0],
 268                                        sizeof(context_value));
 269         CALL_ORIG(glBufferSubData, target, offset, size, data);
 270         GL_GET_ERROR();
 271         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, context_value, "xxxp",
 272               (uint64_t)(target), (uint64_t)(offset),
 273               (uint64_t)(size), voidp_to_uint64(data));
 274 }
 275
 276 // ==================================================================
 277 // C 14
 278 // ==================================================================
 279
 280 DECLARE(GLenum, glCheckFramebufferStatus, GLenum target)
 281 {
 282         TYPEDEF(GLenum (*methodType)(GLenum));
 283         BEFORE(glCheckFramebufferStatus);
 284         GLenum ret = CALL_ORIG(glCheckFramebufferStatus, target);
 285         GL_GET_ERROR();
 286         AFTER('d', ret, APITYPE_CONTEXT, "", "x",
 287               (uint64_t)(target));
 288
 289         return ret;
 290 }
 291
 292 DECLARE(void, glClear, GLbitfield mask)
 293 {
 294         TYPEDEF(void (*methodType)(GLbitfield));
 295         BEFORE(glClear);
 296         CALL_ORIG(glClear, mask);
 297         GL_GET_ERROR();
 298         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 299               (uint64_t)(mask));
 300 }
 301
 302 DECLARE(void, glClearColor, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 303 {
 304         TYPEDEF(void (*methodType)(GLclampf, GLclampf, GLclampf, GLclampf));
 305         BEFORE(glClearColor);
 306         CALL_ORIG(glClearColor, red, green, blue, alpha);
 307         GL_GET_ERROR();
 308         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
 309               red, green, blue, alpha);
 310 }
 311
 312 DECLARE(void, glClearDepthf, GLclampf depth)
 313 {
 314         TYPEDEF(void (*methodType)(GLclampf));
 315         BEFORE(glClearDepthf);
 316         CALL_ORIG(glClearDepthf, depth);
 317         GL_GET_ERROR();
 318         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", depth);
 319 }
 320
 321 DECLARE(void, glClearStencil, GLint s)
 322 {
 323         TYPEDEF(void (*methodType)(GLint));
 324         BEFORE(glClearStencil);
 325         CALL_ORIG(glClearStencil, s);
 326         GL_GET_ERROR();
 327         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", s);
 328 }
 329
 330 DECLARE(void, glColorMask, GLboolean red, GLboolean green, GLboolean blue,
 331                  GLboolean alpha)
 332 {
 333         TYPEDEF(void (*methodType)(GLboolean, GLboolean, GLboolean, GLboolean));
 334         BEFORE(glColorMask);
 335         CALL_ORIG(glColorMask, red, green, blue, alpha);
 336         GL_GET_ERROR();
 337         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
 338               red, green, blue, alpha);
 339 }
 340
 341 DECLARE(void, glCompileShader, GLuint shader)
 342 {
 343         TYPEDEF(void (*methodType)(GLuint));
 344         BEFORE(glCompileShader);
 345         CALL_ORIG(glCompileShader, shader);
 346         GL_GET_ERROR();
 347         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 348               (uint64_t)(shader));
 349 }
 350
 351 DECLARE(void, glCompressedTexImage2D, GLenum target, GLint level, GLenum internalformat,
 352                             GLsizei width, GLsizei height, GLint border,
 353                             GLsizei imageSize, const GLvoid * data)
 354 {
 355         TYPEDEF(void (*methodType)(GLenum, GLint, GLenum, GLsizei, GLsizei,
 356                                    GLint, GLsizei, const GLvoid *));
 357         BEFORE(glCompressedTexImage2D);
 358         CALL_ORIG(glCompressedTexImage2D, target, level, internalformat, width,
 359                   height, border, imageSize, data);
 360         GL_GET_ERROR();
 361         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddp",
 362               (uint64_t)(target), level,
 363               (uint64_t)(internalformat), width, height, border, imageSize,
 364               voidp_to_uint64(data));
 365 }
 366
 367 DECLARE(void, glCompressedTexSubImage2D, GLenum target, GLint level, GLint xoffset,
 368                                GLint yoffset, GLsizei width, GLsizei height,
 369                                GLenum format, GLsizei imageSize,
 370                                const GLvoid * data)
 371 {
 372         TYPEDEF(void (*methodType)(GLenum, GLint, GLint, GLint, GLsizei,
 373                                    GLsizei, GLenum, GLsizei, const GLvoid *));
 374         BEFORE(glCompressedTexSubImage2D);
 375         CALL_ORIG(glCompressedTexSubImage2D, target, level, xoffset, yoffset,
 376                   width, height, format, imageSize, data);
 377         GL_GET_ERROR();
 378         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxdp",
 379               (uint64_t)(target), level, xoffset, yoffset, width, height,
 380               (uint64_t)(format), imageSize, voidp_to_uint64(data));
 381 }
 382
 383 DECLARE(void, glCopyTexImage2D, GLenum target, GLint level, GLenum internalformat,
 384                       GLint x, GLint y, GLsizei width, GLsizei height,
 385                       GLint border)
 386 {
 387         TYPEDEF(void (*methodType)(GLenum, GLint, GLenum, GLint, GLint,
 388                                    GLsizei, GLsizei, GLint));
 389         BEFORE(glCopyTexImage2D);
 390         CALL_ORIG(glCopyTexImage2D, target, level, internalformat, x, y, width,
 391                   height, border);
 392         GL_GET_ERROR();
 393         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddd",
 394               (uint64_t)(target), level,
 395               (uint64_t)(internalformat), x, y, width, height, border);
 396 }
 397
 398 DECLARE(void, glCopyTexSubImage2D, GLenum target, GLint level, GLint xoffset,
 399                          GLint yoffset, GLint x, GLint y, GLsizei width,
 400                          GLsizei height)
 401 {
 402         TYPEDEF(void (*methodType)(GLenum, GLint, GLint, GLint, GLint, GLint,
 403                                    GLsizei, GLsizei));
 404         BEFORE(glCopyTexSubImage2D);
 405         CALL_ORIG(glCopyTexSubImage2D, target, level, xoffset, yoffset, x, y,
 406                   width, height);
 407         GL_GET_ERROR();
 408         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xddddddd",
 409               (uint64_t)(target), level, xoffset, yoffset, x, y, width,
 410               height);
 411 }
 412
 413 DECLARE_NOARGS(GLuint, glCreateProgram)
 414 {
 415         TYPEDEF(GLuint (*methodType)(void));
 416         BEFORE(glCreateProgram);
 417         GLuint ret = CALL_ORIG(glCreateProgram,);
 418         GL_GET_ERROR();
 419         AFTER_NO_PARAM('d', ret, APITYPE_CONTEXT, "");
 420
 421         return ret;
 422 }
 423
 424 DECLARE(GLuint, glCreateShader, GLenum shaderType)
 425 {
 426         TYPEDEF(GLuint (*methodType)(GLenum));
 427         BEFORE(glCreateShader);
 428         GLuint ret = CALL_ORIG(glCreateShader, shaderType);
 429         GL_GET_ERROR();
 430         AFTER('d', ret, APITYPE_CONTEXT, "", "x", (uint64_t)(shaderType));
 431
 432         return ret;
 433 }
 434
 435 DECLARE(void, glCullFace, GLenum mode)
 436 {
 437         TYPEDEF(void (*methodType)(GLenum));
 438         BEFORE(glCullFace);
 439         CALL_ORIG(glCullFace, mode);
 440         GL_GET_ERROR();
 441         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 442               (uint64_t)(mode));
 443 }
 444
 445 // ==================================================================
 446 // D 14
 447 // ==================================================================
 448
 449 DECLARE(void, glDeleteBuffers, GLsizei n, const GLuint * buffers)
 450 {
 451         TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
 452         BEFORE(glDeleteBuffers);
 453
 454         char context_value[MAX_GL_CONTEXT_VALUE_SIZE];
 455         CALL_ORIG(glDeleteBuffers, n, buffers);
 456         GL_GET_ERROR();
 457         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, context_value, "dp",
 458               n, voidp_to_uint64(buffers));
 459 }
 460
 461 DECLARE(void, glDeleteFramebuffers, GLsizei n, const GLuint * framebuffers)
 462 {
 463         TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
 464         BEFORE(glDeleteFramebuffers);
 465         CALL_ORIG(glDeleteFramebuffers, n, framebuffers);
 466         GL_GET_ERROR();
 467         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 468               n, voidp_to_uint64(framebuffers));
 469 }
 470
 471 DECLARE(void, glDeleteProgram, GLuint program)
 472 {
 473         TYPEDEF(void (*methodType)(GLuint));
 474         BEFORE(glDeleteProgram);
 475         CALL_ORIG(glDeleteProgram, program);
 476         GL_GET_ERROR();
 477         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", program);
 478 }
 479
 480 DECLARE(void, glDeleteRenderbuffers, GLsizei n, const GLuint * renderbuffers)
 481 {
 482         TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
 483         BEFORE(glDeleteRenderbuffers);
 484         CALL_ORIG(glDeleteRenderbuffers, n, renderbuffers);
 485         GL_GET_ERROR();
 486         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 487               n, voidp_to_uint64(renderbuffers));
 488 }
 489
 490 DECLARE(void, glDeleteShader, GLuint shader)
 491 {
 492         TYPEDEF(void (*methodType)(GLuint));
 493         BEFORE(glDeleteShader);
 494         CALL_ORIG(glDeleteShader, shader);
 495         GL_GET_ERROR();
 496         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", shader);
 497 }
 498
 499 DECLARE(void, glDeleteTextures, GLsizei n, const GLuint *textures)
 500 {
 501         TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
 502         char buf[128] = "";
 503
 504         BEFORE(glDeleteTextures);
 505         CALL_ORIG(glDeleteTextures, n, textures);
 506         GL_GET_ERROR();
 507         if (error == GL_NO_ERROR)
 508                 __ui_array_to_str(buf, (GLuint *)textures, n, sizeof(buf));
 509
 510         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
 511               n, voidp_to_uint64(textures));
 512 }
 513
 514 DECLARE(void, glDepthFunc, GLenum func)
 515 {
 516         TYPEDEF(void (*methodType)(GLenum));
 517         BEFORE(glDepthFunc);
 518         CALL_ORIG(glDepthFunc, func);
 519         GL_GET_ERROR();
 520         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 521               (uint64_t)(func));
 522 }
 523
 524 DECLARE(void, glDepthMask, GLboolean flag)
 525 {
 526         TYPEDEF(void (*methodType)(GLboolean));
 527         BEFORE(glDepthMask);
 528         CALL_ORIG(glDepthMask, flag);
 529         GL_GET_ERROR();
 530         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 531               (uint64_t)(flag));
 532 }
 533
 534 DECLARE(void, glDepthRangef, GLclampf nearVal, GLclampf farVal)
 535 {
 536         TYPEDEF(void (*methodType)(GLclampf, GLclampf));
 537         BEFORE(glDepthRangef);
 538         CALL_ORIG(glDepthRangef, nearVal, farVal);
 539         GL_GET_ERROR();
 540         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
 541               nearVal, farVal);
 542 }
 543
 544 DECLARE(void, glDetachShader, GLuint program, GLuint shader)
 545 {
 546         TYPEDEF(void (*methodType)(GLuint, GLuint));
 547         BEFORE(glDetachShader);
 548         CALL_ORIG(glDetachShader, program, shader);
 549         GL_GET_ERROR();
 550         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 551               program, shader);
 552 }
 553
 554 DECLARE(void, glDisable, GLenum cap)
 555 {
 556         TYPEDEF(void (*methodType)(GLenum));
 557         BEFORE(glDisable);
 558         CALL_ORIG(glDisable, cap);
 559         GL_GET_ERROR();
 560         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
 561 }
 562
 563 DECLARE(void, glDisableVertexAttribArray, GLuint index)
 564 {
 565         TYPEDEF(void (*methodType)(GLuint));
 566         BEFORE(glDisableVertexAttribArray);
 567         CALL_ORIG(glDisableVertexAttribArray, index);
 568         GL_GET_ERROR();
 569         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
 570 }
 571
 572 DECLARE(void, glDrawArrays, GLenum mode, GLint first, GLsizei count)
 573 {
 574         TYPEDEF(void (*methodType)(GLenum, GLint, GLsizei));
 575         BEFORE(glDrawArrays);
 576         CALL_ORIG(glDrawArrays, mode, first, count);
 577         GL_GET_ERROR();
 578         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
 579               (uint64_t)(mode), first, count);
 580 }
 581
 582 DECLARE(void, glDrawElements, GLenum mode, GLsizei count, GLenum type,
 583                 const GLvoid *indices)
 584 {
 585         TYPEDEF(void (*methodType)(GLenum, GLsizei, GLenum, const GLvoid *));
 586         BEFORE(glDrawElements);
 587         CALL_ORIG(glDrawElements, mode, count, type, indices);
 588         GL_GET_ERROR();
 589         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxp",
 590               (uint64_t)(mode), count, (uint64_t)(type), indices);
 591 }
 592
 593 // ==================================================================
 594 // E 2
 595 // ==================================================================
 596
 597 DECLARE(void, glEnable, GLenum cap)
 598 {
 599         TYPEDEF(void (*methodType)(GLenum));
 600         BEFORE(glEnable);
 601         CALL_ORIG(glEnable, cap);
 602         GL_GET_ERROR();
 603         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
 604 }
 605
 606 DECLARE(void, glEnableVertexAttribArray, GLuint index)
 607 {
 608         TYPEDEF(void (*methodType)(GLuint));
 609         BEFORE(glEnableVertexAttribArray);
 610         CALL_ORIG(glEnableVertexAttribArray, index);
 611         GL_GET_ERROR();
 612         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
 613 }
 614
 615 // ==================================================================
 616 // F 5
 617 // ==================================================================
 618
 619 DECLARE_NOARGS(void, glFinish)
 620 {
 621         TYPEDEF(void (*methodType)(void));
 622         BEFORE(glFinish);
 623         CALL_ORIG(glFinish,);
 624         GL_GET_ERROR();
 625         AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
 626 }
 627
 628 DECLARE_NOARGS(void, glFlush)
 629 {
 630         TYPEDEF(void (*methodType)(void));
 631         BEFORE(glFlush);
 632         CALL_ORIG(glFlush,);
 633         GL_GET_ERROR();
 634         AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
 635 }
 636
 637 DECLARE(void, glFramebufferRenderbuffer, GLenum target, GLenum attachment,
 638                                GLenum renderbuffertarget, GLuint renderbuffer)
 639 {
 640         TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLuint));
 641         BEFORE(glFramebufferRenderbuffer);
 642         CALL_ORIG(glFramebufferRenderbuffer, target, attachment,
 643                   renderbuffertarget, renderbuffer);
 644         GL_GET_ERROR();
 645         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxd",
 646               (uint64_t)(target), (uint64_t)(attachment),
 647               (uint64_t)(renderbuffertarget), renderbuffer);
 648 }
 649
 650 DECLARE(void, glFramebufferTexture2D, GLenum target, GLenum attachment, GLenum textarget,
 651                             GLuint texture, GLint level)
 652 {
 653         TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLuint, GLint));
 654         BEFORE(glFramebufferTexture2D);
 655         CALL_ORIG(glFramebufferTexture2D, target, attachment, textarget,
 656                   texture, level);
 657         GL_GET_ERROR();
 658         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxdd",
 659               (uint64_t)(target), (uint64_t)(attachment),
 660               (uint64_t)(textarget), texture, level);
 661 }
 662
 663 DECLARE(void, glFrontFace, GLenum mode)
 664 {
 665         TYPEDEF(void (*methodType)(GLenum));
 666         BEFORE(glFrontFace);
 667         CALL_ORIG(glFrontFace, mode);
 668         GL_GET_ERROR();
 669         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 670               (uint64_t)(mode));
 671 }
 672
 673 // ==================================================================
 674 // G 31
 675 // ==================================================================
 676
 677 DECLARE(void, glGenBuffers, GLsizei n, GLuint * buffers)
 678 {
 679         TYPEDEF(void (*methodType)(GLsizei, GLuint *));
 680         char buf[128] = "";
 681
 682         BEFORE(glGenBuffers);
 683         CALL_ORIG(glGenBuffers, n, buffers);
 684         GL_GET_ERROR();
 685         if (error == GL_NO_ERROR)
 686                 __ui_array_to_str(buf, buffers, n, sizeof(buf));
 687
 688         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
 689               n, voidp_to_uint64(buffers));
 690 }
 691
 692 DECLARE(void, glGenFramebuffers, GLsizei n, GLuint * framebuffers)
 693 {
 694         TYPEDEF(void (*methodType)(GLsizei, GLuint *));
 695         BEFORE(glGenFramebuffers);
 696         CALL_ORIG(glGenFramebuffers, n, framebuffers);
 697         GL_GET_ERROR();
 698         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 699               n, voidp_to_uint64(framebuffers));
 700 }
 701
 702 DECLARE(void, glGenRenderbuffers, GLsizei n, GLuint * renderbuffers)
 703 {
 704         TYPEDEF(void (*methodType)(GLsizei, GLuint *));
 705         BEFORE(glGenRenderbuffers);
 706         CALL_ORIG(glGenRenderbuffers, n, renderbuffers);
 707         GL_GET_ERROR();
 708         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 709               n, voidp_to_uint64(renderbuffers));
 710 }
 711
 712 DECLARE(void, glGenTextures, GLsizei n, GLuint * textures)
 713 {
 714         TYPEDEF(void (*methodType)(GLsizei, GLuint *));
 715         char buf[128] = "";
 716
 717         BEFORE(glGenTextures);
 718         CALL_ORIG(glGenTextures, n, textures);
 719         GL_GET_ERROR();
 720         if (error == GL_NO_ERROR)
 721                 __ui_array_to_str(buf, textures, n, sizeof(buf));
 722
 723         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
 724               n, voidp_to_uint64(textures));
 725 }
 726
 727 DECLARE(void, glGenerateMipmap, GLenum target)
 728 {
 729         TYPEDEF(void (*methodType)(GLenum));
 730         BEFORE(glGenerateMipmap);
 731         CALL_ORIG(glGenerateMipmap, target);
 732         GL_GET_ERROR();
 733         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 734               (uint64_t)(target));
 735 }
 736
 737 //lsh_get
 738 DECLARE(void, glGetBooleanv, GLenum pname, GLboolean * params)
 739 {
 740         TYPEDEF(void (*methodType)(GLenum, GLboolean *));
 741         BEFORE(glGetBooleanv);
 742         CALL_ORIG(glGetBooleanv, pname, params);
 743         GL_GET_ERROR();
 744         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 745               (uint64_t)(pname));
 746 }
 747
 748 //lsh_get
 749 DECLARE(void, glGetFloatv, GLenum pname, GLfloat * params)
 750 {
 751         TYPEDEF(void (*methodType)(GLenum, GLfloat *));
 752         BEFORE(glGetFloatv);
 753         CALL_ORIG(glGetFloatv, pname, params);
 754         GL_GET_ERROR();
 755         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 756               (uint64_t)(pname));
 757 }
 758
 759 //lsh_get
 760 DECLARE(void, glGetIntegerv, GLenum pname, GLint * params)
 761 {
 762         TYPEDEF(void (*methodType)(GLenum, GLint *));
 763         BEFORE(glGetIntegerv);
 764         CALL_ORIG(glGetIntegerv, pname, params);
 765         GL_GET_ERROR();
 766         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 767               (uint64_t)(pname));
 768 }
 769
 770 //lsh_get
 771 DECLARE(void, glGetActiveAttrib, GLuint program, GLuint index, GLsizei bufSize,
 772                        GLsizei *length, GLint *size, GLenum *type, char *name)
 773 {
 774         TYPEDEF(void (*methodType)(GLuint, GLuint, GLsizei, GLsizei *, GLint *,
 775                                    GLenum *, char *));
 776         BEFORE(glGetActiveAttrib);
 777         CALL_ORIG(glGetActiveAttrib, program, index, bufSize, length, size,
 778                   type, name);
 779         GL_GET_ERROR();
 780         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
 781               program, index, bufSize);
 782 }
 783
 784 //lsh_get
 785 DECLARE(void, glGetActiveUniform, GLuint program, GLuint index, GLsizei bufSize,
 786                         GLsizei *length, GLint *size, GLenum *type, char *name)
 787 {
 788         TYPEDEF(void (*methodType)(GLuint, GLuint, GLsizei, GLsizei *, GLint *,
 789                                    GLenum *, char *));
 790         BEFORE(glGetActiveUniform);
 791         CALL_ORIG(glGetActiveUniform, program, index, bufSize, length, size,
 792                   type, name);
 793         GL_GET_ERROR();
 794         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
 795               program, index, bufSize);
 796 }
 797
 798 //lsh_get
 799 DECLARE(void, glGetAttachedShaders, GLuint program, GLsizei maxCount, GLsizei *count,
 800                           GLuint *shaders)
 801 {
 802         TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, GLuint *));
 803         BEFORE(glGetAttachedShaders);
 804         CALL_ORIG(glGetAttachedShaders, program, maxCount, count, shaders);
 805         GL_GET_ERROR();
 806         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 807               program, maxCount);
 808 }
 809
 810 //lsh_get
 811 DECLARE(int ,glGetAttribLocation, GLuint program, const char *name)
 812 {
 813         TYPEDEF(int (*methodType)(GLuint, const char*));
 814         BEFORE(glGetAttribLocation);
 815         int ret = CALL_ORIG(glGetAttribLocation, program, name);
 816         GL_GET_ERROR();
 817         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xs",
 818               (uint64_t)(program), name);
 819         return ret;
 820 }
 821
 822 //lsh_get
 823 DECLARE(void, glGetBufferParameteriv, GLenum target, GLenum value, GLint * data)
 824 {
 825         TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
 826         BEFORE(glGetBufferParameteriv);
 827         CALL_ORIG(glGetBufferParameteriv, target, value, data);
 828         GL_GET_ERROR();
 829         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 830               (uint64_t)(target), (uint64_t)(value));
 831 }
 832
 833 //lsh_get
 834 DECLARE(void, glGetFramebufferAttachmentParameteriv, GLenum target, GLenum attachment,
 835                                            GLenum pname, GLint * params)
 836 {
 837         TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLint *));
 838         BEFORE(glGetFramebufferAttachmentParameteriv);
 839         CALL_ORIG(glGetFramebufferAttachmentParameteriv, target, attachment,
 840                   pname, params);
 841         GL_GET_ERROR();
 842         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
 843               (uint64_t)(target), (uint64_t)(attachment), (uint64_t)(pname));
 844 }
 845
 846 //lsh_get
 847 DECLARE(void, glGetProgramInfoLog, GLuint program, GLsizei maxLength, GLsizei *length,
 848                          char *infoLog)
 849 {
 850         TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, char *));
 851         BEFORE(glGetProgramInfoLog);
 852         CALL_ORIG(glGetProgramInfoLog, program, maxLength, length, infoLog);
 853         GL_GET_ERROR();
 854         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 855               program, maxLength);
 856 }
 857
 858 //lsh_get
 859 DECLARE(void, glGetProgramiv, GLuint program, GLenum pname, GLint *params)
 860 {
 861         TYPEDEF(void (*methodType)(GLuint, GLenum, GLint *));
 862         BEFORE(glGetProgramiv);
 863         CALL_ORIG(glGetProgramiv, program, pname, params);
 864         GL_GET_ERROR();
 865         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 866               program, (uint64_t)(pname));
 867 }
 868
 869 //lsh_get
 870 DECLARE(void, glGetRenderbufferParameteriv, GLenum target, GLenum pname, GLint *params)
 871 {
 872         TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
 873         BEFORE(glGetRenderbufferParameteriv);
 874         CALL_ORIG(glGetRenderbufferParameteriv, target, pname, params);
 875         GL_GET_ERROR();
 876         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 877               (uint64_t)(target), (uint64_t)(pname));
 878 }
 879
 880 //lsh_get
 881 DECLARE(void, glGetShaderInfoLog, GLuint shader, GLsizei maxLength, GLsizei *length,
 882                         char *infoLog)
 883 {
 884         TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, char *));
 885         BEFORE(glGetShaderInfoLog);
 886         CALL_ORIG(glGetShaderInfoLog, shader, maxLength, length, infoLog);
 887         GL_GET_ERROR();
 888         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 889               shader, maxLength);
 890 }
 891
 892 //lsh_get
 893 DECLARE(void, glGetShaderPrecisionFormat, GLenum shaderType, GLenum precisionType,
 894                                 GLint *range, GLint *precision)
 895 {
 896         TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *, GLint *));
 897         BEFORE(glGetShaderPrecisionFormat);
 898         CALL_ORIG(glGetShaderPrecisionFormat, shaderType, precisionType, range,
 899                   precision);
 900         GL_GET_ERROR();
 901         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 902               (uint64_t)(shaderType), (uint64_t)(precisionType));
 903 }
 904
 905 //lsh_get
 906 DECLARE(void, glGetShaderSource, GLuint shader, GLsizei bufSize, GLsizei *length,
 907                        char *source)
 908 {
 909         TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, char *));
 910         BEFORE(glGetShaderSource);
 911         CALL_ORIG(glGetShaderSource, shader, bufSize, length, source);
 912         GL_GET_ERROR();
 913         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 914               shader, bufSize);
 915 }
 916
 917 //lsh_get
 918 DECLARE(void, glGetShaderiv, GLuint shader, GLenum pname, GLint *params)
 919 {
 920         TYPEDEF(void (*methodType)(GLuint, GLenum, GLint *));
 921         BEFORE(glGetShaderiv);
 922         CALL_ORIG(glGetShaderiv, shader, pname, params);
 923         GL_GET_ERROR();
 924         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 925               shader, (uint64_t)(pname));
 926 }
 927
 928 DECLARE(const GLubyte *, glGetString, GLenum name)
 929 {
 930         TYPEDEF(const GLubyte *(*methodType)(GLenum));
 931         BEFORE(glGetString);
 932         const GLubyte *ret = CALL_ORIG(glGetString, name);
 933         GL_GET_ERROR();
 934         AFTER('p', ret, APITYPE_CONTEXT, "", "x", (uint64_t)(name));
 935
 936         return ret;
 937 }
 938 //lsh_get
 939 DECLARE(void, glGetTexParameterfv, GLenum target, GLenum pname, GLfloat * params)
 940 {
 941         TYPEDEF(void (*methodType)(GLenum, GLenum, GLfloat *));
 942         BEFORE(glGetTexParameterfv);
 943         CALL_ORIG(glGetTexParameterfv, target, pname, params);
 944         GL_GET_ERROR();
 945         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 946               (uint64_t)(target), (uint64_t)(pname));
 947 }
 948
 949 //lsh_get
 950 DECLARE(void, glGetTexParameteriv, GLenum target, GLenum pname, GLint * params)
 951 {
 952         TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
 953         BEFORE(glGetTexParameteriv);
 954         CALL_ORIG(glGetTexParameteriv, target, pname, params);
 955         GL_GET_ERROR();
 956         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 957               (uint64_t)(target), (uint64_t)(pname));
 958 }
 959
 960 //lsh_get
 961 DECLARE(void, glGetUniformfv, GLuint program, GLint location, GLfloat *params)
 962 {
 963         TYPEDEF(void (*methodType)(GLuint, GLuint, GLfloat *));
 964         BEFORE(glGetUniformfv);
 965         CALL_ORIG(glGetUniformfv, program, location, params);
 966         GL_GET_ERROR();
 967         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 968               program, location);
 969 }
 970
 971 //lsh_get
 972 DECLARE(void, glGetUniformiv, GLuint program, GLint location, GLint *params)
 973 {
 974         TYPEDEF(void (*methodType)(GLuint, GLuint, GLint *));
 975         BEFORE(glGetUniformiv);
 976         CALL_ORIG(glGetUniformiv, program, location, params);
 977         GL_GET_ERROR();
 978         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 979               program, location);
 980 }
 981
 982 //lsh_get
 983 DECLARE(GLint, glGetUniformLocation, GLuint program, const char *name)
 984 {
 985         TYPEDEF(GLint (*methodType)(GLuint, const char *));
 986         BEFORE(glGetUniformLocation);
 987         GLint ret = CALL_ORIG(glGetUniformLocation, program, name);
 988         GL_GET_ERROR();
 989         AFTER('d', ret, APITYPE_CONTEXT, "", "d", program);
 990
 991         return ret;
 992 }
 993
 994 //lsh_get
 995 DECLARE(void, glGetVertexAttribfv, GLuint index, GLenum pname, GLfloat *params)
 996 {
 997         TYPEDEF(void (*methodType)(GLuint, GLenum, GLfloat *));
 998         BEFORE(glGetVertexAttribfv);
 999         CALL_ORIG(glGetVertexAttribfv, index, pname, params);
1000         GL_GET_ERROR();
1001         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
1002               index, (uint64_t)(pname));
1003 }
1004
1005 //lsh_get
1006 DECLARE(void, glGetVertexAttribiv, GLuint index, GLenum pname, GLint *params)
1007 {
1008         TYPEDEF(void (*methodType)(GLuint, GLenum, GLint *));
1009         BEFORE(glGetVertexAttribiv);
1010         CALL_ORIG(glGetVertexAttribiv, index, pname, params);
1011         GL_GET_ERROR();
1012         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
1013               index, (uint64_t)(pname));
1014 }
1015
1016 //lsh_get
1017 DECLARE(void, glGetVertexAttribPointerv, GLuint index, GLenum pname, GLvoid **pointer)
1018 {
1019         TYPEDEF(void (*methodType)(GLuint, GLenum, GLvoid **));
1020         BEFORE(glGetVertexAttribPointerv);
1021         CALL_ORIG(glGetVertexAttribPointerv, index, pname, pointer);
1022         GL_GET_ERROR();
1023         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
1024               index, (uint64_t)(pname));
1025 }
1026
1027 // ==================================================================
1028 // H 1
1029 // ==================================================================
1030
1031 DECLARE(void, glHint, GLenum target, GLenum mode)
1032 {
1033         TYPEDEF(void (*methodType)(GLenum, GLenum));
1034         BEFORE(glHint);
1035         CALL_ORIG(glHint, target, mode);
1036         GL_GET_ERROR();
1037         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
1038               (uint64_t)(target), (uint64_t)(mode));
1039 }
1040
1041 // ==================================================================
1042 // I 7
1043 // ==================================================================
1044
1045 DECLARE(GLboolean, glIsBuffer, GLuint buffer)
1046 {
1047         TYPEDEF(GLboolean (*methodType)(GLuint));
1048         BEFORE(glIsBuffer);
1049         GLboolean ret = CALL_ORIG(glIsBuffer, buffer);
1050         GL_GET_ERROR();
1051         AFTER('c', ret, APITYPE_CONTEXT, "", "d", buffer);
1052
1053         return ret;
1054 }
1055
1056 DECLARE(GLboolean, glIsEnabled, GLenum cap)
1057 {
1058         TYPEDEF(GLboolean (*methodType)(GLenum));
1059         BEFORE(glIsEnabled);
1060         GLboolean ret = CALL_ORIG(glIsEnabled, cap);
1061         GL_GET_ERROR();
1062         AFTER('c', ret, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
1063
1064         return ret;
1065 }
1066
1067 DECLARE(GLboolean, glIsFramebuffer, GLuint framebuffer)
1068 {
1069         TYPEDEF(GLboolean (*methodType)(GLuint));
1070         BEFORE(glIsFramebuffer);
1071         GLboolean ret = CALL_ORIG(glIsFramebuffer, framebuffer);
1072         GL_GET_ERROR();
1073         AFTER('c', ret, APITYPE_CONTEXT, "", "d", framebuffer);
1074
1075         return ret;
1076 }
1077
1078 DECLARE(GLboolean, glIsProgram, GLuint program)
1079 {
1080         TYPEDEF(GLboolean (*methodType)(GLuint));
1081         BEFORE(glIsProgram);
1082         GLboolean ret = CALL_ORIG(glIsProgram, program);
1083         GL_GET_ERROR();
1084         AFTER('c', ret, APITYPE_CONTEXT, "", "d", program);
1085
1086         return ret;
1087 }
1088
1089 DECLARE(GLboolean, glIsRenderbuffer, GLuint renderbuffer)
1090 {
1091         TYPEDEF(GLboolean (*methodType)(GLuint));
1092         BEFORE(glIsRenderbuffer);
1093         GLboolean ret = CALL_ORIG(glIsRenderbuffer, renderbuffer);
1094         GL_GET_ERROR();
1095         AFTER('c', ret, APITYPE_CONTEXT, "", "d", renderbuffer);
1096
1097         return ret;
1098 }
1099
1100 DECLARE(GLboolean, glIsShader, GLuint shader)
1101 {
1102         TYPEDEF(GLboolean (*methodType)(GLuint));
1103         BEFORE(glIsShader);
1104         GLboolean ret = CALL_ORIG(glIsShader, shader);
1105         GL_GET_ERROR();
1106         AFTER('c', ret, APITYPE_CONTEXT, "", "d", shader);
1107
1108         return ret;
1109 }
1110
1111 DECLARE(GLboolean, glIsTexture, GLuint texture)
1112 {
1113         TYPEDEF(GLboolean (*methodType)(GLuint));
1114         BEFORE(glIsTexture);
1115         GLboolean ret = CALL_ORIG(glIsTexture, texture);
1116         GL_GET_ERROR();
1117         AFTER('c', ret, APITYPE_CONTEXT, "", "d", texture);
1118
1119         return ret;
1120 }
1121
1122 // ==================================================================
1123 // L 2
1124 // ==================================================================
1125
1126 DECLARE(void, glLineWidth, GLfloat width)
1127 {
1128         TYPEDEF(void (*methodType)(GLfloat));
1129         BEFORE(glLineWidth);
1130         CALL_ORIG(glLineWidth, width);
1131         GL_GET_ERROR();
1132         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", width);
1133 }
1134
1135 /* TODO refactor snprintf check*/
1136 DECLARE(void, glLinkProgram, GLuint program)
1137 {
1138         TYPEDEF(void (*methodType)(GLuint));
1139         BEFORE(glLinkProgram);
1140         CALL_ORIG(glLinkProgram, program);
1141         GL_GET_ERROR();
1142         char buf[512] = "";
1143         if (error == GL_NO_ERROR) {
1144                 char *to = buf;
1145                 int i, len;
1146                 size_t avail;
1147                 GLint activeNum[1];
1148                 GLint maxLength[1];
1149                 GLsizei length[1];
1150                 GLint size[1];
1151                 GLenum type[1];
1152
1153                 avail = sizeof(buf);
1154
1155                 real_glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, activeNum);
1156                 real_glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
1157                                     maxLength);
1158
1159                 char name1[maxLength[0]];
1160                 len = snprintf(to, avail, "%d", activeNum[0]);
1161                 to += len;
1162                 avail -= len;
1163                 for (i = 0; i < activeNum[0]; i++) {
1164                         real_glGetActiveAttrib(program, i, maxLength[0], length,
1165                                                size, type, name1);
1166                         len = snprintf(to, avail, ",%d,%s,%d,%x", i, name1, size[0],
1167                                        type[0]);
1168
1169                         if (avail <= (unsigned int)len) {
1170                                 PRINTERR("fatal. too small buf");
1171                                 break;
1172                         }
1173
1174                         to += len;
1175                         avail -= len;
1176                 }
1177
1178                 real_glGetProgramiv(program, GL_ACTIVE_UNIFORMS, activeNum);
1179                 real_glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH,
1180                                     maxLength);
1181
1182                 char name2[maxLength[0]];
1183                 len = snprintf(to, avail, ",%d", activeNum[0]);
1184
1185                 if (avail <= (unsigned int)len) {
1186                         PRINTERR("fatal. too small buf");
1187                 } else {
1188                         to += len;
1189                         avail -= len;
1190                 }
1191
1192                 for (i = 0; i < activeNum[0]; i++) {
1193                         real_glGetActiveUniform(program, i, maxLength[0],
1194                                                 length, size, type, name2);
1195                         len = snprintf(to, avail, ",%d,%s,%d,%x", i, name2,
1196                                        size[0], type[0]);
1197
1198                         if (avail <= (unsigned int)len) {
1199                                 PRINTERR("fatal. too small buf");
1200                                 break;
1201                         }
1202
1203                         to += len;
1204                         avail -= len;
1205
1206                 }
1207         }
1208         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "d",
1209               program);
1210 }
1211
1212 // ==================================================================
1213 // P 2
1214 // ==================================================================
1215
1216 DECLARE(void, glPixelStorei, GLenum pname, GLint param)
1217 {
1218         TYPEDEF(void (*methodType)(GLenum, GLint));
1219         BEFORE(glPixelStorei);
1220         CALL_ORIG(glPixelStorei, pname, param);
1221         GL_GET_ERROR();
1222         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
1223               (uint64_t)(pname), param);
1224 }
1225
1226 DECLARE(void, glPolygonOffset, GLfloat factor, GLfloat units)
1227 {
1228         TYPEDEF(void (*methodType)(GLfloat, GLfloat));
1229         BEFORE(glPolygonOffset);
1230         CALL_ORIG(glPolygonOffset, factor, units);
1231         GL_GET_ERROR();
1232         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
1233               factor, units);
1234 }
1235
1236 // ==================================================================
1237 // R 3
1238 // ==================================================================
1239
1240 //lsh_get
1241 DECLARE(void, glReadPixels, GLint x, GLint y, GLsizei width, GLsizei height,
1242                   GLenum format, GLenum type, GLvoid * data)
1243 {
1244         TYPEDEF(void (*methodType)(GLint, GLint, GLsizei, GLsizei, GLenum,
1245                                    GLenum, GLvoid *));
1246         BEFORE(glReadPixels);
1247         CALL_ORIG(glReadPixels, x, y, width, height, format, type, data);
1248         GL_GET_ERROR();
1249         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1250               "ddddxx", x, y, width, height,
1251               (uint64_t)(format), (uint64_t)(type));
1252 }
1253
1254 DECLARE_NOARGS(void, glReleaseShaderCompiler)
1255 {
1256         TYPEDEF(void (*methodType)(void));
1257         BEFORE(glReleaseShaderCompiler);
1258         CALL_ORIG(glReleaseShaderCompiler,);
1259         GL_GET_ERROR();
1260         AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
1261 }
1262 DECLARE(void, glRenderbufferStorage, GLenum target, GLenum internalformat, GLsizei width,
1263                            GLsizei height)
1264 {
1265         TYPEDEF(void (*methodType)(GLenum, GLenum, GLsizei, GLsizei));
1266         BEFORE(glRenderbufferStorage);
1267         CALL_ORIG(glRenderbufferStorage, target, internalformat, width, height);
1268         GL_GET_ERROR();
1269         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
1270               (uint64_t)(target), (uint64_t)(internalformat), width, height);
1271 }
1272
1273 // ==================================================================
1274 // S 10
1275 // ==================================================================
1276
1277 DECLARE(void, glSampleCoverage, GLclampf value, GLboolean invert)
1278 {
1279         TYPEDEF(void (*methodType)(GLclampf, GLboolean));
1280         BEFORE(glSampleCoverage);
1281         CALL_ORIG(glSampleCoverage, value, invert);
1282         GL_GET_ERROR();
1283         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "fx",
1284               value, (uint64_t)(invert));
1285 }
1286
1287 DECLARE(void, glScissor, GLint x, GLint y, GLsizei width, GLsizei height)
1288 {
1289         TYPEDEF(void (*methodType)(GLint, GLint, GLsizei, GLsizei));
1290         BEFORE(glScissor);
1291         CALL_ORIG(glScissor, x, y, width, height);
1292         GL_GET_ERROR();
1293         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
1294               x, y, width, height);
1295 }
1296
1297 //lsh_param
1298 DECLARE(void, glShaderBinary, GLsizei n, const GLuint *shaders, GLenum binaryformat,
1299                     const void *binary, GLsizei length)
1300 {
1301         TYPEDEF(void (*methodType)(GLsizei, const GLuint *, GLenum,
1302                                    const void *, GLsizei));
1303         BEFORE(glShaderBinary);
1304         CALL_ORIG(glShaderBinary, n, shaders, binaryformat, binary, length);
1305         GL_GET_ERROR();
1306         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1307               "dpxpd", n, voidp_to_uint64(shaders),
1308               (uint64_t)(binaryformat), voidp_to_uint64(binary), length);
1309 }
1310
1311 //lsh_param
1312 DECLARE(void, glShaderSource, GLuint shader, GLsizei count, const char **string,
1313                     const GLint *length)
1314 {
1315         TYPEDEF(void (*methodType)(GLuint, GLsizei, const char **,
1316                                    const GLint*));
1317         BEFORE(glShaderSource);
1318         CALL_ORIG(glShaderSource, shader, count, string, length);
1319         GL_GET_ERROR();
1320         if (error == GL_NO_ERROR) {
1321                 GLint length[1];
1322                 real_glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, length);
1323                 char buf[length[0]];
1324                 real_glGetShaderSource(shader, length[0], NULL, buf);
1325                 AFTER_SHADER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf,
1326                              length[0], "ddpp", shader, count,
1327                              voidp_to_uint64(string), voidp_to_uint64(length));
1328         } else {
1329                 AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1330                       "ddpp", shader, count,
1331                       voidp_to_uint64(string), voidp_to_uint64(length));
1332         }
1333 }
1334
1335 DECLARE(void, glStencilFunc, GLenum func, GLint ref, GLuint mask)
1336 {
1337         TYPEDEF(void (*methodType)(GLenum, GLint, GLint));
1338         BEFORE(glStencilFunc);
1339         CALL_ORIG(glStencilFunc, func, ref, mask);
1340         GL_GET_ERROR();
1341         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
1342               (uint64_t)(func), ref, mask);
1343 }
1344
1345 DECLARE(void, glStencilFuncSeparate, GLenum face, GLenum func, GLint ref, GLuint mask)
1346 {
1347         TYPEDEF(void (*methodType)(GLenum, GLenum, GLint, GLuint));
1348         BEFORE(glStencilFuncSeparate);
1349         CALL_ORIG(glStencilFuncSeparate, face, func, ref, mask);
1350         GL_GET_ERROR();
1351         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
1352               (uint64_t)(face), (uint64_t)(func), ref, mask);
1353 }
1354
1355 DECLARE(void, glStencilMask, GLuint mask)
1356 {
1357         TYPEDEF(void (*methodType)(GLuint));
1358         BEFORE(glStencilMask);
1359         CALL_ORIG(glStencilMask, mask);
1360         GL_GET_ERROR();
1361         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", mask);
1362 }
1363
1364 DECLARE(void, glStencilMaskSeparate, GLenum face, GLuint mask)
1365 {
1366         TYPEDEF(void (*methodType)(GLenum, GLuint));
1367         BEFORE(glStencilMaskSeparate);
1368         CALL_ORIG(glStencilMaskSeparate, face, mask);
1369         GL_GET_ERROR();
1370         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
1371               (uint64_t)(face), mask);
1372 }
1373
1374 DECLARE(void, glStencilOp, GLenum sfail, GLenum dpfail, GLenum dppass)
1375 {
1376         TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum));
1377         BEFORE(glStencilOp);
1378         CALL_ORIG(glStencilOp, sfail, dpfail, dppass);
1379         GL_GET_ERROR();
1380         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
1381               (uint64_t)(sfail), (uint64_t)(dpfail),
1382               (uint64_t)(dppass));
1383 }
1384
1385 DECLARE(void, glStencilOpSeparate, GLenum face, GLenum sfail, GLenum dpfail,
1386                          GLenum dppass)
1387 {
1388         TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLenum));
1389         BEFORE(glStencilOpSeparate);
1390         CALL_ORIG(glStencilOpSeparate, face, sfail, dpfail, dppass);
1391         GL_GET_ERROR();
1392         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
1393               (uint64_t)(face), (uint64_t)(sfail), (uint64_t)(dpfail),
1394               (uint64_t)(dppass));
1395 }
1396
1397 // ==================================================================
1398 // T 6
1399 // ==================================================================
1400
1401 DECLARE(void, glTexImage2D, GLenum target, GLint level, GLenum internalformat,
1402                   GLsizei width, GLsizei height, GLint border, GLenum format,
1403                   GLenum type, const GLvoid *data)
1404 {
1405         TYPEDEF(void (*methodType)(GLenum, GLint, GLint, GLsizei, GLsizei,
1406                                    GLint, GLenum, GLenum, const GLvoid *));
1407         BEFORE(glTexImage2D);
1408         CALL_ORIG(glTexImage2D, target, level, internalformat, width,
1409                   height, border, format, type, data);
1410         GL_GET_ERROR();
1411         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxxp",
1412               (uint64_t)(target), level, internalformat, width, height,
1413               border, (uint64_t)(format), (uint64_t)(type),
1414               voidp_to_uint64(data));
1415 }
1416
1417 DECLARE(void, glTexParameterf, GLenum target, GLenum pname, GLfloat param)
1418 {
1419         TYPEDEF(void (*methodType)(GLenum, GLenum, GLfloat));
1420         BEFORE(glTexParameterf);
1421         CALL_ORIG(glTexParameterf, target, pname, param);
1422         GL_GET_ERROR();
1423         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxf",
1424               (uint64_t)(target), (uint64_t)(pname), param);
1425 }
1426
1427 DECLARE(void, glTexParameterfv, GLenum target, GLenum pname, const GLfloat * params)
1428 {
1429         TYPEDEF(void (*methodType)(GLenum, GLenum, const GLfloat *));
1430         BEFORE(glTexParameterfv);
1431         CALL_ORIG(glTexParameterfv, target, pname, params);
1432         GL_GET_ERROR();
1433         if (error == GL_NO_ERROR) {
1434                 char param0[sizeof(GLenum) * 4];
1435                 snprintf(param0, sizeof(param0), "%x", (GLenum)params[0]);
1436                 AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
1437                       (uint64_t)(target), (uint64_t)(pname),
1438                       voidp_to_uint64(params));
1439         } else {
1440                 AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
1441                       (uint64_t)(target), (uint64_t)(pname),
1442                       voidp_to_uint64(params));
1443         }
1444 }
1445
1446 DECLARE(void, glTexParameteri, GLenum target, GLenum pname, GLint param)
1447 {
1448         TYPEDEF(void (*methodType)(GLenum, GLenum, GLint));
1449         BEFORE(glTexParameteri);
1450         CALL_ORIG(glTexParameteri, target, pname, param);
1451         GL_GET_ERROR();
1452         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
1453               (uint64_t)(target), (uint64_t)(pname),
1454               (uint64_t)(param));
1455 }
1456
1457 DECLARE(void, glTexParameteriv, GLenum target, GLenum pname, const GLint * params)
1458 {
1459         TYPEDEF(void (*methodType)(GLenum, GLenum, const GLint *));
1460         BEFORE(glTexParameteriv);
1461         CALL_ORIG(glTexParameteriv, target, pname, params);
1462         GL_GET_ERROR();
1463         if (error == GL_NO_ERROR) {
1464                 char param0[sizeof(GLenum) * 4];
1465                 snprintf(param0, sizeof(param0), "%x", (GLenum)params[0]);
1466                 AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
1467                       (uint64_t)(target), (uint64_t)(pname),
1468                       voidp_to_uint64(params));
1469         } else {
1470                 AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
1471                       (uint64_t)(target),
1472                       (uint64_t)(pname),
1473                       voidp_to_uint64(params));
1474         }
1475 }
1476
1477 DECLARE(void, glTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset,
1478                      GLsizei width, GLsizei height, GLenum format, GLenum type,
1479                      const GLvoid * data)
1480 {
1481         TYPEDEF(void (*methodType)(GLenum, GLint, GLint, GLint, GLsizei,
1482                                    GLsizei, GLenum, GLenum, const GLvoid *));
1483         BEFORE(glTexSubImage2D);
1484         CALL_ORIG(glTexSubImage2D, target, level, xoffset, yoffset, width,
1485                   height, format, type, data);
1486         GL_GET_ERROR();
1487         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1488               "xdddddxxp",
1489               (uint64_t)(target), level, xoffset, yoffset, width, height,
1490               (uint64_t)(format), (uint64_t)(type), voidp_to_uint64(data));
1491 }
1492
1493 // ==================================================================
1494 // U 20
1495 // ==================================================================
1496
1497 DECLARE(void, glUniform1f, GLint location, GLfloat v0)
1498 {
1499         TYPEDEF(void (*methodType)(GLint, GLfloat));
1500         BEFORE(glUniform1f);
1501         CALL_ORIG(glUniform1f, location, v0);
1502         GL_GET_ERROR();
1503         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "df",
1504               location, v0);
1505 }
1506
1507 DECLARE(void, glUniform2f, GLint location, GLfloat v0, GLfloat v1)
1508 {
1509         TYPEDEF(void (*methodType)(GLint, GLfloat, GLfloat));
1510         BEFORE(glUniform2f);
1511         CALL_ORIG(glUniform2f, location, v0, v1);
1512         GL_GET_ERROR();
1513         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dff",
1514               location, v0, v1);
1515 }
1516
1517 DECLARE(void, glUniform3f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
1518 {
1519         TYPEDEF(void (*methodType)(GLint, GLfloat, GLfloat, GLfloat));
1520         BEFORE(glUniform3f);
1521         CALL_ORIG(glUniform3f, location, v0, v1, v2);
1522         GL_GET_ERROR();
1523         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dfff",
1524               location, v0, v1, v2);
1525 }
1526
1527 DECLARE(void, glUniform4f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
1528 {
1529         TYPEDEF(void (*methodType)(GLint, GLfloat, GLfloat, GLfloat, GLfloat));
1530         BEFORE(glUniform4f);
1531         CALL_ORIG(glUniform4f, location, v0, v1, v2, v3);
1532         GL_GET_ERROR();
1533         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dffff",
1534               location, v0, v1, v2, v3);
1535 }
1536
1537 DECLARE(void, glUniform1fv, GLint location, GLsizei count, const GLfloat *value)
1538 {
1539         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
1540         BEFORE(glUniform1fv);
1541         CALL_ORIG(glUniform1fv, location, count, value);
1542         GL_GET_ERROR();
1543         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddF",
1544               location, count, count * 1, voidp_to_uint64(value));
1545 }
1546
1547 DECLARE(void, glUniform2fv, GLint location, GLsizei count, const GLfloat *value)
1548 {
1549         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
1550         BEFORE(glUniform2fv);
1551         CALL_ORIG(glUniform2fv, location, count, value);
1552         GL_GET_ERROR();
1553         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddF",
1554               location, count, count * 2, voidp_to_uint64(value));
1555 }
1556
1557 DECLARE(void, glUniform3fv, GLint location, GLsizei count, const GLfloat *value)
1558 {
1559         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
1560         BEFORE(glUniform3fv);
1561         CALL_ORIG(glUniform3fv, location, count, value);
1562         GL_GET_ERROR();
1563         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddF",
1564               location, count, count * 3, voidp_to_uint64(value));
1565 }
1566
1567 DECLARE(void, glUniform4fv, GLint location, GLsizei count, const GLfloat *value)
1568 {
1569         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
1570         BEFORE(glUniform4fv);
1571         CALL_ORIG(glUniform4fv, location, count, value);
1572         GL_GET_ERROR();
1573         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddF",
1574               location, count, count * 4, voidp_to_uint64(value));
1575 }
1576
1577 DECLARE(void, glUniform1i, GLint location, GLint v0)
1578 {
1579         TYPEDEF(void (*methodType)(GLint, GLint));
1580         BEFORE(glUniform1i);
1581         CALL_ORIG(glUniform1i, location, v0);
1582         GL_GET_ERROR();
1583         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
1584               location, v0);
1585 }
1586
1587 DECLARE(void, glUniform2i, GLint location, GLint v0, GLint v1)
1588 {
1589         TYPEDEF(void (*methodType)(GLint, GLint, GLint));
1590         BEFORE(glUniform2i);
1591         CALL_ORIG(glUniform2i, location, v0, v1);
1592         GL_GET_ERROR();
1593         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
1594               location, v0, v1);
1595 }
1596
1597 DECLARE(void, glUniform3i, GLint location, GLint v0, GLint v1, GLint v2)
1598 {
1599         TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint));
1600         BEFORE(glUniform3i);
1601         CALL_ORIG(glUniform3i, location, v0, v1, v2);
1602         GL_GET_ERROR();
1603         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
1604               location, v0, v1, v2);
1605 }
1606
1607 DECLARE(void, glUniform4i, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
1608 {
1609         TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint, GLint));
1610         BEFORE(glUniform4i);
1611         CALL_ORIG(glUniform4i, location, v0, v1, v2, v3);
1612         GL_GET_ERROR();
1613         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddddd",
1614               location, v0, v1, v2, v3);
1615 }
1616
1617 DECLARE(void, glUniform1iv, GLint location, GLsizei count, const GLint *value)
1618 {
1619         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
1620         BEFORE(glUniform1iv);
1621         CALL_ORIG(glUniform1iv, location, count, value);
1622         GL_GET_ERROR();
1623         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddD",
1624               location, count, count * 1, voidp_to_uint64(value));
1625 }
1626
1627 DECLARE(void, glUniform2iv, GLint location, GLsizei count, const GLint *value)
1628 {
1629         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
1630         BEFORE(glUniform2iv);
1631         CALL_ORIG(glUniform2iv, location, count, value);
1632         GL_GET_ERROR();
1633         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddD",
1634               location, count, count * 2, voidp_to_uint64(value));
1635 }
1636
1637 DECLARE(void, glUniform3iv, GLint location, GLsizei count, const GLint *value)
1638 {
1639         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
1640         BEFORE(glUniform3iv);
1641         CALL_ORIG(glUniform3iv, location, count, value);
1642         GL_GET_ERROR();
1643         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddD",
1644               location, count, count * 3, voidp_to_uint64(value));
1645 }
1646
1647 DECLARE(void, glUniform4iv, GLint location, GLsizei count, const GLint *value)
1648 {
1649         TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
1650         BEFORE(glUniform4iv);
1651         CALL_ORIG(glUniform4iv, location, count, value);
1652         GL_GET_ERROR();
1653         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddD",
1654               location, count, count * 4, voidp_to_uint64(value));
1655 }
1656
1657 DECLARE(void, glUniformMatrix2fv, GLint location, GLsizei count, GLboolean transpose,
1658                         const GLfloat *value)
1659 {
1660         TYPEDEF(void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *));
1661         BEFORE(glUniformMatrix2fv);
1662         CALL_ORIG(glUniformMatrix2fv, location, count, transpose, value);
1663         GL_GET_ERROR();
1664         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxF",
1665               location, count, (uint64_t)(transpose), count * 2 * 2,
1666               voidp_to_uint64(value));
1667 }
1668
1669 DECLARE(void, glUniformMatrix3fv, GLint location, GLsizei count, GLboolean transpose,
1670                         const GLfloat *value)
1671 {
1672         TYPEDEF(void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *));
1673         BEFORE(glUniformMatrix3fv);
1674         CALL_ORIG(glUniformMatrix3fv, location, count, transpose, value);
1675         GL_GET_ERROR();
1676         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxF",
1677               location, count, (uint64_t)(transpose), count * 3 * 3,
1678               voidp_to_uint64(value));
1679 }
1680
1681 DECLARE(void, glUniformMatrix4fv, GLint location, GLsizei count, GLboolean transpose,
1682                         const GLfloat *value)
1683 {
1684         TYPEDEF(void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *));
1685         BEFORE(glUniformMatrix4fv);
1686         CALL_ORIG(glUniformMatrix4fv, location, count, transpose, value);
1687         GL_GET_ERROR();
1688         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxF",
1689               location, count, (uint64_t)(transpose), count * 4 * 4,
1690               voidp_to_uint64(value));
1691 }
1692
1693 DECLARE(void, glUseProgram, GLuint program)
1694 {
1695         TYPEDEF(void (*methodType)(GLuint));
1696         BEFORE(glUseProgram);
1697         CALL_ORIG(glUseProgram, program);
1698         GL_GET_ERROR();
1699         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
1700               program);
1701 }
1702
1703 // ==================================================================
1704 // V 7
1705 // ==================================================================
1706
1707 DECLARE(void, glValidateProgram, GLuint program)
1708 {
1709         TYPEDEF(void (*methodType)(GLuint));
1710         BEFORE(glValidateProgram);
1711         CALL_ORIG(glValidateProgram, program);
1712         GL_GET_ERROR();
1713         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
1714               program);
1715 }
1716
1717 DECLARE(void, glVertexAttrib1f, GLuint index, GLfloat v0)
1718 {
1719         TYPEDEF(void (*methodType)(GLuint, GLfloat));
1720         BEFORE(glVertexAttrib1f);
1721         CALL_ORIG(glVertexAttrib1f, index, v0);
1722
1723         GLfloat cv[4];
1724         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1725         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1726                  cv[0], cv[1], cv[2], cv[3]);
1727
1728         GL_GET_ERROR();
1729         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue, "df",
1730               index, v0);
1731 }
1732
1733 DECLARE(void, glVertexAttrib2f, GLuint index, GLfloat v0, GLfloat v1)
1734 {
1735         TYPEDEF(void (*methodType)(GLuint, GLfloat, GLfloat));
1736         BEFORE(glVertexAttrib2f);
1737         CALL_ORIG(glVertexAttrib2f, index, v0, v1);
1738
1739         GLfloat cv[4];
1740         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1741         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1742                  cv[0], cv[1], cv[2], cv[3]);
1743
1744         GL_GET_ERROR();
1745         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue, "dff",
1746               index, v0, v1);
1747 }
1748
1749 DECLARE(void, glVertexAttrib3f, GLuint index, GLfloat v0, GLfloat v1, GLfloat v2)
1750 {
1751         TYPEDEF(void (*methodType)(GLuint, GLfloat, GLfloat, GLfloat));
1752         BEFORE(glVertexAttrib3f);
1753         CALL_ORIG(glVertexAttrib3f, index, v0, v1, v2);
1754
1755         GLfloat cv[4];
1756         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1757         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1758                  cv[0], cv[1], cv[2], cv[3]);
1759
1760         GL_GET_ERROR();
1761         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue, "dfff",
1762               index, v0, v1, v2);
1763 }
1764
1765 DECLARE(void, glVertexAttrib4f, GLuint index, GLfloat v0, GLfloat v1, GLfloat v2,
1766                       GLfloat v3)
1767 {
1768         TYPEDEF(void (*methodType)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat));
1769         BEFORE(glVertexAttrib4f);
1770         CALL_ORIG(glVertexAttrib4f, index, v0, v1, v2, v3);
1771
1772         GLfloat cv[4];
1773         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1774         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1775                  cv[0], cv[1], cv[2], cv[3]);
1776
1777         GL_GET_ERROR();
1778         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue, "dffff",
1779               index, v0, v1, v2, v3);
1780 }
1781
1782 DECLARE(void, glVertexAttrib1fv, GLuint index, const GLfloat *v)
1783 {
1784         TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
1785         BEFORE(glVertexAttrib1fv);
1786         CALL_ORIG(glVertexAttrib1fv, index, v);
1787
1788         GLfloat cv[4];
1789         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1790         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1791                  cv[0], cv[1], cv[2], cv[3]);
1792
1793         GL_GET_ERROR();
1794         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1795               "dp", index, voidp_to_uint64(v));
1796 }
1797
1798 DECLARE(void, glVertexAttrib2fv, GLuint index, const GLfloat *v)
1799 {
1800         TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
1801         BEFORE(glVertexAttrib2fv);
1802         CALL_ORIG(glVertexAttrib2fv, index, v);
1803
1804         GLfloat cv[4];
1805         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1806         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1807                  cv[0], cv[1], cv[2], cv[3]);
1808
1809         GL_GET_ERROR();
1810         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1811               "dp", index, voidp_to_uint64(v));
1812 }
1813
1814 DECLARE(void, glVertexAttrib3fv, GLuint index, const GLfloat *v)
1815 {
1816         TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
1817         BEFORE(glVertexAttrib3fv);
1818         CALL_ORIG(glVertexAttrib3fv, index, v);
1819
1820         GLfloat cv[4];
1821         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1822         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1823                  cv[0], cv[1], cv[2], cv[3]);
1824
1825         GL_GET_ERROR();
1826         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1827               "dp", index, voidp_to_uint64(v));
1828 }
1829
1830 DECLARE(void, glVertexAttrib4fv, GLuint index, const GLfloat *v)
1831 {
1832         TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
1833         BEFORE(glVertexAttrib4fv);
1834         CALL_ORIG(glVertexAttrib4fv, index, v);
1835         GLfloat cv[4];
1836         real_glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1837         snprintf(contextValue, sizeof(contextValue), "%f,%f,%f,%f",
1838                  cv[0], cv[1], cv[2], cv[3]);
1839
1840         GL_GET_ERROR();
1841         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1842               "dp", index, voidp_to_uint64(v));
1843 }
1844
1845 DECLARE(void, glVertexAttribPointer, GLuint index, GLint size, GLenum type,
1846                            GLboolean normalized, GLsizei stride,
1847                            const GLvoid *pointer)
1848 {
1849         TYPEDEF(void (*methodType)(GLuint, GLint, GLenum, GLboolean, GLsizei,
1850                                    const GLvoid *));
1851         BEFORE(glVertexAttribPointer);
1852         CALL_ORIG(glVertexAttribPointer, index, size, type, normalized, stride,
1853                   pointer);
1854         GL_GET_ERROR();
1855         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxxdp",
1856               index, size, (uint64_t)(type), (uint64_t)(normalized),
1857               stride, voidp_to_uint64(pointer));
1858 }
1859
1860 DECLARE(void, glViewport, GLint x, GLint y, GLsizei width, GLsizei height)
1861 {
1862         TYPEDEF(void (*methodType)(GLint, GLint, GLsizei, GLsizei));
1863
1864         BEFORE(glViewport);
1865
1866         CALL_ORIG(glViewport, x, y, width, height);
1867         GL_GET_ERROR();
1868         AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
1869               x, y, width, height);
1870 }
1871
1872 #undef CALL_ORIG
1873 #undef BEFORE