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