src/wraps/coregl_gl.c

   1 #include <stdio.h>
   2 #include <dlfcn.h>
   3
   4 # include <GLES/glplatform.h>
   5 # include "../headers/gl.h"
   6
   7 ///////////////////////////////////////
   8 // Disable dlog for debugging urgent issues //
   9 //#define LOG_TAG "CoreGL_GLES2"
  10 //#include <dlog.h>
  11 #define LOGE(...) fprintf(stderr, __VA_ARGS__)
  12 #define LOGW(...) fprintf(stderr, __VA_ARGS__)
  13 #define LOGD(...) fprintf(stderr, __VA_ARGS__)
  14 ///////////////////////////////////////
  15
  16 #define COREGL_API           __attribute__((visibility("default")))
  17
  18 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST)     COREGL_API extern RET_TYPE FUNC_NAME PARAM_LIST;
  19 #define _COREGL_EXT_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST)
  20 # include "../headers/sym_gl.h"
  21 #undef _COREGL_EXT_SYMBOL
  22 #undef _COREGL_SYMBOL
  23
  24 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST)     RET_TYPE (*ovr_##FUNC_NAME) PARAM_LIST = NULL;
  25 #define _COREGL_EXT_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST)
  26 # include "../headers/sym_gl.h"
  27 #undef _COREGL_EXT_SYMBOL
  28 #undef _COREGL_SYMBOL
  29
  30 #define INIT_EXPORT()
  31
  32 void *lib_handle = NULL;
  33
  34 __attribute__((constructor))
  35 int
  36 coregl_glwrap_init()
  37 {
  38         lib_handle = dlopen("libCOREGL.so", RTLD_NOW);
  39         if (!lib_handle) {
  40                 LOGE(" \E[40;31;1m%s\E[0m\n\n", dlerror());
  41                 LOGE(" \E[40;31;1mInvalid library link! (Check linkage of libEGL -> libCOREGL)\E[0m\n");
  42                 return 0;
  43         }
  44
  45 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) \
  46    ovr_##FUNC_NAME = (__typeof__(ovr_##FUNC_NAME))dlsym(lib_handle, "coregl_api_"#FUNC_NAME); \
  47         if (ovr_##FUNC_NAME == NULL) \
  48         { \
  49                 LOGE("\E[40;31;1mCan't find a symbol '%s'!\E[0m\n\n", #FUNC_NAME); \
  50                 LOGE("\E[40;31;1mInvalid library link! (Check linkage of libGLESv2 -> libCOREGL)\E[0m\n"); \
  51         }
  52
  53 #define _COREGL_EXT_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST)
  54 #include "../headers/sym_gl.h"
  55 #undef _COREGL_EXT_SYMBOL
  56 #undef _COREGL_SYMBOL
  57
  58         return 1;
  59 }
  60
  61 void
  62 glActiveTexture(GLenum texture)
  63 {
  64         ovr_glActiveTexture(texture);
  65 }
  66
  67 void
  68 glAttachShader(GLuint program, GLuint shader)
  69 {
  70         ovr_glAttachShader(program, shader);
  71 }
  72
  73 void
  74 glBindAttribLocation(GLuint program, GLuint index, const char *name)
  75 {
  76         ovr_glBindAttribLocation(program, index, name);
  77 }
  78
  79 void
  80 glBindBuffer(GLenum target, GLuint buffer)
  81 {
  82         ovr_glBindBuffer(target, buffer);
  83 }
  84
  85 void
  86 glBindFramebuffer(GLenum target, GLuint framebuffer)
  87 {
  88         ovr_glBindFramebuffer(target, framebuffer);
  89 }
  90
  91 void
  92 glBindRenderbuffer(GLenum target, GLuint renderbuffer)
  93 {
  94         ovr_glBindRenderbuffer(target, renderbuffer);
  95 }
  96
  97 void
  98 glBindTexture(GLenum target, GLuint texture)
  99 {
 100         ovr_glBindTexture(target, texture);
 101 }
 102
 103 void
 104 glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 105 {
 106         ovr_glBlendColor(red, green, blue, alpha);
 107 }
 108
 109 void
 110 glBlendEquation(GLenum mode)
 111 {
 112         ovr_glBlendEquation(mode);
 113 }
 114
 115 void
 116 glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 117 {
 118         ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
 119 }
 120
 121 void
 122 glBlendFunc(GLenum sfactor, GLenum dfactor)
 123 {
 124         ovr_glBlendFunc(sfactor, dfactor);
 125 }
 126
 127 void
 128 glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
 129                     GLenum dstAlpha)
 130 {
 131         ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 132 }
 133
 134 void
 135 glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 136 {
 137         ovr_glBufferData(target, size, data, usage);
 138 }
 139
 140 void
 141 glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
 142                 const void *data)
 143 {
 144         ovr_glBufferSubData(target, offset, size, data);
 145 }
 146
 147 GLenum
 148 glCheckFramebufferStatus(GLenum target)
 149 {
 150         return ovr_glCheckFramebufferStatus(target);
 151 }
 152
 153 void
 154 glClear(GLbitfield mask)
 155 {
 156         ovr_glClear(mask);
 157 }
 158
 159 void
 160 glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 161 {
 162         ovr_glClearColor(red, green, blue, alpha);
 163 }
 164
 165 void
 166 glClearDepthf(GLclampf depth)
 167 {
 168         ovr_glClearDepthf(depth);
 169 }
 170
 171 void
 172 glClearStencil(GLint s)
 173 {
 174         ovr_glClearStencil(s);
 175 }
 176
 177 void
 178 glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 179 {
 180         ovr_glColorMask(red, green, blue, alpha);
 181 }
 182
 183 void
 184 glCompileShader(GLuint shader)
 185 {
 186         ovr_glCompileShader(shader);
 187 }
 188
 189 void
 190 glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
 191                        GLsizei width, GLsizei height, GLint border, GLsizei imageSize,
 192                        const void *data)
 193 {
 194         ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border,
 195                                    imageSize, data);
 196 }
 197
 198 void
 199 glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 200                           GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
 201                           const void *data)
 202 {
 203         ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
 204                                       format, imageSize, data);
 205 }
 206
 207 void
 208 glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x,
 209                  GLint y, GLsizei width, GLsizei height, GLint border)
 210 {
 211         ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height,
 212                              border);
 213 }
 214
 215 void
 216 glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 217                     GLint x, GLint y, GLsizei width, GLsizei height)
 218 {
 219         ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 220 }
 221
 222 GLuint
 223 glCreateProgram(void)
 224 {
 225         return ovr_glCreateProgram();
 226 }
 227
 228 GLuint
 229 glCreateShader(GLenum type)
 230 {
 231         return ovr_glCreateShader(type);
 232 }
 233
 234 void
 235 glCullFace(GLenum mode)
 236 {
 237         ovr_glCullFace(mode);
 238 }
 239
 240 void
 241 glDeleteBuffers(GLsizei n, const GLuint *buffers)
 242 {
 243         ovr_glDeleteBuffers(n, buffers);
 244 }
 245
 246 void
 247 glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 248 {
 249         ovr_glDeleteFramebuffers(n, framebuffers);
 250 }
 251
 252 void
 253 glDeleteProgram(GLuint program)
 254 {
 255         ovr_glDeleteProgram(program);
 256 }
 257
 258 void
 259 glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 260 {
 261         ovr_glDeleteRenderbuffers(n, renderbuffers);
 262 }
 263
 264 void
 265 glDeleteShader(GLuint shader)
 266 {
 267         ovr_glDeleteShader(shader);
 268 }
 269
 270 void
 271 glDeleteTextures(GLsizei n, const GLuint *textures)
 272 {
 273         ovr_glDeleteTextures(n, textures);
 274 }
 275
 276 void
 277 glDepthFunc(GLenum func)
 278 {
 279         ovr_glDepthFunc(func);
 280 }
 281
 282 void
 283 glDepthMask(GLboolean flag)
 284 {
 285         ovr_glDepthMask(flag);
 286 }
 287
 288 void
 289 glDepthRangef(GLclampf zNear, GLclampf zFar)
 290 {
 291         ovr_glDepthRangef(zNear, zFar);
 292 }
 293
 294 void
 295 glDetachShader(GLuint program, GLuint shader)
 296 {
 297         ovr_glDetachShader(program, shader);
 298 }
 299
 300 void
 301 glDisable(GLenum cap)
 302 {
 303         ovr_glDisable(cap);
 304 }
 305
 306 void
 307 glDisableVertexAttribArray(GLuint index)
 308 {
 309         ovr_glDisableVertexAttribArray(index);
 310 }
 311
 312 void
 313 glDrawArrays(GLenum mode, GLint first, GLsizei count)
 314 {
 315         ovr_glDrawArrays(mode, first, count);
 316 }
 317
 318 void
 319 glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
 320 {
 321         ovr_glDrawElements(mode, count, type, indices);
 322 }
 323
 324 void
 325 glEnable(GLenum cap)
 326 {
 327         ovr_glEnable(cap);
 328 }
 329
 330 void
 331 glEnableVertexAttribArray(GLuint index)
 332 {
 333         ovr_glEnableVertexAttribArray(index);
 334 }
 335
 336 void
 337 glFinish(void)
 338 {
 339         ovr_glFinish();
 340 }
 341
 342 void
 343 glFlush(void)
 344 {
 345         ovr_glFlush();
 346 }
 347
 348 void
 349 glFramebufferRenderbuffer(GLenum target, GLenum attachment,
 350                           GLenum renderbuffertarget, GLuint renderbuffer)
 351 {
 352         ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
 353                                       renderbuffer);
 354 }
 355
 356 void
 357 glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
 358                        GLuint texture, GLint level)
 359 {
 360         ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
 361 }
 362
 363 void
 364 glFrontFace(GLenum mode)
 365 {
 366         ovr_glFrontFace(mode);
 367 }
 368
 369 void
 370 glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 371 {
 372         ovr_glGetVertexAttribfv(index, pname, params);
 373 }
 374
 375 void
 376 glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 377 {
 378         ovr_glGetVertexAttribiv(index, pname, params);
 379 }
 380
 381 void
 382 glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
 383 {
 384         ovr_glGetVertexAttribPointerv(index, pname, pointer);
 385 }
 386
 387 void
 388 glHint(GLenum target, GLenum mode)
 389 {
 390         ovr_glHint(target, mode);
 391 }
 392
 393 void
 394 glGenBuffers(GLsizei n, GLuint *buffers)
 395 {
 396         ovr_glGenBuffers(n, buffers);
 397 }
 398
 399 void
 400 glGenerateMipmap(GLenum target)
 401 {
 402         ovr_glGenerateMipmap(target);
 403 }
 404
 405 void
 406 glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 407 {
 408         ovr_glGenFramebuffers(n, framebuffers);
 409 }
 410
 411 void
 412 glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 413 {
 414         ovr_glGenRenderbuffers(n, renderbuffers);
 415 }
 416
 417 void
 418 glGenTextures(GLsizei n, GLuint *textures)
 419 {
 420         ovr_glGenTextures(n, textures);
 421 }
 422
 423 void
 424 glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
 425                   GLsizei *length, GLint *size, GLenum *type, char *name)
 426 {
 427         ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 428 }
 429
 430 void
 431 glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
 432                    GLsizei *length, GLint *size, GLenum *type, char *name)
 433 {
 434         ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
 435 }
 436
 437 void
 438 glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count,
 439                      GLuint *shaders)
 440 {
 441         ovr_glGetAttachedShaders(program, maxcount, count, shaders);
 442 }
 443
 444 int
 445 glGetAttribLocation(GLuint program, const char *name)
 446 {
 447         return ovr_glGetAttribLocation(program, name);
 448 }
 449
 450 void
 451 glGetBooleanv(GLenum pname, GLboolean *params)
 452 {
 453         ovr_glGetBooleanv(pname, params);
 454 }
 455
 456 void
 457 glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 458 {
 459         ovr_glGetBufferParameteriv(target, pname, params);
 460 }
 461
 462 GLenum
 463 glGetError(void)
 464 {
 465         return ovr_glGetError();
 466 }
 467
 468 void
 469 glGetFloatv(GLenum pname, GLfloat *params)
 470 {
 471         ovr_glGetFloatv(pname, params);
 472 }
 473
 474 void
 475 glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
 476                                       GLenum pname, GLint *params)
 477 {
 478         ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 479 }
 480
 481 void
 482 glGetIntegerv(GLenum pname, GLint *params)
 483 {
 484         ovr_glGetIntegerv(pname, params);
 485 }
 486
 487 void
 488 glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 489 {
 490         ovr_glGetProgramiv(program, pname, params);
 491 }
 492
 493 void
 494 glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
 495                     char *infolog)
 496 {
 497         ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
 498 }
 499
 500 void
 501 glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 502 {
 503         ovr_glGetRenderbufferParameteriv(target, pname, params);
 504 }
 505
 506 void
 507 glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 508 {
 509         ovr_glGetShaderiv(shader, pname, params);
 510 }
 511
 512 void
 513 glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
 514                    char *infolog)
 515 {
 516         ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
 517 }
 518
 519 void
 520 glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
 521                            GLint *range, GLint *precision)
 522 {
 523         ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 524 }
 525
 526 void
 527 glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, char *source)
 528 {
 529         ovr_glGetShaderSource(shader, bufsize, length, source);
 530 }
 531
 532 const GLubyte *
 533 glGetString(GLenum name)
 534 {
 535         return ovr_glGetString(name);
 536 }
 537
 538 void
 539 glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 540 {
 541         ovr_glGetTexParameterfv(target, pname, params);
 542 }
 543
 544 void
 545 glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 546 {
 547         ovr_glGetTexParameteriv(target, pname, params);
 548 }
 549
 550 void
 551 glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 552 {
 553         ovr_glGetUniformfv(program, location, params);
 554 }
 555
 556 void
 557 glGetUniformiv(GLuint program, GLint location, GLint *params)
 558 {
 559         ovr_glGetUniformiv(program, location, params);
 560 }
 561
 562 int
 563 glGetUniformLocation(GLuint program, const char *name)
 564 {
 565         return ovr_glGetUniformLocation(program, name);
 566 }
 567
 568 GLboolean
 569 glIsBuffer(GLuint buffer)
 570 {
 571         return ovr_glIsBuffer(buffer);
 572 }
 573
 574 GLboolean
 575 glIsEnabled(GLenum cap)
 576 {
 577         return ovr_glIsEnabled(cap);
 578 }
 579
 580 GLboolean
 581 glIsFramebuffer(GLuint framebuffer)
 582 {
 583         return ovr_glIsFramebuffer(framebuffer);
 584 }
 585
 586 GLboolean
 587 glIsProgram(GLuint program)
 588 {
 589         return ovr_glIsProgram(program);
 590 }
 591
 592 GLboolean
 593 glIsRenderbuffer(GLuint renderbuffer)
 594 {
 595         return ovr_glIsRenderbuffer(renderbuffer);
 596 }
 597
 598 GLboolean
 599 glIsShader(GLuint shader)
 600 {
 601         return ovr_glIsShader(shader);
 602 }
 603
 604 GLboolean
 605 glIsTexture(GLuint texture)
 606 {
 607         return ovr_glIsTexture(texture);
 608 }
 609
 610 void
 611 glLineWidth(GLfloat width)
 612 {
 613         ovr_glLineWidth(width);
 614 }
 615
 616 void
 617 glLinkProgram(GLuint program)
 618 {
 619         ovr_glLinkProgram(program);
 620 }
 621
 622 void
 623 glPixelStorei(GLenum pname, GLint param)
 624 {
 625         ovr_glPixelStorei(pname, param);
 626 }
 627
 628 void
 629 glPolygonOffset(GLfloat factor, GLfloat units)
 630 {
 631         ovr_glPolygonOffset(factor, units);
 632 }
 633
 634 void
 635 glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
 636              GLenum type, void *pixels)
 637 {
 638         ovr_glReadPixels(x, y, width, height, format, type, pixels);
 639 }
 640
 641 void
 642 glReleaseShaderCompiler(void)
 643 {
 644         ovr_glReleaseShaderCompiler();
 645 }
 646
 647 void
 648 glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width,
 649                       GLsizei height)
 650 {
 651         ovr_glRenderbufferStorage(target, internalformat, width, height);
 652 }
 653
 654 void
 655 glSampleCoverage(GLclampf value, GLboolean invert)
 656 {
 657         ovr_glSampleCoverage(value, invert);
 658 }
 659
 660 void
 661 glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 662 {
 663         ovr_glScissor(x, y, width, height);
 664 }
 665
 666 void
 667 glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
 668                const void *binary, GLsizei length)
 669 {
 670         ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
 671 }
 672
 673 void
 674 glShaderSource(GLuint shader, GLsizei count, const char **string,
 675                const GLint *length)
 676 {
 677         ovr_glShaderSource(shader, count, string, length);
 678 }
 679
 680 void
 681 glStencilFunc(GLenum func, GLint ref, GLuint mask)
 682 {
 683         ovr_glStencilFunc(func, ref, mask);
 684 }
 685
 686 void
 687 glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 688 {
 689         ovr_glStencilFuncSeparate(face, func, ref, mask);
 690 }
 691
 692 void
 693 glStencilMask(GLuint mask)
 694 {
 695         ovr_glStencilMask(mask);
 696 }
 697
 698 void
 699 glStencilMaskSeparate(GLenum face, GLuint mask)
 700 {
 701         ovr_glStencilMaskSeparate(face, mask);
 702 }
 703
 704 void
 705 glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 706 {
 707         ovr_glStencilOp(fail, zfail, zpass);
 708 }
 709
 710 void
 711 glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 712 {
 713         ovr_glStencilOpSeparate(face, fail, zfail, zpass);
 714 }
 715
 716 void
 717 glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width,
 718              GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
 719 {
 720         ovr_glTexImage2D(target, level, internalformat, width, height, border, format,
 721                          type, pixels);
 722 }
 723
 724 void
 725 glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 726 {
 727         ovr_glTexParameterf(target, pname, param);
 728 }
 729
 730 void
 731 glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 732 {
 733         ovr_glTexParameterfv(target, pname, params);
 734 }
 735
 736 void
 737 glTexParameteri(GLenum target, GLenum pname, GLint param)
 738 {
 739         ovr_glTexParameteri(target, pname, param);
 740 }
 741
 742 void
 743 glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 744 {
 745         ovr_glTexParameteriv(target, pname, params);
 746 }
 747
 748 void
 749 glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 750                 GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 751 {
 752         ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
 753                             type, pixels);
 754 }
 755
 756 void
 757 glUniform1f(GLint location, GLfloat x)
 758 {
 759         ovr_glUniform1f(location, x);
 760 }
 761
 762 void
 763 glUniform1fv(GLint location, GLsizei count, const GLfloat *v)
 764 {
 765         ovr_glUniform1fv(location, count, v);
 766 }
 767
 768 void
 769 glUniform1i(GLint location, GLint x)
 770 {
 771         ovr_glUniform1i(location, x);
 772 }
 773
 774 void
 775 glUniform1iv(GLint location, GLsizei count, const GLint *v)
 776 {
 777         ovr_glUniform1iv(location, count, v);
 778 }
 779
 780 void
 781 glUniform2f(GLint location, GLfloat x, GLfloat y)
 782 {
 783         ovr_glUniform2f(location, x, y);
 784 }
 785
 786 void
 787 glUniform2fv(GLint location, GLsizei count, const GLfloat *v)
 788 {
 789         ovr_glUniform2fv(location, count, v);
 790 }
 791
 792 void
 793 glUniform2i(GLint location, GLint x, GLint y)
 794 {
 795         ovr_glUniform2i(location, x, y);
 796 }
 797
 798 void
 799 glUniform2iv(GLint location, GLsizei count, const GLint *v)
 800 {
 801         ovr_glUniform2iv(location, count, v);
 802 }
 803
 804 void
 805 glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 806 {
 807         ovr_glUniform3f(location, x, y, z);
 808 }
 809
 810 void
 811 glUniform3fv(GLint location, GLsizei count, const GLfloat *v)
 812 {
 813         ovr_glUniform3fv(location, count, v);
 814 }
 815
 816 void
 817 glUniform3i(GLint location, GLint x, GLint y, GLint z)
 818 {
 819         ovr_glUniform3i(location, x, y, z);
 820 }
 821
 822 void
 823 glUniform3iv(GLint location, GLsizei count, const GLint *v)
 824 {
 825         ovr_glUniform3iv(location, count, v);
 826 }
 827
 828 void
 829 glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 830 {
 831         ovr_glUniform4f(location, x, y, z, w);
 832 }
 833
 834 void
 835 glUniform4fv(GLint location, GLsizei count, const GLfloat *v)
 836 {
 837         ovr_glUniform4fv(location, count, v);
 838 }
 839
 840 void
 841 glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 842 {
 843         ovr_glUniform4i(location, x, y, z, w);
 844 }
 845
 846 void
 847 glUniform4iv(GLint location, GLsizei count, const GLint *v)
 848 {
 849         ovr_glUniform4iv(location, count, v);
 850 }
 851
 852 void
 853 glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
 854                    const GLfloat *value)
 855 {
 856         ovr_glUniformMatrix2fv(location, count, transpose, value);
 857 }
 858
 859 void
 860 glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
 861                    const GLfloat *value)
 862 {
 863         ovr_glUniformMatrix3fv(location, count, transpose, value);
 864 }
 865
 866 void
 867 glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
 868                    const GLfloat *value)
 869 {
 870         ovr_glUniformMatrix4fv(location, count, transpose, value);
 871 }
 872
 873 void
 874 glUseProgram(GLuint program)
 875 {
 876         ovr_glUseProgram(program);
 877 }
 878
 879 void
 880 glValidateProgram(GLuint program)
 881 {
 882         ovr_glValidateProgram(program);
 883 }
 884
 885 void
 886 glVertexAttrib1f(GLuint index, GLfloat x)
 887 {
 888         ovr_glVertexAttrib1f(index, x);
 889 }
 890
 891 void
 892 glVertexAttrib1fv(GLuint index, const GLfloat *values)
 893 {
 894         ovr_glVertexAttrib1fv(index, values);
 895 }
 896
 897 void
 898 glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 899 {
 900         ovr_glVertexAttrib2f(index, x, y);
 901 }
 902
 903 void
 904 glVertexAttrib2fv(GLuint index, const GLfloat *values)
 905 {
 906         ovr_glVertexAttrib2fv(index, values);
 907 }
 908
 909 void
 910 glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 911 {
 912         ovr_glVertexAttrib3f(index, x, y, z);
 913 }
 914
 915 void
 916 glVertexAttrib3fv(GLuint index, const GLfloat *values)
 917 {
 918         ovr_glVertexAttrib3fv(index, values);
 919 }
 920
 921 void
 922 glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 923 {
 924         ovr_glVertexAttrib4f(index, x, y, z, w);
 925 }
 926
 927 void
 928 glVertexAttrib4fv(GLuint index, const GLfloat *values)
 929 {
 930         ovr_glVertexAttrib4fv(index, values);
 931 }
 932
 933 void
 934 glVertexAttribPointer(GLuint index, GLint size, GLenum type,
 935                       GLboolean normalized, GLsizei stride, const void *pointer)
 936 {
 937         ovr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
 938 }
 939
 940 void
 941 glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 942 {
 943         ovr_glViewport(x, y, width, height);
 944 }
 945
 946 /* OpenGL ES 3.0 */
 947 void
 948 glReadBuffer(GLenum mode)
 949 {
 950         ovr_glReadBuffer(mode);
 951 }
 952
 953 void
 954 glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
 955                     GLenum type, const GLvoid *indices)
 956 {
 957         ovr_glDrawRangeElements(mode, start, end, count, type, indices);
 958 }
 959
 960 void
 961 glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width,
 962              GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
 963              const GLvoid *pixels)
 964 {
 965         ovr_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border,
 966                          format, type, pixels);
 967 }
 968
 969 void
 970 glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 971                 GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format,
 972                 GLenum type, const GLvoid *pixels)
 973 {
 974         ovr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
 975                             depth, format, type, pixels);
 976 }
 977
 978 void
 979 glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 980                     GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 981 {
 982         ovr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
 983                                 height);
 984 }
 985
 986 void
 987 glCompressedTexImage3D(GLenum target, GLint level, GLenum GLinternalformat,
 988                        GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
 989                        const GLvoid *data)
 990 {
 991         ovr_glCompressedTexImage3D(target, level, GLinternalformat, width, height,
 992                                    depth, border, imageSize, data);
 993 }
 994
 995 void
 996 glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
 997                           GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
 998                           GLenum format, GLsizei imageSize, const GLvoid *data)
 999 {
1000         ovr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
1001                                       height, depth, format, imageSize, data);
1002 }
1003
1004 void
1005 glGenQueries(GLsizei n, GLuint *ids)
1006 {
1007         ovr_glGenQueries(n, ids);
1008 }
1009
1010 void
1011 glDeleteQueries(GLsizei n, const GLuint *ids)
1012 {
1013         ovr_glDeleteQueries(n, ids);
1014 }
1015
1016 GLboolean
1017 glIsQuery(GLuint id)
1018 {
1019         return ovr_glIsQuery(id);
1020 }
1021
1022 void
1023 glBeginQuery(GLenum target, GLuint id)
1024 {
1025         ovr_glBeginQuery(target, id);
1026 }
1027
1028 void
1029 glEndQuery(GLenum target)
1030 {
1031         ovr_glEndQuery(target);
1032 }
1033
1034 void
1035 glGetQueryiv(GLenum target, GLenum pname, GLint *params)
1036 {
1037         ovr_glGetQueryiv(target, pname, params);
1038 }
1039
1040 void
1041 glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
1042 {
1043         ovr_glGetQueryObjectuiv(id, pname, params);
1044 }
1045
1046 GLboolean
1047 glUnmapBuffer(GLenum target)
1048 {
1049         return ovr_glUnmapBuffer(target);
1050 }
1051
1052 void
1053 glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
1054 {
1055         ovr_glGetBufferPointerv(target, pname, params);
1056 }
1057
1058 void
1059 glDrawBuffers(GLsizei n, const GLenum *bufs)
1060 {
1061         ovr_glDrawBuffers(n, bufs);
1062 }
1063
1064 void
1065 glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
1066                      const GLfloat *value)
1067 {
1068         ovr_glUniformMatrix2x3fv(location, count, transpose, value);
1069 }
1070
1071 void
1072 glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
1073                      const GLfloat *value)
1074 {
1075         ovr_glUniformMatrix3x2fv(location, count, transpose, value);
1076 }
1077
1078 void
1079 glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
1080                      const GLfloat *value)
1081 {
1082         ovr_glUniformMatrix2x4fv(location, count, transpose, value);
1083 }
1084
1085 void
1086 glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
1087                      const GLfloat *value)
1088 {
1089         ovr_glUniformMatrix4x2fv(location, count, transpose, value);
1090 }
1091
1092 void
1093 glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
1094                      const GLfloat *value)
1095 {
1096         ovr_glUniformMatrix3x4fv(location, count, transpose, value);
1097 }
1098
1099 void
1100 glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
1101                      const GLfloat *value)
1102 {
1103         ovr_glUniformMatrix4x3fv(location, count, transpose, value);
1104 }
1105
1106 void
1107 glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
1108                   GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
1109                   GLenum filter)
1110 {
1111         ovr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
1112                               mask, filter);
1113 }
1114
1115 void
1116 glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
1117                                  GLenum internalformat, GLsizei width, GLsizei height)
1118 {
1119         ovr_glRenderbufferStorageMultisample(target, samples, internalformat, width,
1120                                              height);
1121 }
1122
1123 void
1124 glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture,
1125                           GLint level, GLint layer)
1126 {
1127         ovr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
1128 }
1129
1130 GLvoid *
1131 glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
1132                  GLbitfield access)
1133 {
1134         return ovr_glMapBufferRange(target, offset, length, access);
1135 }
1136
1137 void
1138 glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
1139 {
1140         ovr_glFlushMappedBufferRange(target, offset, length);
1141 }
1142
1143 void
1144 glBindVertexArray(GLuint array)
1145 {
1146         ovr_glBindVertexArray(array);
1147 }
1148
1149 void
1150 glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
1151 {
1152         ovr_glDeleteVertexArrays(n, arrays);
1153 }
1154
1155 void
1156 glGenVertexArrays(GLsizei n, GLuint *arrays)
1157 {
1158         ovr_glGenVertexArrays(n, arrays);
1159 }
1160
1161 GLboolean
1162 glIsVertexArray(GLuint array)
1163 {
1164         return ovr_glIsVertexArray(array);
1165 }
1166
1167 void
1168 glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
1169 {
1170         ovr_glGetIntegeri_v(target, index, data);
1171 }
1172
1173 void
1174 glBeginTransformFeedback(GLenum primitiveMode)
1175 {
1176         ovr_glBeginTransformFeedback(primitiveMode);
1177 }
1178
1179 void
1180 glEndTransformFeedback()
1181 {
1182         ovr_glEndTransformFeedback();
1183 }
1184
1185 void
1186 glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset,
1187                   GLsizeiptr size)
1188 {
1189         ovr_glBindBufferRange(target, index, buffer, offset, size);
1190 }
1191
1192 void
1193 glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
1194 {
1195         ovr_glBindBufferBase(target, index, buffer);
1196 }
1197
1198 void
1199 glTransformFeedbackVaryings(GLuint program, GLsizei count,
1200                             const GLchar *const *varyings, GLenum bufferMode)
1201 {
1202         ovr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
1203 }
1204
1205 void
1206 glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize,
1207                               GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
1208 {
1209         ovr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type,
1210                                           name);
1211 }
1212
1213 void
1214 glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride,
1215                        const GLvoid *pointer)
1216 {
1217         ovr_glVertexAttribIPointer(index, size, type, stride, pointer);
1218 }
1219
1220 void
1221 glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
1222 {
1223         ovr_glGetVertexAttribIiv(index, pname, params);
1224 }
1225
1226 void
1227 glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
1228 {
1229         ovr_glGetVertexAttribIuiv(index, pname, params);
1230 }
1231
1232 void
1233 glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1234 {
1235         ovr_glVertexAttribI4i(index, x, y, z, w);
1236 }
1237
1238 void
1239 glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
1240 {
1241         ovr_glVertexAttribI4ui(index, x, y, z, w);
1242 }
1243
1244 void
1245 glVertexAttribI4iv(GLuint index, const GLint *v)
1246 {
1247         ovr_glVertexAttribI4iv(index, v);
1248 }
1249
1250 void
1251 glVertexAttribI4uiv(GLuint index, const GLuint *v)
1252 {
1253         ovr_glVertexAttribI4uiv(index, v);
1254 }
1255
1256 void
1257 glGetUniformuiv(GLuint program, GLint location, GLuint *params)
1258 {
1259         ovr_glGetUniformuiv(program, location, params);
1260 }
1261
1262 GLint
1263 glGetFragDataLocation(GLuint program, const GLchar *name)
1264 {
1265         return ovr_glGetFragDataLocation(program, name);
1266 }
1267
1268 void
1269 glUniform1ui(GLint location, GLuint v0)
1270 {
1271         ovr_glUniform1ui(location, v0);
1272 }
1273
1274 void
1275 glUniform2ui(GLint location, GLuint v0, GLuint v1)
1276 {
1277         ovr_glUniform2ui(location, v0, v1);
1278 }
1279
1280 void
1281 glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1282 {
1283         ovr_glUniform3ui(location, v0, v1, v2);
1284 }
1285
1286 void
1287 glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1288 {
1289         ovr_glUniform4ui(location, v0, v1, v2, v3);
1290 }
1291
1292 void
1293 glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
1294 {
1295         ovr_glUniform1uiv(location, count, value);
1296 }
1297
1298 void
1299 glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
1300 {
1301         ovr_glUniform2uiv(location, count, value);
1302 }
1303
1304 void
1305 glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
1306 {
1307         ovr_glUniform3uiv(location, count, value);
1308 }
1309
1310 void
1311 glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
1312 {
1313         ovr_glUniform4uiv(location, count, value);
1314 }
1315
1316 void
1317 glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
1318 {
1319         ovr_glClearBufferiv(buffer, drawbuffer, value);
1320 }
1321
1322 void
1323 glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
1324 {
1325         ovr_glClearBufferuiv(buffer, drawbuffer, value);
1326 }
1327
1328 void
1329 glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
1330 {
1331         ovr_glClearBufferfv(buffer, drawbuffer, value);
1332 }
1333
1334 void
1335 glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
1336 {
1337         ovr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
1338 }
1339
1340 const GLubyte *
1341 glGetStringi(GLenum name, GLuint index)
1342 {
1343         return ovr_glGetStringi(name, index);
1344 }
1345
1346 void
1347 glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset,
1348                     GLintptr writeOffset, GLsizeiptr size)
1349 {
1350         ovr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
1351 }
1352
1353 void
1354 glGetUniformIndices(GLuint program, GLsizei uniformCount,
1355                     const GLchar *const *uniformNames, GLuint *uniformIndices)
1356 {
1357         ovr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
1358 }
1359
1360 void
1361 glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
1362                       const GLuint *uniformIndices, GLenum pname, GLint *params)
1363 {
1364         ovr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1365 }
1366
1367 GLuint
1368 glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
1369 {
1370         return ovr_glGetUniformBlockIndex(program, uniformBlockName);
1371 }
1372
1373 void
1374 glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
1375                           GLenum pname, GLint *params)
1376 {
1377         ovr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1378 }
1379
1380 void
1381 glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
1382                             GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
1383 {
1384         ovr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
1385                                         uniformBlockName);
1386 }
1387
1388 void
1389 glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
1390                       GLuint uniformBlockBinding)
1391 {
1392         ovr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
1393 }
1394
1395 void
1396 glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
1397                       GLsizei instanceCount)
1398 {
1399         ovr_glDrawArraysInstanced(mode, first, count, instanceCount);
1400 }
1401
1402 void
1403 glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
1404                         const GLvoid *indices, GLsizei instanceCount)
1405 {
1406         ovr_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
1407 }
1408
1409 GLsync
1410 glFenceSync(GLenum condition, GLbitfield flags)
1411 {
1412         return ovr_glFenceSync(condition, flags);
1413 }
1414
1415 GLboolean
1416 glIsSync(GLsync sync)
1417 {
1418         return ovr_glIsSync(sync);
1419 }
1420
1421 void
1422 glDeleteSync(GLsync sync)
1423 {
1424         ovr_glDeleteSync(sync);
1425 }
1426
1427 GLenum
1428 glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1429 {
1430         return ovr_glClientWaitSync(sync, flags, timeout);
1431 }
1432
1433 void
1434 glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1435 {
1436         ovr_glWaitSync(sync, flags, timeout);
1437 }
1438
1439 void
1440 glGetInteger64v(GLenum pname, GLint64 *params)
1441 {
1442         ovr_glGetInteger64v(pname, params);
1443 }
1444
1445 void
1446 glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length,
1447             GLint *values)
1448 {
1449         ovr_glGetSynciv(sync, pname, bufSize, length, values);
1450 }
1451
1452 void
1453 glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
1454 {
1455         ovr_glGetInteger64i_v(target, index, data);
1456 }
1457
1458 void
1459 glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
1460 {
1461         ovr_glGetBufferParameteri64v(target, pname, params);
1462 }
1463
1464 void
1465 glGenSamplers(GLsizei n, GLuint *samplers)
1466 {
1467         ovr_glGenSamplers(n, samplers);
1468 }
1469
1470 void
1471 glDeleteSamplers(GLsizei n, const GLuint *samplers)
1472 {
1473         ovr_glDeleteSamplers(n, samplers);
1474 }
1475
1476 GLboolean
1477 glIsSampler(GLuint sampler)
1478 {
1479         return ovr_glIsSampler(sampler);
1480 }
1481
1482 void
1483 glBindSampler(GLuint unit, GLuint sampler)
1484 {
1485         ovr_glBindSampler(unit, sampler);
1486 }
1487
1488 void
1489 glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1490 {
1491         ovr_glSamplerParameteri(sampler, pname, param);
1492 }
1493
1494 void
1495 glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
1496 {
1497         ovr_glSamplerParameteriv(sampler, pname, param);
1498 }
1499
1500 void
1501 glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1502 {
1503         ovr_glSamplerParameterf(sampler, pname, param);
1504 }
1505
1506 void
1507 glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
1508 {
1509         ovr_glSamplerParameterfv(sampler, pname, param);
1510 }
1511
1512 void
1513 glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
1514 {
1515         ovr_glGetSamplerParameteriv(sampler, pname, params);
1516 }
1517
1518 void
1519 glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
1520 {
1521         ovr_glGetSamplerParameterfv(sampler, pname, params);
1522 }
1523
1524 void
1525 glVertexAttribDivisor(GLuint index, GLuint divisor)
1526 {
1527         ovr_glVertexAttribDivisor(index, divisor);
1528 }
1529
1530 void
1531 glBindTransformFeedback(GLenum target, GLuint id)
1532 {
1533         ovr_glBindTransformFeedback(target, id);
1534 }
1535
1536 void
1537 glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
1538 {
1539         ovr_glDeleteTransformFeedbacks(n, ids);
1540 }
1541
1542 void
1543 glGenTransformFeedbacks(GLsizei n, GLuint *ids)
1544 {
1545         ovr_glGenTransformFeedbacks(n, ids);
1546 }
1547
1548 GLboolean
1549 glIsTransformFeedback(GLuint id)
1550 {
1551         return ovr_glIsTransformFeedback(id);
1552 }
1553
1554 void
1555 glPauseTransformFeedback()
1556 {
1557         ovr_glPauseTransformFeedback();
1558 }
1559
1560 void
1561 glResumeTransformFeedback()
1562 {
1563         ovr_glResumeTransformFeedback();
1564 }
1565
1566 void
1567 glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1568                    GLenum *binaryFormat, GLvoid *binary)
1569 {
1570         ovr_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
1571 }
1572
1573 void
1574 glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary,
1575                 GLsizei length)
1576 {
1577         ovr_glProgramBinary(program, binaryFormat, binary, length);
1578 }
1579
1580 void
1581 glProgramParameteri(GLuint program, GLenum pname, GLint value)
1582 {
1583         ovr_glProgramParameteri(program, pname, value);
1584 }
1585
1586 void
1587 glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
1588                         const GLenum *attachments)
1589 {
1590         ovr_glInvalidateFramebuffer(target, numAttachments, attachments);
1591 }
1592
1593 void
1594 glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
1595                            const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1596 {
1597         ovr_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
1598                                        height);
1599 }
1600
1601 void
1602 glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
1603                GLsizei width, GLsizei height)
1604 {
1605         ovr_glTexStorage2D(target, levels, internalformat, width, height);
1606 }
1607
1608 void
1609 glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
1610                GLsizei width, GLsizei height, GLsizei depth)
1611 {
1612         ovr_glTexStorage3D(target, levels, internalformat, width, height, depth);
1613 }
1614
1615 void
1616 glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
1617                       GLsizei bufSize, GLint *params)
1618 {
1619         ovr_glGetInternalformativ(target, internalformat, pname, bufSize, params);
1620 }
1621
1622 /* GLES3.1 API */
1623 GLuint
1624 glCreateShaderProgramv(GLenum type,  GLsizei count,
1625                        const GLchar *const *strings)
1626 {
1627         return ovr_glCreateShaderProgramv(type, count, strings);
1628 }
1629
1630 void
1631 glGenProgramPipelines( GLsizei n,  GLuint *pipelines)
1632 {
1633         ovr_glGenProgramPipelines(n, pipelines);
1634 }
1635
1636 void
1637 glBindProgramPipeline( GLuint pipeline)
1638 {
1639         ovr_glBindProgramPipeline(pipeline);
1640 }
1641
1642 void
1643 glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
1644 {
1645         ovr_glGetProgramPipelineiv(pipeline, pname, params);
1646 }
1647
1648 void
1649 glDeleteProgramPipelines(GLsizei n, GLuint const *pipelines)
1650 {
1651         ovr_glDeleteProgramPipelines(n, pipelines);
1652 }
1653
1654 GLboolean
1655 glIsProgramPipeline( GLuint pipeline)
1656 {
1657         return ovr_glIsProgramPipeline(pipeline);
1658 }
1659
1660 void
1661 glValidateProgramPipeline(GLuint pipeline)
1662 {
1663         ovr_glValidateProgramPipeline(pipeline);
1664 }
1665
1666 void
1667 glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length,
1668                             GLchar *infoLog)
1669 {
1670         ovr_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
1671 }
1672
1673 void
1674 glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
1675 {
1676         ovr_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
1677 }
1678
1679 void
1680 glDispatchComputeIndirect( GLintptr indirect)
1681 {
1682         ovr_glDispatchComputeIndirect(indirect);
1683 }
1684
1685 void
1686 glDrawArraysIndirect(GLenum mode, GLvoid const *indirect)
1687 {
1688         ovr_glDrawArraysIndirect(mode, indirect);
1689 }
1690
1691 void
1692 glDrawElementsIndirect(GLenum mode, GLenum type, GLvoid const *indirect)
1693 {
1694         ovr_glDrawElementsIndirect(mode, type, indirect);
1695 }
1696
1697 void
1698 glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
1699 {
1700         ovr_glFramebufferParameteri(target, pname, param);
1701 }
1702
1703 void
1704 glGetFramebufferParameteriv( GLenum target,  GLenum pname,  GLint *params)
1705 {
1706         ovr_glGetFramebufferParameteriv(target,  pname,  params);
1707 }
1708
1709 void
1710 glGetProgramInterfaceiv(GLuint program,  GLenum programInterface,  GLenum pname,
1711                         GLint *params)
1712 {
1713         ovr_glGetProgramInterfaceiv(program, programInterface, pname, params);
1714 }
1715
1716 GLuint
1717 glGetProgramResourceIndex( GLuint program,  GLenum programInterface,
1718                            const char *name)
1719 {
1720         return ovr_glGetProgramResourceIndex(program,  programInterface,  name);
1721 }
1722
1723 void
1724 glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index,
1725                          GLsizei bufSize, GLsizei *length, GLchar *name)
1726 {
1727         ovr_glGetProgramResourceName(program, programInterface, index, bufSize, length,
1728                                      name);
1729 }
1730
1731 void
1732 glGetProgramResourceiv( GLuint program,  GLenum programInterface,  GLuint index,
1733                         GLsizei propCount,  const GLenum *props,  GLsizei bufSize,  GLsizei *length,
1734                         GLint *params)
1735 {
1736         ovr_glGetProgramResourceiv(program,  programInterface,  index,  propCount,
1737                                    props,  bufSize,  length,  params);
1738 }
1739
1740 GLint
1741 glGetProgramResourceLocation(GLuint program, GLenum programInterface,
1742                              GLchar const *name)
1743 {
1744         return ovr_glGetProgramResourceLocation(program, programInterface, name);
1745 }
1746
1747 void
1748 glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
1749 {
1750         ovr_glUseProgramStages(pipeline, stages, program);
1751 }
1752
1753 void
1754 glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
1755                     const GLint *value)
1756 {
1757         ovr_glProgramUniform1iv(program, location, count, value);
1758 }
1759
1760
1761 void
1762 glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
1763                     const GLint *value)
1764 {
1765         ovr_glProgramUniform2iv(program, location, count, value);
1766 }
1767
1768
1769 void
1770 glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
1771                     const GLint *value)
1772 {
1773         ovr_glProgramUniform3iv(program, location, count, value);
1774 }
1775
1776
1777 void
1778 glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
1779                     const GLint *value)
1780 {
1781         ovr_glProgramUniform4iv(program, location, count, value);
1782 }
1783
1784
1785
1786 void
1787 glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
1788                     const GLfloat *value)
1789 {
1790         ovr_glProgramUniform1fv(program, location, count, value);
1791 }
1792
1793
1794 void
1795 glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
1796                     const GLfloat *value)
1797 {
1798         ovr_glProgramUniform2fv(program, location, count, value);
1799 }
1800
1801
1802 void
1803 glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
1804                     const GLfloat *value)
1805 {
1806         ovr_glProgramUniform3fv(program, location, count, value);
1807 }
1808
1809
1810 void
1811 glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
1812                     const GLfloat *value)
1813 {
1814         ovr_glProgramUniform4fv(program, location, count, value);
1815 }
1816
1817 void
1818 glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count,
1819                           GLboolean transpose, const GLfloat *value)
1820 {
1821         ovr_glProgramUniformMatrix2fv(program, location, count, transpose, value);
1822 }
1823
1824
1825 void
1826 glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count,
1827                           GLboolean transpose, const GLfloat *value)
1828 {
1829         ovr_glProgramUniformMatrix3fv(program, location, count, transpose, value);
1830 }
1831
1832
1833 void
1834 glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count,
1835                           GLboolean transpose, const GLfloat *value)
1836 {
1837         ovr_glProgramUniformMatrix4fv(program, location, count, transpose, value);
1838 }
1839
1840 void
1841 glProgramUniform1i(GLuint program, GLint location, GLint x)
1842 {
1843         ovr_glProgramUniform1i(program, location, x);
1844 }
1845
1846
1847 void
1848 glProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
1849 {
1850         ovr_glProgramUniform2i(program, location, x, y);
1851 }
1852
1853
1854 void
1855 glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y, GLint z)
1856 {
1857         ovr_glProgramUniform3i(program, location, x, y, z);
1858 }
1859
1860
1861 void
1862 glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y, GLint z,
1863                    GLint w)
1864 {
1865         ovr_glProgramUniform4i(program, location, x, y, z, w);
1866 }
1867
1868
1869 void
1870 glProgramUniform1f(GLuint program, GLint location, GLfloat x)
1871 {
1872         ovr_glProgramUniform1f(program, location, x);
1873 }
1874
1875
1876 void
1877 glProgramUniform2f(GLuint program, GLint location, GLfloat x, GLfloat y)
1878 {
1879         ovr_glProgramUniform2f(program, location, x, y);
1880 }
1881
1882
1883 void
1884 glProgramUniform3f(GLuint program, GLint location, GLfloat x, GLfloat y,
1885                    GLfloat z)
1886 {
1887         ovr_glProgramUniform3f(program, location, x, y, z);
1888 }
1889
1890
1891 void
1892 glProgramUniform4f(GLuint program, GLint location, GLfloat x, GLfloat y,
1893                    GLfloat z, GLfloat w)
1894 {
1895         ovr_glProgramUniform4f(program, location, x, y, z, w);
1896 }
1897
1898 void
1899 glProgramUniform1ui(GLuint program, GLint location, GLuint x)
1900 {
1901         ovr_glProgramUniform1ui(program, location, x);
1902 }
1903
1904
1905 void
1906 glProgramUniform2ui(GLuint program, GLint location, GLuint x, GLuint y)
1907 {
1908         ovr_glProgramUniform2ui(program, location, x, y);
1909 }
1910
1911
1912 void
1913 glProgramUniform3ui(GLuint program, GLint location, GLuint x, GLuint y,
1914                     GLuint z)
1915 {
1916         ovr_glProgramUniform3ui(program, location, x, y, z);
1917 }
1918
1919
1920 void
1921 glProgramUniform4ui(GLuint program, GLint location, GLuint x, GLuint y,
1922                     GLuint z, GLuint w)
1923 {
1924         ovr_glProgramUniform4ui(program, location, x, y, z, w);
1925 }
1926
1927 void
1928 glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
1929                      const GLuint *value)
1930 {
1931         ovr_glProgramUniform1uiv(program, location, count, value);
1932 }
1933
1934
1935 void
1936 glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
1937                      const GLuint *value)
1938 {
1939         ovr_glProgramUniform2uiv(program, location, count, value);
1940 }
1941
1942 void
1943 glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
1944                      const GLuint *value)
1945 {
1946         ovr_glProgramUniform3uiv(program, location, count, value);
1947 }
1948
1949 void
1950 glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
1951                      const GLuint *value)
1952 {
1953         ovr_glProgramUniform4uiv(program, location, count, value);
1954 }
1955
1956 void
1957 glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count,
1958                             GLboolean transpose, const GLfloat *value)
1959 {
1960         ovr_glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
1961 }
1962
1963
1964 void
1965 glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count,
1966                             GLboolean transpose, const GLfloat *value)
1967 {
1968         ovr_glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
1969 }
1970
1971
1972 void
1973 glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count,
1974                             GLboolean transpose, const GLfloat *value)
1975 {
1976         ovr_glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
1977 }
1978
1979 void
1980 glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count,
1981                             GLboolean transpose, const GLfloat *value)
1982 {
1983         ovr_glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
1984 }
1985
1986
1987 void
1988 glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
1989                             GLboolean transpose, const GLfloat *value)
1990 {
1991         ovr_glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
1992 }
1993
1994
1995 void
1996 glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count,
1997                             GLboolean transpose, const GLfloat *value)
1998 {
1999         ovr_glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
2000 }
2001
2002
2003 void
2004 glBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered,
2005                     GLint layer, GLenum access, GLenum format)
2006 {
2007         ovr_glBindImageTexture (unit, texture, level, layered, layer, access, format);
2008 }
2009
2010
2011 void
2012 glGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
2013 {
2014         ovr_glGetBooleani_v (target, index, data);
2015 }
2016
2017
2018 void
2019 glMemoryBarrier (GLbitfield barriers)
2020 {
2021         ovr_glMemoryBarrier (barriers);
2022 }
2023
2024
2025 void
2026 glMemoryBarrierByRegion (GLbitfield barriers)
2027 {
2028         ovr_glMemoryBarrierByRegion (barriers);
2029 }
2030
2031
2032 void
2033 glTexStorage2DMultisample (GLenum target, GLsizei samples,
2034                            GLenum internalformat, GLsizei width, GLsizei height,
2035                            GLboolean fixedsamplelocations)
2036 {
2037         ovr_glTexStorage2DMultisample (target, samples, internalformat, width, height,
2038                                        fixedsamplelocations);
2039 }
2040
2041
2042 void
2043 glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
2044 {
2045         ovr_glGetMultisamplefv (pname, index, val);
2046 }
2047
2048
2049 void
2050 glSampleMaski (GLuint maskNumber, GLbitfield mask)
2051 {
2052         ovr_glSampleMaski (maskNumber, mask);
2053 }
2054
2055
2056 void
2057 glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
2058                           GLint *params)
2059 {
2060         ovr_glGetTexLevelParameteriv (target, level, pname, params);
2061 }
2062
2063
2064 void
2065 glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
2066                           GLfloat *params)
2067 {
2068         ovr_glGetTexLevelParameterfv (target, level, pname, params);
2069 }
2070
2071
2072 void
2073 glBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset,
2074                     GLsizei stride)
2075 {
2076         ovr_glBindVertexBuffer (bindingindex, buffer, offset, stride);
2077 }
2078
2079
2080 void
2081 glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type,
2082                       GLboolean normalized, GLuint relativeoffset)
2083 {
2084         ovr_glVertexAttribFormat (attribindex, size, type, normalized, relativeoffset);
2085 }
2086
2087
2088 void
2089 glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type,
2090                        GLuint relativeoffset)
2091 {
2092         ovr_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
2093 }
2094
2095
2096 void
2097 glVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
2098 {
2099         ovr_glVertexAttribBinding (attribindex, bindingindex);
2100 }
2101
2102
2103 void
2104 glVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
2105 {
2106         ovr_glVertexBindingDivisor (bindingindex, divisor);
2107 }
2108
2109 void
2110 glGetPointerv(GLenum pname, GLvoid **params)
2111 {
2112         ovr_glGetPointerv(pname, params);
2113 }
2114
2115