probe_graphics/da_gles20.cpp

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2011 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  *
  29  */
  30 #include "da_gles20.h"
  31 #include "binproto.h"
  32
  33 static enum DaOptions _sopt = OPT_GLES;
  34
  35 // ==================================================================
  36 // A 2
  37 // ==================================================================
  38
  39 void glActiveTexture(GLenum texture) {
  40         typedef void (*methodType)(GLenum);
  41         BEFORE(glActiveTexture);
  42         glActiveTexturep(texture);
  43         error = glGetError();
  44         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
  45               (uint64_t)(texture));
  46 }
  47
  48 void glAttachShader(GLuint program, GLuint shader) {
  49         typedef void (*methodType)(GLuint, GLuint);
  50         BEFORE(glAttachShader);
  51         glAttachShaderp(program, shader);
  52         error = glGetError();
  53         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
  54                         program, shader);
  55 }
  56
  57 // ==================================================================
  58 // B 12
  59 // ==================================================================
  60
  61 void glBindAttribLocation(GLuint program, GLuint index, const char *name) {
  62         typedef void (*methodType)(GLuint, GLuint, const char *);
  63         BEFORE(glBindAttribLocation);
  64         glBindAttribLocationp(program, index, name);
  65         error = glGetError();
  66         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dds",
  67                         program, index, name);
  68 }
  69
  70 void glBindBuffer(GLenum target, GLuint buffer) {
  71         typedef void (*methodType)(GLenum, GLuint);
  72         BEFORE(glBindBuffer);
  73         glBindBufferp(target, buffer);
  74         error = glGetError();
  75         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
  76               (uint64_t)(target), buffer);
  77 }
  78
  79 void glBindFramebuffer(GLenum target, GLuint framebuffer) {
  80         typedef void (*methodType)(GLenum, GLuint);
  81         BEFORE(glBindFramebuffer);
  82         glBindFramebufferp(target, framebuffer);
  83         error = glGetError();
  84         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
  85               (uint64_t)(target), framebuffer);
  86 }
  87
  88 void glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
  89         typedef void (*methodType)(GLenum, GLuint);
  90         BEFORE(glBindRenderbuffer);
  91         glBindRenderbufferp(target, renderbuffer);
  92         error = glGetError();
  93         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
  94               (uint64_t)(target), renderbuffer);
  95 }
  96
  97 void glBindTexture(GLenum target, GLuint texture) {
  98         typedef void (*methodType)(GLenum, GLuint);
  99         BEFORE(glBindTexture);
 100         glBindTexturep(target, texture);
 101         error = glGetError();
 102         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
 103               (uint64_t)(target), texture);
 104 }
 105
 106 void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
 107         typedef void (*methodType)(GLclampf, GLclampf, GLclampf, GLclampf);
 108         BEFORE(glBlendColor);
 109         glBlendColorp(red, green, blue, alpha);
 110         error = glGetError();
 111         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
 112                         red, green, blue, alpha);
 113 }
 114
 115 void glBlendEquation(GLenum mode) {
 116         typedef void (*methodType)(GLenum);
 117         BEFORE(glBlendEquation);
 118         glBlendEquationp(mode);
 119         error = glGetError();
 120         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 121               (uint64_t)(mode));
 122 }
 123
 124 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
 125         typedef void (*methodType)(GLenum, GLenum);
 126         BEFORE(glBlendEquationSeparate);
 127         glBlendEquationSeparatep(modeRGB, modeAlpha);
 128         error = glGetError();
 129         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 130               (uint64_t)(modeRGB), (uint64_t)(modeAlpha));
 131 }
 132
 133 void glBlendFunc(GLenum sfactor, GLenum dfactor) {
 134         typedef void (*methodType)(GLenum, GLenum);
 135         BEFORE(glBlendFunc);
 136         glBlendFuncp(sfactor, dfactor);
 137         error = glGetError();
 138         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 139               (uint64_t)(sfactor), (uint64_t)(dfactor));
 140 }
 141
 142 void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
 143                 GLenum dstAlpha) {
 144         typedef void (*methodType)(GLenum, GLenum, GLenum, GLenum);
 145         BEFORE(glBlendFuncSeparate);
 146         glBlendFuncSeparatep(srcRGB, dstRGB, srcAlpha, dstAlpha);
 147         error = glGetError();
 148         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
 149               (uint64_t)(srcRGB), (uint64_t)(dstRGB),
 150               (uint64_t)(srcAlpha), (uint64_t)(dstAlpha));
 151 }
 152
 153 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data,
 154                 GLenum usage) {
 155         typedef void (*methodType)(GLenum, GLsizeiptr, const GLvoid *, GLenum);
 156         BEFORE(glBufferData);
 157         glBufferDatap(target, size, data, usage);
 158         error = glGetError();
 159         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxpx",
 160               (uint64_t)(target), (uint64_t)(size),
 161               voidp_to_uint64(data), (uint64_t)(usage));
 162 }
 163
 164 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
 165                 const GLvoid * data) {
 166         typedef void (*methodType)(GLenum, GLintptr, GLsizeiptr, const GLvoid *);
 167         BEFORE(glBufferSubData);
 168         glBufferSubDatap(target, offset, size, data);
 169         error = glGetError();
 170         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxp",
 171               (uint64_t)(target), (uint64_t)(offset),
 172               (uint64_t)(size), voidp_to_uint64(data));
 173 }
 174
 175 // ==================================================================
 176 // C 14
 177 // ==================================================================
 178
 179 GLenum glCheckFramebufferStatus(GLenum target) {
 180         typedef GLenum (*methodType)(GLenum);
 181         BEFORE(glCheckFramebufferStatus);
 182         GLenum ret = glCheckFramebufferStatusp(target);
 183         error = glGetError();
 184         AFTER(ret, APITYPE_CONTEXT, "", "x",
 185               (uint64_t)(target));
 186
 187         return ret;
 188 }
 189
 190 void glClear(GLbitfield mask) {
 191         typedef void (*methodType)(GLbitfield);
 192         BEFORE(glClear);
 193         glClearp(mask);
 194         error = glGetError();
 195         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 196               (uint64_t)(mask));
 197 }
 198
 199 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
 200         typedef void (*methodType)(GLclampf, GLclampf, GLclampf, GLclampf);
 201         BEFORE(glClearColor);
 202         glClearColorp(red, green, blue, alpha);
 203         error = glGetError();
 204         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
 205                         red, green, blue, alpha);
 206 }
 207
 208 void glClearDepthf(GLclampf depth) {
 209         typedef void (*methodType)(GLclampf);
 210         BEFORE(glClearDepthf);
 211         glClearDepthfp(depth);
 212         error = glGetError();
 213         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", depth);
 214 }
 215
 216 void glClearStencil(GLint s) {
 217         typedef void (*methodType)(GLint);
 218         BEFORE(glClearStencil);
 219         glClearStencilp(s);
 220         error = glGetError();
 221         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", s);
 222 }
 223
 224 void glColorMask(GLboolean red, GLboolean green, GLboolean blue,
 225                 GLboolean alpha) {
 226         typedef void (*methodType)(GLboolean, GLboolean, GLboolean, GLboolean);
 227         BEFORE(glColorMask);
 228         glColorMaskp(red, green, blue, alpha);
 229         error = glGetError();
 230         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
 231                         red, green, blue, alpha);
 232 }
 233
 234 void glCompileShader(GLuint shader) {
 235         typedef void (*methodType)(GLuint);
 236         BEFORE(glCompileShader);
 237         glCompileShaderp(shader);
 238         error = glGetError();
 239         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(shader));
 240 }
 241
 242 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
 243                 GLsizei width, GLsizei height, GLint border, GLsizei imageSize,
 244                 const GLvoid * data) {
 245         typedef void (*methodType)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint,
 246                         GLsizei, const GLvoid *);
 247         BEFORE(glCompressedTexImage2D);
 248         glCompressedTexImage2Dp(target, level, internalformat, width, height,
 249                         border, imageSize, data);
 250         error = glGetError();
 251         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddp",
 252               (uint64_t)(target), level,
 253               (uint64_t)(internalformat), width, height, border, imageSize,
 254               voidp_to_uint64(data));
 255 }
 256
 257 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 258                 GLint yoffset, GLsizei width, GLsizei height, GLenum format,
 259                 GLsizei imageSize, const GLvoid * data) {
 260         typedef void (*methodType)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei,
 261                         GLenum, GLsizei, const GLvoid *);
 262         BEFORE(glCompressedTexSubImage2D);
 263         glCompressedTexSubImage2Dp(target, level, xoffset, yoffset, width, height,
 264                         format, imageSize, data);
 265         error = glGetError();
 266         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxdp",
 267               (uint64_t)(target), level, xoffset, yoffset, width, height,
 268               (uint64_t)(format), imageSize, voidp_to_uint64(data));
 269 }
 270
 271 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
 272                 GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
 273         typedef void (*methodType)(GLenum, GLint, GLenum, GLint, GLint, GLsizei,
 274                         GLsizei, GLint);
 275         BEFORE(glCopyTexImage2D);
 276         glCopyTexImage2Dp(target, level, internalformat, x, y, width, height,
 277                         border);
 278         error = glGetError();
 279         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddd",
 280               (uint64_t)(target), level,
 281               (uint64_t)(internalformat), x, y, width, height, border);
 282 }
 283
 284 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 285                 GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
 286         typedef void (*methodType)(GLenum, GLint, GLint, GLint, GLint, GLint,
 287                         GLsizei, GLsizei);
 288         BEFORE(glCopyTexSubImage2D);
 289         glCopyTexSubImage2Dp(target, level, xoffset, yoffset, x, y, width, height);
 290         error = glGetError();
 291         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xddddddd",
 292               (uint64_t)(target), level, xoffset, yoffset, x, y, width,
 293               height);
 294 }
 295
 296 GLuint glCreateProgram(void) {
 297         typedef GLuint (*methodType)(void);
 298         BEFORE(glCreateProgram);
 299         GLuint ret = glCreateProgramp();
 300         error = glGetError();
 301         AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
 302
 303         return ret;
 304 }
 305
 306 GLuint glCreateShader(GLenum shaderType) {
 307         typedef GLuint (*methodType)(GLenum);
 308         BEFORE(glCreateShader);
 309         GLuint ret = glCreateShaderp(shaderType);
 310         error = glGetError();
 311         AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(shaderType));
 312
 313         return ret;
 314 }
 315
 316 void glCullFace(GLenum mode) {
 317         typedef void (*methodType)(GLenum);
 318         BEFORE(glCullFace);
 319         glCullFacep(mode);
 320         error = glGetError();
 321         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(mode));
 322 }
 323
 324 // ==================================================================
 325 // D 14
 326 // ==================================================================
 327
 328 void glDeleteBuffers(GLsizei n, const GLuint * buffers) {
 329         typedef void (*methodType)(GLsizei, const GLuint *);
 330         BEFORE(glDeleteBuffers);
 331         glDeleteBuffersp(n, buffers);
 332         error = glGetError();
 333         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 334               n, voidp_to_uint64(buffers));
 335 }
 336
 337 void glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers) {
 338         typedef void (*methodType)(GLsizei, const GLuint *);
 339         BEFORE(glDeleteFramebuffers);
 340         glDeleteFramebuffersp(n, framebuffers);
 341         error = glGetError();
 342         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 343               n, voidp_to_uint64(framebuffers));
 344 }
 345
 346 void glDeleteProgram(GLuint program) {
 347         typedef void (*methodType)(GLuint);
 348         BEFORE(glDeleteProgram);
 349         glDeleteProgramp(program);
 350         error = glGetError();
 351         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
 352                         program);
 353 }
 354
 355 void glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers) {
 356         typedef void (*methodType)(GLsizei, const GLuint *);
 357         BEFORE(glDeleteRenderbuffers);
 358         glDeleteRenderbuffersp(n, renderbuffers);
 359         error = glGetError();
 360         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 361               n, voidp_to_uint64(renderbuffers));
 362 }
 363
 364 void glDeleteShader(GLuint shader) {
 365         typedef void (*methodType)(GLuint);
 366         BEFORE(glDeleteShader);
 367         glDeleteShaderp(shader);
 368         error = glGetError();
 369         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", shader);
 370 }
 371
 372 void glDeleteTextures(GLsizei n, const GLuint * textures) {
 373         typedef void (*methodType)(GLsizei, const GLuint *);
 374         BEFORE(glDeleteTextures);
 375         glDeleteTexturesp(n, textures);
 376         error = glGetError();
 377         if (error == GL_NO_ERROR) {
 378                 char buf[128] = "";
 379                 int bufP = 0;
 380                 for (int i = 0; i < n; i++) {
 381                         bufP += sprintf(buf + bufP, "%u", textures[i]);
 382                         if (i != n - 1) {
 383                                 bufP += sprintf(buf + bufP, ",");
 384                         }
 385                 }
 386                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
 387                       n, voidp_to_uint64(textures));
 388         } else {
 389                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 390                       n, voidp_to_uint64(textures));
 391         }
 392 }
 393
 394 void glDepthFunc(GLenum func) {
 395         typedef void (*methodType)(GLenum);
 396         BEFORE(glDepthFunc);
 397         glDepthFuncp(func);
 398         error = glGetError();
 399         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(func));
 400 }
 401
 402 void glDepthMask(GLboolean flag) {
 403         typedef void (*methodType)(GLboolean);
 404         BEFORE(glDepthMask);
 405         glDepthMaskp(flag);
 406         error = glGetError();
 407         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(flag));
 408 }
 409
 410 void glDepthRangef(GLclampf nearVal, GLclampf farVal) {
 411         typedef void (*methodType)(GLclampf, GLclampf);
 412         BEFORE(glDepthRangef);
 413         glDepthRangefp(nearVal, farVal);
 414         error = glGetError();
 415         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
 416                         nearVal, farVal);
 417 }
 418
 419 void glDetachShader(GLuint program, GLuint shader) {
 420         typedef void (*methodType)(GLuint, GLuint);
 421         BEFORE(glDetachShader);
 422         glDetachShaderp(program, shader);
 423         error = glGetError();
 424         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 425                         program, shader);
 426 }
 427
 428 void glDisable(GLenum cap) {
 429         typedef void (*methodType)(GLenum);
 430         BEFORE(glDisable);
 431         glDisablep(cap);
 432         error = glGetError();
 433         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
 434 }
 435
 436 void glDisableVertexAttribArray(GLuint index) {
 437         typedef void (*methodType)(GLuint);
 438         BEFORE(glDisableVertexAttribArray);
 439         glDisableVertexAttribArrayp(index);
 440         error = glGetError();
 441         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
 442 }
 443
 444 void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
 445         typedef void (*methodType)(GLenum, GLint, GLsizei);
 446         BEFORE(glDrawArrays);
 447         glDrawArraysp(mode, first, count);
 448         error = glGetError();
 449         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
 450               (uint64_t)(mode), first, count);
 451 }
 452
 453 void glDrawElements(GLenum mode, GLsizei count, GLenum type,
 454                 const GLvoid * indices) {
 455         typedef void (*methodType)(GLenum, GLsizei, GLenum, const GLvoid *);
 456         BEFORE(glDrawElements);
 457         glDrawElementsp(mode, count, type, indices);
 458         error = glGetError();
 459         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxp",
 460               (uint64_t)(mode), count, (uint64_t)(type), indices);
 461 }
 462
 463 // ==================================================================
 464 // E 2
 465 // ==================================================================
 466
 467 void glEnable(GLenum cap) {
 468         typedef void (*methodType)(GLenum);
 469         BEFORE(glEnable);
 470         glEnablep(cap);
 471         error = glGetError();
 472         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
 473 }
 474
 475 void glEnableVertexAttribArray(GLuint index) {
 476         typedef void (*methodType)(GLuint);
 477         BEFORE(glEnableVertexAttribArray);
 478         glEnableVertexAttribArrayp(index);
 479         error = glGetError();
 480         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
 481 }
 482
 483 #undef eglSwapBuffers
 484 extern "C" EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
 485         typedef EGLBoolean (*methodType)(EGLDisplay, EGLSurface);
 486         BEFORE_EGL(eglSwapBuffers);
 487         EGLBoolean ret = eglSwapBuffersp(dpy, surface);
 488         error = eglGetError();
 489         AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
 490
 491         return ret;
 492 }
 493 #define eglSwapBuffers _SglSwapBuffers
 494
 495 EGLBoolean _SglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
 496         typedef EGLBoolean (*methodType)(EGLDisplay, EGLSurface);
 497         BEFORE_OSP_UIFW(_SglSwapBuffers);
 498         EGLBoolean ret = _SglSwapBuffersp(dpy, surface);
 499         error = eglGetError();
 500         AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
 501
 502         return ret;
 503 }
 504
 505 // ==================================================================
 506 // F 5
 507 // ==================================================================
 508
 509 void glFinish(void) {
 510         typedef void (*methodType)(void);
 511         BEFORE(glFinish);
 512         glFinishp();
 513         error = glGetError();
 514         AFTER_NO_PARAM(NO_RETURN_VALUE, APITYPE_CONTEXT, "");
 515 }
 516
 517 void glFlush(void) {
 518         typedef void (*methodType)(void);
 519         BEFORE(glFlush);
 520         glFlushp();
 521         error = glGetError();
 522         AFTER_NO_PARAM(NO_RETURN_VALUE, APITYPE_CONTEXT, "");
 523 }
 524
 525 void glFramebufferRenderbuffer(GLenum target, GLenum attachment,
 526                 GLenum renderbuffertarget, GLuint renderbuffer) {
 527         typedef void (*methodType)(GLenum, GLenum, GLenum, GLuint);
 528         BEFORE(glFramebufferRenderbuffer);
 529         glFramebufferRenderbufferp(target, attachment, renderbuffertarget,
 530                         renderbuffer);
 531         error = glGetError();
 532         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxd",
 533               (uint64_t)(target), (uint64_t)(attachment),
 534               (uint64_t)(renderbuffertarget), renderbuffer);
 535 }
 536
 537 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
 538                 GLuint texture, GLint level) {
 539         typedef void (*methodType)(GLenum, GLenum, GLenum, GLuint, GLint);
 540         BEFORE(glFramebufferTexture2D);
 541         glFramebufferTexture2Dp(target, attachment, textarget, texture, level);
 542         error = glGetError();
 543         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxdd",
 544               (uint64_t)(target), (uint64_t)(attachment),
 545               (uint64_t)(textarget), texture, level);
 546 }
 547
 548 void glFrontFace(GLenum mode) {
 549         typedef void (*methodType)(GLenum);
 550         BEFORE(glFrontFace);
 551         glFrontFacep(mode);
 552         error = glGetError();
 553         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
 554               (uint64_t)(mode));
 555 }
 556
 557 // ==================================================================
 558 // G 31
 559 // ==================================================================
 560
 561 void glGenBuffers(GLsizei n, GLuint * buffers) {
 562         typedef void (*methodType)(GLsizei, GLuint *);
 563         BEFORE(glGenBuffers);
 564         glGenBuffersp(n, buffers);
 565         error = glGetError();
 566         if (error == GL_NO_ERROR) {
 567                 char buf[128] = "";
 568                 int bufP = 0;
 569                 for (int i = 0; i < n; i++) {
 570                         bufP += sprintf(buf + bufP, "%u", buffers[i]);
 571                         if (i != n - 1) {
 572                                 bufP += sprintf(buf + bufP, ",");
 573                         }
 574                 }
 575                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
 576                       n, voidp_to_uint64(buffers));
 577         } else {
 578                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 579                       n, voidp_to_uint64(buffers));
 580         }
 581 }
 582
 583 void glGenFramebuffers(GLsizei n, GLuint * framebuffers) {
 584         typedef void (*methodType)(GLsizei, GLuint *);
 585         BEFORE(glGenFramebuffers);
 586         glGenFramebuffersp(n, framebuffers);
 587         error = glGetError();
 588         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 589               n, voidp_to_uint64(framebuffers));
 590 }
 591
 592 void glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) {
 593         typedef void (*methodType)(GLsizei, GLuint *);
 594         BEFORE(glGenRenderbuffers);
 595         glGenRenderbuffersp(n, renderbuffers);
 596         error = glGetError();
 597         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 598               n, voidp_to_uint64(renderbuffers));
 599 }
 600
 601 void glGenTextures(GLsizei n, GLuint * textures) {
 602         typedef void (*methodType)(GLsizei, GLuint *);
 603         BEFORE(glGenTextures);
 604         glGenTexturesp(n, textures);
 605         error = glGetError();
 606         if (error == GL_NO_ERROR) {
 607                 char buf[128] = "";
 608                 int bufP = 0;
 609                 for (int i = 0; i < n; i++) {
 610                         bufP += sprintf(buf + bufP, "%u", textures[i]);
 611                         if (i != n - 1) {
 612                                 bufP += sprintf(buf + bufP, ",");
 613                         }
 614                 }
 615                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
 616                       n, voidp_to_uint64(textures));
 617         } else {
 618                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
 619                       n, voidp_to_uint64(textures));
 620         }
 621 }
 622
 623 void glGenerateMipmap(GLenum target) {
 624         typedef void (*methodType)(GLenum);
 625         BEFORE(glGenerateMipmap);
 626         glGenerateMipmapp(target);
 627         error = glGetError();
 628         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(target));
 629 }
 630
 631 //lsh_get
 632 void glGetBooleanv(GLenum pname, GLboolean * params) {
 633         typedef void (*methodType)(GLenum, GLboolean *);
 634         BEFORE(glGetBooleanv);
 635         glGetBooleanvp(pname, params);
 636         error = glGetError();
 637         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
 638 }
 639
 640 //lsh_get
 641 void glGetFloatv(GLenum pname, GLfloat * params) {
 642         typedef void (*methodType)(GLenum, GLfloat *);
 643         BEFORE(glGetFloatv);
 644         glGetFloatvp(pname, params);
 645         error = glGetError();
 646         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
 647 }
 648
 649 //lsh_get
 650 void glGetIntegerv(GLenum pname, GLint * params) {
 651         typedef void (*methodType)(GLenum, GLint *);
 652         BEFORE(glGetIntegerv);
 653         glGetIntegervp(pname, params);
 654         error = glGetError();
 655         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
 656 }
 657
 658 //lsh_get
 659 void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize,
 660                 GLsizei *length, GLint *size, GLenum *type, char *name) {
 661         typedef void (*methodType)(GLuint, GLuint, GLsizei, GLsizei *, GLint *,
 662                         GLenum *, char *);
 663         BEFORE(glGetActiveAttrib);
 664         glGetActiveAttribp(program, index, bufSize, length, size, type, name);
 665         error = glGetError();
 666         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
 667                         program, index, bufSize);
 668 }
 669
 670 //lsh_get
 671 void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize,
 672                 GLsizei *length, GLint *size, GLenum *type, char *name) {
 673         typedef void (*methodType)(GLuint, GLuint, GLsizei, GLsizei *, GLint *,
 674                         GLenum *, char *);
 675         BEFORE(glGetActiveUniform);
 676         glGetActiveUniformp(program, index, bufSize, length, size, type, name);
 677         error = glGetError();
 678         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
 679                         program, index, bufSize);
 680 }
 681
 682 //lsh_get
 683 void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count,
 684                 GLuint *shaders) {
 685         typedef void (*methodType)(GLuint, GLsizei, GLsizei *, GLuint *);
 686         BEFORE(glGetAttachedShaders);
 687         glGetAttachedShadersp(program, maxCount, count, shaders);
 688         error = glGetError();
 689         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 690                         program, maxCount);
 691 }
 692
 693 //lsh_get
 694 void glGetAttribLocation(GLenum pname, GLint * params) {
 695         typedef void (*methodType)(GLenum, GLint *);
 696         BEFORE(glGetAttribLocation);
 697         glGetAttribLocationp(pname, params);
 698         error = glGetError();
 699         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
 700 }
 701
 702 //lsh_get
 703 void glGetBufferParameteriv(GLenum target, GLenum value, GLint * data) {
 704         typedef void (*methodType)(GLenum, GLenum, GLint *);
 705         BEFORE(glGetBufferParameteriv);
 706         glGetBufferParameterivp(target, value, data);
 707         error = glGetError();
 708         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 709               (uint64_t)(target), (uint64_t)(value));
 710 }
 711
 712 GLenum glGetError(void) {
 713         typedef GLenum (*methodType)(void);
 714         BEFORE(glGetError);
 715         GLenum ret = glGetErrorp();
 716 //      error = glGetError();
 717         AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
 718
 719         return ret;
 720 }
 721
 722 //lsh_get
 723 void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
 724                 GLenum pname, GLint * params) {
 725         typedef void (*methodType)(GLenum, GLenum, GLenum, GLint *);
 726         BEFORE(glGetFramebufferAttachmentParameteriv);
 727         glGetFramebufferAttachmentParameterivp(target, attachment, pname, params);
 728         error = glGetError();
 729         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
 730               (uint64_t)(target), (uint64_t)(attachment),
 731               (uint64_t)(pname));
 732 }
 733
 734 //lsh_get
 735 void glGetProgramInfoLog(GLuint program, GLsizei maxLength, GLsizei *length,
 736                 char *infoLog) {
 737         typedef void (*methodType)(GLuint, GLsizei, GLsizei *, char *);
 738         BEFORE(glGetProgramInfoLog);
 739         glGetProgramInfoLogp(program, maxLength, length, infoLog);
 740         error = glGetError();
 741         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 742                         program, maxLength);
 743 }
 744
 745 //lsh_get
 746 void glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
 747         typedef void (*methodType)(GLuint, GLenum, GLint *);
 748         BEFORE(glGetProgramiv);
 749         glGetProgramivp(program, pname, params);
 750         error = glGetError();
 751         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 752               program, (uint64_t)(pname));
 753 }
 754
 755 //lsh_get
 756 void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {
 757         typedef void (*methodType)(GLenum, GLenum, GLint *);
 758         BEFORE(glGetRenderbufferParameteriv);
 759         glGetRenderbufferParameterivp(target, pname, params);
 760         error = glGetError();
 761         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 762               (uint64_t)(target), (uint64_t)(pname));
 763 }
 764
 765 //lsh_get
 766 void glGetShaderInfoLog(GLuint shader, GLsizei maxLength, GLsizei *length,
 767                 char *infoLog) {
 768         typedef void (*methodType)(GLuint, GLsizei, GLsizei *, char *);
 769         BEFORE(glGetShaderInfoLog);
 770         glGetShaderInfoLogp(shader, maxLength, length, infoLog);
 771         error = glGetError();
 772         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 773                         shader, maxLength);
 774 }
 775
 776 //lsh_get
 777 void glGetShaderPrecisionFormat(GLenum shaderType, GLenum precisionType,
 778                 GLint *range, GLint *precision) {
 779         typedef void (*methodType)(GLenum, GLenum, GLint *, GLint *);
 780         BEFORE(glGetShaderPrecisionFormat);
 781         glGetShaderPrecisionFormatp(shaderType, precisionType, range, precision);
 782         error = glGetError();
 783         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 784               (uint64_t)(shaderType), (uint64_t)(precisionType));
 785 }
 786
 787 //lsh_get
 788 void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length,
 789                 char *source) {
 790         typedef void (*methodType)(GLuint, GLsizei, GLsizei *, char *);
 791         BEFORE(glGetShaderSource);
 792         glGetShaderSourcep(shader, bufSize, length, source);
 793         error = glGetError();
 794         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 795                         shader, bufSize);
 796 }
 797
 798 //lsh_get
 799 void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
 800         typedef void (*methodType)(GLuint, GLenum, GLint *);
 801         BEFORE(glGetShaderiv);
 802         glGetShaderivp(shader, pname, params);
 803         error = glGetError();
 804         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 805               shader, (uint64_t)(pname));
 806 }
 807
 808 const GLubyte* glGetString(GLenum name) {
 809         typedef const GLubyte* (*methodType)(GLenum);
 810         BEFORE(glGetString);
 811         const GLubyte* ret = glGetStringp(name);
 812         error = glGetError();
 813         AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(name));
 814
 815         return ret;
 816 }
 817
 818 //lsh_get
 819 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params) {
 820         typedef void (*methodType)(GLenum, GLenum, GLfloat *);
 821         BEFORE(glGetTexParameterfv);
 822         glGetTexParameterfvp(target, pname, params);
 823         error = glGetError();
 824         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 825               (uint64_t)(target), (uint64_t)(pname));
 826 }
 827
 828 //lsh_get
 829 void glGetTexParameteriv(GLenum target, GLenum pname, GLint * params) {
 830         typedef void (*methodType)(GLenum, GLenum, GLint *);
 831         BEFORE(glGetTexParameteriv);
 832         glGetTexParameterivp(target, pname, params);
 833         error = glGetError();
 834         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 835               (uint64_t)(target), (uint64_t)(pname));
 836 }
 837
 838 //lsh_get
 839 void glGetUniformfv(GLuint program, GLint location, GLfloat *params) {
 840         typedef void (*methodType)(GLuint, GLuint, GLfloat *);
 841         BEFORE(glGetUniformfv);
 842         glGetUniformfvp(program, location, params);
 843         error = glGetError();
 844         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 845                         program, location);
 846 }
 847
 848 //lsh_get
 849 void glGetUniformiv(GLuint program, GLint location, GLint *params) {
 850         typedef void (*methodType)(GLuint, GLuint, GLint *);
 851         BEFORE(glGetUniformiv);
 852         glGetUniformivp(program, location, params);
 853         error = glGetError();
 854         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
 855                         program, location);
 856 }
 857
 858 //lsh_get
 859 GLint glGetUniformLocation(GLuint program, const char *name) {
 860         typedef GLint (*methodType)(GLuint, const char *);
 861         BEFORE(glGetUniformLocation);
 862         GLint ret = glGetUniformLocationp(program, name);
 863         error = glGetError();
 864         AFTER(ret, APITYPE_CONTEXT, "", "d", program);
 865
 866         return ret;
 867 }
 868
 869 //lsh_get
 870 void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {
 871         typedef void (*methodType)(GLuint, GLenum, GLfloat *);
 872         BEFORE(glGetVertexAttribfv);
 873         glGetVertexAttribfvp(index, pname, params);
 874         error = glGetError();
 875         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 876               index, (uint64_t)(pname));
 877 }
 878
 879 //lsh_get
 880 void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {
 881         typedef void (*methodType)(GLuint, GLenum, GLint *);
 882         BEFORE(glGetVertexAttribiv);
 883         glGetVertexAttribivp(index, pname, params);
 884         error = glGetError();
 885         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 886               index, (uint64_t)(pname));
 887 }
 888
 889 //lsh_get
 890 void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {
 891         typedef void (*methodType)(GLuint, GLenum, GLvoid **);
 892         BEFORE(glGetVertexAttribPointerv);
 893         glGetVertexAttribPointervp(index, pname, pointer);
 894         error = glGetError();
 895         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
 896               index, (uint64_t)(pname));
 897 }
 898
 899 // ==================================================================
 900 // H 1
 901 // ==================================================================
 902
 903 void glHint(GLenum target, GLenum mode) {
 904         typedef void (*methodType)(GLenum, GLenum);
 905         BEFORE(glHint);
 906         glHintp(target, mode);
 907         error = glGetError();
 908         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
 909               (uint64_t)(target), (uint64_t)(mode));
 910 }
 911
 912 // ==================================================================
 913 // I 7
 914 // ==================================================================
 915
 916 GLboolean glIsBuffer(GLuint buffer) {
 917         typedef GLboolean (*methodType)(GLuint);
 918         BEFORE(glIsBuffer);
 919         GLboolean ret = glIsBufferp(buffer);
 920         error = glGetError();
 921         AFTER(ret, APITYPE_CONTEXT, "", "d", buffer);
 922
 923         return ret;
 924 }
 925
 926 GLboolean glIsEnabled(GLenum cap) {
 927         typedef GLboolean (*methodType)(GLenum);
 928         BEFORE(glIsEnabled);
 929         GLboolean ret = glIsEnabledp(cap);
 930         error = glGetError();
 931         AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
 932
 933         return ret;
 934 }
 935
 936 GLboolean glIsFramebuffer(GLuint framebuffer) {
 937         typedef GLboolean (*methodType)(GLuint);
 938         BEFORE(glIsFramebuffer);
 939         GLboolean ret = glIsFramebufferp(framebuffer);
 940         error = glGetError();
 941         AFTER(ret, APITYPE_CONTEXT, "", "d", framebuffer);
 942
 943         return ret;
 944 }
 945
 946 GLboolean glIsProgram(GLuint program) {
 947         typedef GLboolean (*methodType)(GLuint);
 948         BEFORE(glIsProgram);
 949         GLboolean ret = glIsProgramp(program);
 950         error = glGetError();
 951         AFTER(ret, APITYPE_CONTEXT, "", "d", program);
 952
 953         return ret;
 954 }
 955
 956 GLboolean glIsRenderbuffer(GLuint renderbuffer) {
 957         typedef GLboolean (*methodType)(GLuint);
 958         BEFORE(glIsRenderbuffer);
 959         GLboolean ret = glIsRenderbufferp(renderbuffer);
 960         error = glGetError();
 961         AFTER(ret, APITYPE_CONTEXT, "", "d", renderbuffer);
 962
 963         return ret;
 964 }
 965
 966 GLboolean glIsShader(GLuint shader) {
 967         typedef GLboolean (*methodType)(GLuint);
 968         BEFORE(glIsShader);
 969         GLboolean ret = glIsShaderp(shader);
 970         error = glGetError();
 971         AFTER(ret, APITYPE_CONTEXT, "", "d", shader);
 972
 973         return ret;
 974 }
 975
 976 GLboolean glIsTexture(GLuint texture) {
 977         typedef GLboolean (*methodType)(GLuint);
 978         BEFORE(glIsTexture);
 979         GLboolean ret = glIsTexturep(texture);
 980         error = glGetError();
 981         AFTER(ret, APITYPE_CONTEXT, "", "d", texture);
 982
 983         return ret;
 984 }
 985
 986 // ==================================================================
 987 // L 2
 988 // ==================================================================
 989
 990 void glLineWidth(GLfloat width) {
 991         typedef void (*methodType)(GLfloat);
 992         BEFORE(glLineWidth);
 993         glLineWidthp(width);
 994         error = glGetError();
 995         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", width);
 996 }
 997
 998 void glLinkProgram(GLuint program) {
 999         typedef void (*methodType)(GLuint);
1000         BEFORE(glLinkProgram);
1001         glLinkProgramp(program);
1002         error = glGetError();
1003         char buf[512] = "";
1004         if (error == GL_NO_ERROR) {
1005                 int bufP = 0;
1006                 GLint activeNum[1];
1007                 GLint maxLength[1];
1008                 glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, activeNum);
1009                 glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, maxLength);
1010                 bufP += sprintf(buf + bufP, "%d", activeNum[0]);
1011                 for (int i = 0; i < activeNum[0]; i++) {
1012                         GLsizei length[1];
1013                         GLint size[1];
1014                         GLenum type[1];
1015                         char name[maxLength[0]];
1016                         glGetActiveAttrib(program, i, maxLength[0], length, size, type,
1017                                         name);
1018                         bufP += sprintf(buf + bufP, ",%d,%s,%d,%x", i, name, size[0],
1019                                         type[0]);
1020                 }
1021
1022                 glGetProgramiv(program, GL_ACTIVE_UNIFORMS, activeNum);
1023                 glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, maxLength);
1024                 bufP += sprintf(buf + bufP, ",%d", activeNum[0]);
1025                 for (int i = 0; i < activeNum[0]; i++) {
1026                         GLsizei length[1];
1027                         GLint size[1];
1028                         GLenum type[1];
1029                         char name[maxLength[0]];
1030                         glGetActiveUniform(program, i, maxLength[0], length, size, type,
1031                                         name);
1032                         bufP += sprintf(buf + bufP, ",%d,%s,%d,%x", i, name, size[0],
1033                                         type[0]);
1034                 }
1035         }
1036         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "d",
1037                         program);
1038 }
1039
1040 // ==================================================================
1041 // P 2
1042 // ==================================================================
1043
1044 void glPixelStorei(GLenum pname, GLint param) {
1045         typedef void (*methodType)(GLenum, GLint);
1046         BEFORE(glPixelStorei);
1047         glPixelStoreip(pname, param);
1048         error = glGetError();
1049         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
1050               (uint64_t)(pname), param);
1051 }
1052
1053 void glPolygonOffset(GLfloat factor, GLfloat units) {
1054         typedef void (*methodType)(GLfloat, GLfloat);
1055         BEFORE(glPolygonOffset);
1056         glPolygonOffsetp(factor, units);
1057         error = glGetError();
1058         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
1059                         factor, units);
1060 }
1061
1062 // ==================================================================
1063 // R 3
1064 // ==================================================================
1065
1066 //lsh_get
1067 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1068                 GLenum format, GLenum type, GLvoid * data) {
1069         typedef void (*methodType)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum,
1070                         GLvoid *);
1071         BEFORE(glReadPixels);
1072         glReadPixelsp(x, y, width, height, format, type, data);
1073         error = glGetError();
1074         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1075               "ddddxx", x, y, width, height,
1076               (uint64_t)(format), (uint64_t)(type));
1077 }
1078
1079 void glReleaseShaderCompiler(void) {
1080         typedef void (*methodType)(void);
1081         BEFORE(glReleaseShaderCompiler);
1082         glReleaseShaderCompilerp();
1083         error = glGetError();
1084         AFTER_NO_PARAM(NO_RETURN_VALUE, APITYPE_CONTEXT, "");
1085 }
1086
1087 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width,
1088                 GLsizei height) {
1089         typedef void (*methodType)(GLenum, GLenum, GLsizei, GLsizei);
1090         BEFORE(glRenderbufferStorage);
1091         glRenderbufferStoragep(target, internalformat, width, height);
1092         error = glGetError();
1093         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
1094               (uint64_t)(target), (uint64_t)(internalformat),
1095               width, height);
1096 }
1097
1098 // ==================================================================
1099 // S 10
1100 // ==================================================================
1101
1102 void glSampleCoverage(GLclampf value, GLboolean invert) {
1103         typedef void (*methodType)(GLclampf, GLboolean);
1104         BEFORE(glSampleCoverage);
1105         glSampleCoveragep(value, invert);
1106         error = glGetError();
1107         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "fx",
1108                         value, (uint64_t)(invert));
1109 }
1110
1111 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
1112         typedef void (*methodType)(GLint, GLint, GLsizei, GLsizei);
1113         BEFORE(glScissor);
1114         glScissorp(x, y, width, height);
1115         error = glGetError();
1116         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
1117                         x, y, width, height);
1118 }
1119
1120 //lsh_param
1121 void glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
1122                 const void *binary, GLsizei length) {
1123         typedef void (*methodType)(GLsizei, const GLuint *, GLenum, const void *,
1124                         GLsizei);
1125         BEFORE(glShaderBinary);
1126         glShaderBinaryp(n, shaders, binaryformat, binary, length);
1127         error = glGetError();
1128         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1129               "dpxpd", n, voidp_to_uint64(shaders),
1130               (uint64_t)(binaryformat), voidp_to_uint64(binary), length);
1131 }
1132
1133 //lsh_param
1134 void glShaderSource(GLuint shader, GLsizei count, const char** string,
1135                 const GLint* length) {
1136         typedef void (*methodType)(GLuint, GLsizei, const char**, const GLint*);
1137         BEFORE(glShaderSource);
1138         glShaderSourcep(shader, count, string, length);
1139         error = glGetError();
1140         if (error == GL_NO_ERROR) {
1141                 GLint length[1];
1142                 glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, length);
1143                 char buf[length[0]];
1144                 glGetShaderSource(shader, length[0], NULL, buf);
1145                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf,
1146                       "ddpp", shader, count,
1147                       voidp_to_uint64(string), voidp_to_uint64(length));
1148         } else {
1149                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1150                       "ddpp", shader, count,
1151                       voidp_to_uint64(string), voidp_to_uint64(length));
1152         }
1153 }
1154
1155 void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
1156         typedef void (*methodType)(GLenum, GLint, GLint);
1157         BEFORE(glStencilFunc);
1158         glStencilFuncp(func, ref, mask);
1159         error = glGetError();
1160         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
1161               (uint64_t)(func), ref, mask);
1162 }
1163
1164 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
1165         typedef void (*methodType)(GLenum, GLenum, GLint, GLuint);
1166         BEFORE(glStencilFuncSeparate);
1167         glStencilFuncSeparatep(face, func, ref, mask);
1168         error = glGetError();
1169         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
1170               (uint64_t)(face), (uint64_t)(func), ref, mask);
1171 }
1172
1173 void glStencilMask(GLuint mask) {
1174         typedef void (*methodType)(GLuint);
1175         BEFORE(glStencilMask);
1176         glStencilMaskp(mask);
1177         error = glGetError();
1178         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", mask);
1179 }
1180
1181 void glStencilMaskSeparate(GLenum face, GLuint mask) {
1182         typedef void (*methodType)(GLenum, GLuint);
1183         BEFORE(glStencilMaskSeparate);
1184         glStencilMaskSeparatep(face, mask);
1185         error = glGetError();
1186         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
1187               (uint64_t)(face), mask);
1188 }
1189
1190 void glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) {
1191         typedef void (*methodType)(GLenum, GLenum, GLenum);
1192         BEFORE(glStencilOp);
1193         glStencilOpp(sfail, dpfail, dppass);
1194         error = glGetError();
1195         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
1196               (uint64_t)(sfail), (uint64_t)(dpfail),
1197               (uint64_t)(dppass));
1198 }
1199
1200 void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail,
1201                 GLenum dppass) {
1202         typedef void (*methodType)(GLenum, GLenum, GLenum, GLenum);
1203         BEFORE(glStencilOpSeparate);
1204         glStencilOpSeparatep(face, sfail, dpfail, dppass);
1205         error = glGetError();
1206         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
1207               (uint64_t)(face), (uint64_t)(sfail), (uint64_t)(dpfail),
1208               (uint64_t)(dppass));
1209 }
1210
1211 // ==================================================================
1212 // T 6
1213 // ==================================================================
1214
1215 void glTexImage2D(GLenum target, GLint level, GLint internalformat,
1216                 GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
1217                 const GLvoid * data) {
1218         typedef void (*methodType)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint,
1219                         GLenum, GLenum, const GLvoid *);
1220         BEFORE(glTexImage2D);
1221         glTexImage2Dp(target, level, internalformat, width, height, border, format,
1222                         type, data);
1223         error = glGetError();
1224         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxxp",
1225               (uint64_t)(target), level, internalformat, width, height,
1226               border, (uint64_t)(format), (uint64_t)(type),
1227               voidp_to_uint64(data));
1228 }
1229
1230 void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
1231         typedef void (*methodType)(GLenum, GLenum, GLfloat);
1232         BEFORE(glTexParameterf);
1233         glTexParameterfp(target, pname, param);
1234         error = glGetError();
1235         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxf",
1236               (uint64_t)(target), (uint64_t)(pname), param);
1237 }
1238
1239 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params) {
1240         typedef void (*methodType)(GLenum, GLenum, const GLfloat *);
1241         BEFORE(glTexParameterfv);
1242         glTexParameterfvp(target, pname, params);
1243         error = glGetError();
1244         if(error == GL_NO_ERROR) {
1245                 char param0[8];
1246                 sprintf(param0, "%x", (GLenum)params[0]);
1247                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
1248                       (uint64_t)(target), (uint64_t)(pname),
1249                       voidp_to_uint64(params));
1250         } else {
1251                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
1252                       (uint64_t)(target), (uint64_t)(pname),
1253                       voidp_to_uint64(params));
1254         }
1255 }
1256
1257 void glTexParameteri(GLenum target, GLenum pname, GLint param) {
1258         typedef void (*methodType)(GLenum, GLenum, GLint);
1259         BEFORE(glTexParameteri);
1260         glTexParameterip(target, pname, param);
1261         error = glGetError();
1262         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
1263               (uint64_t)(target), (uint64_t)(pname),
1264               (uint64_t)(param));
1265 }
1266
1267 void glTexParameteriv(GLenum target, GLenum pname, const GLint * params) {
1268         typedef void (*methodType)(GLenum, GLenum, const GLint *);
1269         BEFORE(glTexParameteriv);
1270         glTexParameterivp(target, pname, params);
1271         error = glGetError();
1272         if(error == GL_NO_ERROR) {
1273                 char param0[8];
1274                 sprintf(param0, "%x", (GLenum)params[0]);
1275                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
1276                       (uint64_t)(target), (uint64_t)(pname),
1277                       voidp_to_uint64(params));
1278         } else {
1279                 AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
1280                       (uint64_t)(target),
1281                       (uint64_t)(pname),
1282                       voidp_to_uint64(params));
1283         }
1284 }
1285
1286 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
1287                 GLsizei width, GLsizei height, GLenum format, GLenum type,
1288                 const GLvoid * data) {
1289         typedef void (*methodType)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei,
1290                         GLenum, GLenum, const GLvoid *);
1291         BEFORE(glTexImage2D);
1292         glTexImage2Dp(target, level, xoffset, yoffset, width, height, format, type,
1293                         data);
1294         error = glGetError();
1295         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1296               "xdddddxxp",
1297               (uint64_t)(target), level, xoffset, yoffset, width, height,
1298               (uint64_t)(format), (uint64_t)(type), voidp_to_uint64(data));
1299 }
1300
1301 // ==================================================================
1302 // U 20
1303 // ==================================================================
1304
1305 void glUniform1f(GLint location, GLfloat v0) {
1306         typedef void (*methodType)(GLint, GLfloat);
1307         BEFORE(glUniform1f);
1308         glUniform1fp(location, v0);
1309         error = glGetError();
1310         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "df",
1311                         location, v0);
1312 }
1313
1314 void glUniform2f(GLint location, GLfloat v0, GLfloat v1) {
1315         typedef void (*methodType)(GLint, GLfloat, GLfloat);
1316         BEFORE(glUniform2f);
1317         glUniform2fp(location, v0, v1);
1318         error = glGetError();
1319         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dff",
1320                         location, v0, v1);
1321 }
1322
1323 void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
1324         typedef void (*methodType)(GLint, GLfloat, GLfloat, GLfloat);
1325         BEFORE(glUniform3f);
1326         glUniform3fp(location, v0, v1, v2);
1327         error = glGetError();
1328         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dfff",
1329                         location, v0, v1, v2);
1330 }
1331
1332 void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
1333                 GLfloat v3) {
1334         typedef void (*methodType)(GLint, GLfloat, GLfloat, GLfloat, GLfloat);
1335         BEFORE(glUniform4f);
1336         glUniform4fp(location, v0, v1, v2, v3);
1337         error = glGetError();
1338         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1339                         "dffff", location, v0, v1, v2, v3);
1340 }
1341
1342 void glUniform1fv(GLint location, GLsizei count, const GLfloat *value) {
1343         typedef void (*methodType)(GLint, GLsizei, const GLfloat *);
1344         BEFORE(glUniform1fv);
1345         glUniform1fvp(location, count, value);
1346         error = glGetError();
1347         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1348               location, count, voidp_to_uint64(value));
1349 }
1350
1351 void glUniform2fv(GLint location, GLsizei count, const GLfloat *value) {
1352         typedef void (*methodType)(GLint, GLsizei, const GLfloat *);
1353         BEFORE(glUniform2fv);
1354         glUniform2fvp(location, count, value);
1355         error = glGetError();
1356         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1357               location, count, voidp_to_uint64(value));
1358 }
1359
1360 void glUniform3fv(GLint location, GLsizei count, const GLfloat *value) {
1361         typedef void (*methodType)(GLint, GLsizei, const GLfloat *);
1362         BEFORE(glUniform3fv);
1363         glUniform3fvp(location, count, value);
1364         error = glGetError();
1365         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1366               location, count, voidp_to_uint64(value));
1367 }
1368
1369 void glUniform4fv(GLint location, GLsizei count, const GLfloat *value) {
1370         typedef void (*methodType)(GLint, GLsizei, const GLfloat *);
1371         BEFORE(glUniform4fv);
1372         glUniform4fvp(location, count, value);
1373         error = glGetError();
1374         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1375               location, count, voidp_to_uint64(value));
1376 }
1377
1378 void glUniform1i(GLint location, GLint v0) {
1379         typedef void (*methodType)(GLint, GLint);
1380         BEFORE(glUniform1i);
1381         glUniform1ip(location, v0);
1382         error = glGetError();
1383         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
1384                         location, v0);
1385 }
1386
1387 void glUniform2i(GLint location, GLint v0, GLint v1) {
1388         typedef void (*methodType)(GLint, GLint, GLint);
1389         BEFORE(glUniform2i);
1390         glUniform2ip(location, v0, v1);
1391         error = glGetError();
1392         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
1393                         location, v0, v1);
1394 }
1395
1396 void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
1397         typedef void (*methodType)(GLint, GLint, GLint, GLint);
1398         BEFORE(glUniform3i);
1399         glUniform3ip(location, v0, v1, v2);
1400         error = glGetError();
1401         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
1402                         location, v0, v1, v2);
1403 }
1404
1405 void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
1406         typedef void (*methodType)(GLint, GLint, GLint, GLint, GLint);
1407         BEFORE(glUniform4i);
1408         glUniform4ip(location, v0, v1, v2, v3);
1409         error = glGetError();
1410         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
1411                         "ddddd", location, v0, v1, v2, v3);
1412 }
1413
1414 void glUniform1iv(GLint location, GLsizei count, const GLint *value) {
1415         typedef void (*methodType)(GLint, GLsizei, const GLint *);
1416         BEFORE(glUniform1iv);
1417         glUniform1ivp(location, count, value);
1418         error = glGetError();
1419         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1420               location, count, voidp_to_uint64(value));
1421 }
1422
1423 void glUniform2iv(GLint location, GLsizei count, const GLint *value) {
1424         typedef void (*methodType)(GLint, GLsizei, const GLint *);
1425         BEFORE(glUniform2iv);
1426         glUniform2ivp(location, count, value);
1427         error = glGetError();
1428         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1429               location, count, voidp_to_uint64(value));
1430 }
1431
1432 void glUniform3iv(GLint location, GLsizei count, const GLint *value) {
1433         typedef void (*methodType)(GLint, GLsizei, const GLint *);
1434         BEFORE(glUniform3iv);
1435         glUniform3ivp(location, count, value);
1436         error = glGetError();
1437         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1438               location, count, voidp_to_uint64(value));
1439 }
1440
1441 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
1442                 const GLfloat *value) {
1443         typedef void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *);
1444         BEFORE(glUniformMatrix2fv);
1445         glUniformMatrix2fvp(location, count, transpose, value);
1446         error = glGetError();
1447         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
1448               location, count, (uint64_t)(transpose), voidp_to_uint64(value));
1449 }
1450
1451 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
1452                 const GLfloat *value) {
1453         typedef void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *);
1454         BEFORE(glUniformMatrix3fv);
1455         glUniformMatrix3fvp(location, count, transpose, value);
1456         error = glGetError();
1457         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
1458               location, count, (uint64_t)(transpose), voidp_to_uint64(value));
1459 }
1460
1461 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
1462                 const GLfloat *value) {
1463         typedef void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *);
1464         BEFORE(glUniformMatrix4fv);
1465         glUniformMatrix4fvp(location, count, transpose, value);
1466         error = glGetError();
1467         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
1468               location, count, (uint64_t)(transpose), voidp_to_uint64(value));
1469 }
1470
1471 void glUniform4iv(GLint location, GLsizei count, const GLint *value) {
1472         typedef void (*methodType)(GLint, GLsizei, const GLint *);
1473         BEFORE(glUniform4iv);
1474         glUniform4ivp(location, count, value);
1475         error = glGetError();
1476         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
1477               location, count, voidp_to_uint64(value));
1478 }
1479
1480 void glUseProgram(GLuint program) {
1481         typedef void (*methodType)(GLuint);
1482         BEFORE(glUseProgram);
1483         glUseProgramp(program);
1484         error = glGetError();
1485         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
1486                         program);
1487 }
1488
1489 // ==================================================================
1490 // V 7
1491 // ==================================================================
1492
1493 void glValidateProgram(GLuint program) {
1494         typedef void (*methodType)(GLuint);
1495         BEFORE(glValidateProgram);
1496         glValidateProgramp(program);
1497         error = glGetError();
1498         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
1499                         program);
1500 }
1501
1502 void glVertexAttrib1f(GLuint index, GLfloat v0) {
1503         typedef void (*methodType)(GLuint, GLfloat);
1504         BEFORE(glVertexAttrib1f);
1505         glVertexAttrib1fp(index, v0);
1506
1507         GLfloat cv[4];
1508         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1509         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1510
1511         error = glGetError();
1512         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1513                         "df", index, v0);
1514 }
1515
1516 void glVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {
1517         typedef void (*methodType)(GLuint, GLfloat, GLfloat);
1518         BEFORE(glVertexAttrib2f);
1519         glVertexAttrib2fp(index, v0, v1);
1520
1521         GLfloat cv[4];
1522         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1523         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1524
1525         error = glGetError();
1526         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1527                         "dff", index, v0, v1);
1528 }
1529
1530 void glVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {
1531         typedef void (*methodType)(GLuint, GLfloat, GLfloat, GLfloat);
1532         BEFORE(glVertexAttrib3f);
1533         glVertexAttrib3fp(index, v0, v1, v2);
1534
1535         GLfloat cv[4];
1536         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1537         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1538
1539         error = glGetError();
1540         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1541                         "dfff", index, v0, v1, v2);
1542 }
1543
1544 void glVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2,
1545                 GLfloat v3) {
1546         typedef void (*methodType)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
1547         BEFORE(glVertexAttrib4f);
1548         glVertexAttrib4fp(index, v0, v1, v2, v3);
1549
1550         GLfloat cv[4];
1551         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1552         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1553
1554         error = glGetError();
1555         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1556                         "dffff", index, v0, v1, v2, v3);
1557 }
1558
1559 void glVertexAttrib1fv(GLuint index, const GLfloat *v) {
1560         typedef void (*methodType)(GLuint, const GLfloat *);
1561         BEFORE(glVertexAttrib1fv);
1562         glVertexAttrib1fvp(index, v);
1563
1564         GLfloat cv[4];
1565         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1566         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1567
1568         error = glGetError();
1569         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1570               "dp", index, voidp_to_uint64(v));
1571 }
1572
1573 void glVertexAttrib2fv(GLuint index, const GLfloat *v) {
1574         typedef void (*methodType)(GLuint, const GLfloat *);
1575         BEFORE(glVertexAttrib2fv);
1576         glVertexAttrib2fvp(index, v);
1577
1578         GLfloat cv[4];
1579         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1580         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1581
1582         error = glGetError();
1583         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1584               "dp", index, voidp_to_uint64(v));
1585 }
1586
1587 void glVertexAttrib3fv(GLuint index, const GLfloat *v) {
1588         typedef void (*methodType)(GLuint, const GLfloat *);
1589         BEFORE(glVertexAttrib3fv);
1590         glVertexAttrib3fvp(index, v);
1591
1592         GLfloat cv[4];
1593         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1594         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1595
1596         error = glGetError();
1597         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1598               "dp", index, voidp_to_uint64(v));
1599 }
1600
1601 void glVertexAttrib4fv(GLuint index, const GLfloat *v) {
1602         typedef void (*methodType)(GLuint, const GLfloat *);
1603         BEFORE(glVertexAttrib4fv);
1604         glVertexAttrib4fvp(index, v);
1605         GLfloat cv[4];
1606         glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, cv);
1607         sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
1608
1609         error = glGetError();
1610         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
1611               "dp", index, voidp_to_uint64(v));
1612 }
1613
1614 void glVertexAttribPointer(GLuint index, GLint size, GLenum type,
1615                 GLboolean normalized, GLsizei stride, const GLvoid * pointer) {
1616         typedef void (*methodType)(GLuint, GLint, GLenum, GLboolean, GLsizei,
1617                         const GLvoid *);
1618         BEFORE(glVertexAttribPointer);
1619         glVertexAttribPointerp(index, size, type, normalized, stride, pointer);
1620         error = glGetError();
1621         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxxdp",
1622               index, size, (uint64_t)(type), (uint64_t)(normalized),
1623               stride, voidp_to_uint64(pointer));
1624 }
1625
1626 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1627         typedef void (*methodType)(GLint, GLint, GLsizei, GLsizei);
1628         BEFORE(glViewport);
1629         glViewportp(x, y, width, height);
1630         error = glGetError();
1631         AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
1632                         x, y, width, height);
1633 }