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 #define COREGL_API           __attribute__((visibility("default")))
   8
   9 #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     COREGL_API extern RET_TYPE FUNC_NAME PARAM_LIST;
  10 # include "../headers/sym_gl.h"
  11 #undef _COREGL_SYMBOL
  12
  13 #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     RET_TYPE (*ovr_##FUNC_NAME) PARAM_LIST = NULL;
  14 # include "../headers/sym_gl.h"
  15 #undef _COREGL_SYMBOL
  16
  17 #define INIT_EXPORT()
  18
  19 __attribute__((constructor))
  20 int
  21 coregl_glwrap_init()
  22 {
  23         void *lib_handle = NULL;
  24
  25         lib_handle = dlopen("libCOREGL.so", RTLD_NOW);
  26         if (!lib_handle)
  27         {
  28                 fprintf(stderr, "\E[0;31;1mERROR : %s\E[0m\n\n", dlerror());
  29                 fprintf(stderr, "\E[0;31;1mERROR : Invalid library link! (Check linkage of libEGL -> libCOREGL)\E[0m\n");
  30                 return 0;
  31         }
  32
  33 #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) \
  34    ovr_##FUNC_NAME = (__typeof__(ovr_##FUNC_NAME))dlsym(lib_handle, #FUNC_NAME);
  35 #include "../headers/sym_gl.h"
  36 #undef _COREGL_SYMBOL
  37
  38         return 1;
  39 }
  40
  41 void
  42 glActiveTexture(GLenum texture)
  43 {
  44         ovr_glActiveTexture(texture);
  45 }
  46
  47 void
  48 glAttachShader(GLuint program, GLuint shader)
  49 {
  50         ovr_glAttachShader(program, shader);
  51 }
  52
  53 void
  54 glBindAttribLocation(GLuint program, GLuint index, const char* name)
  55 {
  56         ovr_glBindAttribLocation(program, index, name);
  57 }
  58
  59 void
  60 glBindBuffer(GLenum target, GLuint buffer)
  61 {
  62         ovr_glBindBuffer(target, buffer);
  63 }
  64
  65 void
  66 glBindFramebuffer(GLenum target, GLuint framebuffer)
  67 {
  68         ovr_glBindFramebuffer(target, framebuffer);
  69 }
  70
  71 void
  72 glBindRenderbuffer(GLenum target, GLuint renderbuffer)
  73 {
  74         ovr_glBindRenderbuffer(target, renderbuffer);
  75 }
  76
  77 void
  78 glBindTexture(GLenum target, GLuint texture)
  79 {
  80         ovr_glBindTexture(target, texture);
  81 }
  82
  83 void
  84 glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
  85 {
  86         ovr_glBlendColor(red, green, blue, alpha);
  87 }
  88
  89 void
  90 glBlendEquation(GLenum mode)
  91 {
  92         ovr_glBlendEquation(mode);
  93 }
  94
  95 void
  96 glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
  97 {
  98         ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
  99 }
 100
 101 void
 102 glBlendFunc(GLenum sfactor, GLenum dfactor)
 103 {
 104         ovr_glBlendFunc(sfactor, dfactor);
 105 }
 106
 107 void
 108 glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 109 {
 110         ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 111 }
 112
 113 void
 114 glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
 115 {
 116         ovr_glBufferData(target, size, data, usage);
 117 }
 118
 119 void
 120 glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
 121 {
 122         ovr_glBufferSubData(target, offset, size, data);
 123 }
 124
 125 GLenum
 126 glCheckFramebufferStatus(GLenum target)
 127 {
 128         return ovr_glCheckFramebufferStatus(target);
 129 }
 130
 131 void
 132 glClear(GLbitfield mask)
 133 {
 134         ovr_glClear(mask);
 135 }
 136
 137 void
 138 glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 139 {
 140         ovr_glClearColor(red, green, blue, alpha);
 141 }
 142
 143 void
 144 glClearDepthf(GLclampf depth)
 145 {
 146         ovr_glClearDepthf(depth);
 147 }
 148
 149 void
 150 glClearStencil(GLint s)
 151 {
 152         ovr_glClearStencil(s);
 153 }
 154
 155 void
 156 glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 157 {
 158         ovr_glColorMask(red, green, blue, alpha);
 159 }
 160
 161 void
 162 glCompileShader(GLuint shader)
 163 {
 164         ovr_glCompileShader(shader);
 165 }
 166
 167 void
 168 glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 169 {
 170         ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 171 }
 172
 173 void
 174 glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
 175 {
 176         ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 177 }
 178
 179 void
 180 glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 181 {
 182         ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 183 }
 184
 185 void
 186 glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 187 {
 188         ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 189 }
 190
 191 GLuint
 192 glCreateProgram(void)
 193 {
 194         return ovr_glCreateProgram();
 195 }
 196
 197 GLuint
 198 glCreateShader(GLenum type)
 199 {
 200         return ovr_glCreateShader(type);
 201 }
 202
 203 void
 204 glCullFace(GLenum mode)
 205 {
 206         ovr_glCullFace(mode);
 207 }
 208
 209 void
 210 glDeleteBuffers(GLsizei n, const GLuint* buffers)
 211 {
 212         ovr_glDeleteBuffers(n, buffers);
 213 }
 214
 215 void
 216 glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 217 {
 218         ovr_glDeleteFramebuffers(n, framebuffers);
 219 }
 220
 221 void
 222 glDeleteProgram(GLuint program)
 223 {
 224         ovr_glDeleteProgram(program);
 225 }
 226
 227 void
 228 glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 229 {
 230         ovr_glDeleteRenderbuffers(n, renderbuffers);
 231 }
 232
 233 void
 234 glDeleteShader(GLuint shader)
 235 {
 236         ovr_glDeleteShader(shader);
 237 }
 238
 239 void
 240 glDeleteTextures(GLsizei n, const GLuint* textures)
 241 {
 242         ovr_glDeleteTextures(n, textures);
 243 }
 244
 245 void
 246 glDepthFunc(GLenum func)
 247 {
 248         ovr_glDepthFunc(func);
 249 }
 250
 251 void
 252 glDepthMask(GLboolean flag)
 253 {
 254         ovr_glDepthMask(flag);
 255 }
 256
 257 void
 258 glDepthRangef(GLclampf zNear, GLclampf zFar)
 259 {
 260         ovr_glDepthRangef(zNear, zFar);
 261 }
 262
 263 void
 264 glDetachShader(GLuint program, GLuint shader)
 265 {
 266         ovr_glDetachShader(program, shader);
 267 }
 268
 269 void
 270 glDisable(GLenum cap)
 271 {
 272         ovr_glDisable(cap);
 273 }
 274
 275 void
 276 glDisableVertexAttribArray(GLuint index)
 277 {
 278         ovr_glDisableVertexAttribArray(index);
 279 }
 280
 281 void
 282 glDrawArrays(GLenum mode, GLint first, GLsizei count)
 283 {
 284         ovr_glDrawArrays(mode, first, count);
 285 }
 286
 287 void
 288 glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
 289 {
 290         ovr_glDrawElements(mode, count, type, indices);
 291 }
 292
 293 void
 294 glEnable(GLenum cap)
 295 {
 296         ovr_glEnable(cap);
 297 }
 298
 299 void
 300 glEnableVertexAttribArray(GLuint index)
 301 {
 302         ovr_glEnableVertexAttribArray(index);
 303 }
 304
 305 void
 306 glFinish(void)
 307 {
 308         ovr_glFinish();
 309 }
 310
 311 void
 312 glFlush(void)
 313 {
 314         ovr_glFlush();
 315 }
 316
 317 void
 318 glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 319 {
 320         ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 321 }
 322
 323 void
 324 glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 325 {
 326         ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
 327 }
 328
 329 void
 330 glFrontFace(GLenum mode)
 331 {
 332         ovr_glFrontFace(mode);
 333 }
 334
 335 void
 336 glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 337 {
 338         ovr_glGetVertexAttribfv(index, pname, params);
 339 }
 340
 341 void
 342 glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 343 {
 344         ovr_glGetVertexAttribiv(index, pname, params);
 345 }
 346
 347 void
 348 glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
 349 {
 350         ovr_glGetVertexAttribPointerv(index, pname, pointer);
 351 }
 352
 353 void
 354 glHint(GLenum target, GLenum mode)
 355 {
 356         ovr_glHint(target, mode);
 357 }
 358
 359 void
 360 glGenBuffers(GLsizei n, GLuint* buffers)
 361 {
 362         ovr_glGenBuffers(n, buffers);
 363 }
 364
 365 void
 366 glGenerateMipmap(GLenum target)
 367 {
 368         ovr_glGenerateMipmap(target);
 369 }
 370
 371 void
 372 glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 373 {
 374         ovr_glGenFramebuffers(n, framebuffers);
 375 }
 376
 377 void
 378 glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 379 {
 380         ovr_glGenRenderbuffers(n, renderbuffers);
 381 }
 382
 383 void
 384 glGenTextures(GLsizei n, GLuint* textures)
 385 {
 386         ovr_glGenTextures(n, textures);
 387 }
 388
 389 void
 390 glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 391 {
 392         ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 393 }
 394
 395 void
 396 glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 397 {
 398         ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
 399 }
 400
 401 void
 402 glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 403 {
 404         ovr_glGetAttachedShaders(program, maxcount, count, shaders);
 405 }
 406
 407 int
 408 glGetAttribLocation(GLuint program, const char* name)
 409 {
 410         return ovr_glGetAttribLocation(program, name);
 411 }
 412
 413 void
 414 glGetBooleanv(GLenum pname, GLboolean* params)
 415 {
 416         ovr_glGetBooleanv(pname, params);
 417 }
 418
 419 void
 420 glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 421 {
 422         ovr_glGetBufferParameteriv(target, pname, params);
 423 }
 424
 425 GLenum
 426 glGetError(void)
 427 {
 428         return ovr_glGetError();
 429 }
 430
 431 void
 432 glGetFloatv(GLenum pname, GLfloat* params)
 433 {
 434         ovr_glGetFloatv(pname, params);
 435 }
 436
 437 void
 438 glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 439 {
 440         ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 441 }
 442
 443 void
 444 glGetIntegerv(GLenum pname, GLint* params)
 445 {
 446         ovr_glGetIntegerv(pname, params);
 447 }
 448
 449 void
 450 glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 451 {
 452         ovr_glGetProgramiv(program, pname, params);
 453 }
 454
 455 void
 456 glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
 457 {
 458         ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
 459 }
 460
 461 void
 462 glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 463 {
 464         ovr_glGetRenderbufferParameteriv(target, pname, params);
 465 }
 466
 467 void
 468 glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 469 {
 470         ovr_glGetShaderiv(shader, pname, params);
 471 }
 472
 473 void
 474 glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
 475 {
 476         ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
 477 }
 478
 479 void
 480 glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 481 {
 482         ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 483 }
 484
 485 void
 486 glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
 487 {
 488         ovr_glGetShaderSource(shader, bufsize, length, source);
 489 }
 490
 491 const GLubyte *
 492 glGetString(GLenum name)
 493 {
 494         return ovr_glGetString(name);
 495 }
 496
 497 void
 498 glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 499 {
 500         ovr_glGetTexParameterfv(target, pname, params);
 501 }
 502
 503 void
 504 glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 505 {
 506         ovr_glGetTexParameteriv(target, pname, params);
 507 }
 508
 509 void
 510 glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 511 {
 512         ovr_glGetUniformfv(program, location, params);
 513 }
 514
 515 void
 516 glGetUniformiv(GLuint program, GLint location, GLint* params)
 517 {
 518         ovr_glGetUniformiv(program, location, params);
 519 }
 520
 521 int
 522 glGetUniformLocation(GLuint program, const char* name)
 523 {
 524         return ovr_glGetUniformLocation(program, name);
 525 }
 526
 527 GLboolean
 528 glIsBuffer(GLuint buffer)
 529 {
 530         return ovr_glIsBuffer(buffer);
 531 }
 532
 533 GLboolean
 534 glIsEnabled(GLenum cap)
 535 {
 536         return ovr_glIsEnabled(cap);
 537 }
 538
 539 GLboolean
 540 glIsFramebuffer(GLuint framebuffer)
 541 {
 542         return ovr_glIsFramebuffer(framebuffer);
 543 }
 544
 545 GLboolean
 546 glIsProgram(GLuint program)
 547 {
 548         return ovr_glIsProgram(program);
 549 }
 550
 551 GLboolean
 552 glIsRenderbuffer(GLuint renderbuffer)
 553 {
 554         return ovr_glIsRenderbuffer(renderbuffer);
 555 }
 556
 557 GLboolean
 558 glIsShader(GLuint shader)
 559 {
 560         return ovr_glIsShader(shader);
 561 }
 562
 563 GLboolean
 564 glIsTexture(GLuint texture)
 565 {
 566         return ovr_glIsTexture(texture);
 567 }
 568
 569 void
 570 glLineWidth(GLfloat width)
 571 {
 572         ovr_glLineWidth(width);
 573 }
 574
 575 void
 576 glLinkProgram(GLuint program)
 577 {
 578         ovr_glLinkProgram(program);
 579 }
 580
 581 void
 582 glPixelStorei(GLenum pname, GLint param)
 583 {
 584         ovr_glPixelStorei(pname, param);
 585 }
 586
 587 void
 588 glPolygonOffset(GLfloat factor, GLfloat units)
 589 {
 590         ovr_glPolygonOffset(factor, units);
 591 }
 592
 593 void
 594 glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
 595 {
 596         ovr_glReadPixels(x, y, width, height, format, type, pixels);
 597 }
 598
 599 void
 600 glReleaseShaderCompiler(void)
 601 {
 602         ovr_glReleaseShaderCompiler();
 603 }
 604
 605 void
 606 glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 607 {
 608         ovr_glRenderbufferStorage(target, internalformat, width, height);
 609 }
 610
 611 void
 612 glSampleCoverage(GLclampf value, GLboolean invert)
 613 {
 614         ovr_glSampleCoverage(value, invert);
 615 }
 616
 617 void
 618 glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 619 {
 620         ovr_glScissor(x, y, width, height);
 621 }
 622
 623 void
 624 glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
 625 {
 626         ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
 627 }
 628
 629 void
 630 glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
 631 {
 632         ovr_glShaderSource(shader, count, string, length);
 633 }
 634
 635 void
 636 glStencilFunc(GLenum func, GLint ref, GLuint mask)
 637 {
 638         ovr_glStencilFunc(func, ref, mask);
 639 }
 640
 641 void
 642 glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 643 {
 644         ovr_glStencilFuncSeparate(face, func, ref, mask);
 645 }
 646
 647 void
 648 glStencilMask(GLuint mask)
 649 {
 650         ovr_glStencilMask(mask);
 651 }
 652
 653 void
 654 glStencilMaskSeparate(GLenum face, GLuint mask)
 655 {
 656         ovr_glStencilMaskSeparate(face, mask);
 657 }
 658
 659 void
 660 glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 661 {
 662         ovr_glStencilOp(fail, zfail, zpass);
 663 }
 664
 665 void
 666 glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 667 {
 668         ovr_glStencilOpSeparate(face, fail, zfail, zpass);
 669 }
 670
 671 void
 672 glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
 673 {
 674         ovr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 675 }
 676
 677 void
 678 glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 679 {
 680         ovr_glTexParameterf(target, pname, param);
 681 }
 682
 683 void
 684 glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 685 {
 686         ovr_glTexParameterfv(target, pname, params);
 687 }
 688
 689 void
 690 glTexParameteri(GLenum target, GLenum pname, GLint param)
 691 {
 692         ovr_glTexParameteri(target, pname, param);
 693 }
 694
 695 void
 696 glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 697 {
 698         ovr_glTexParameteriv(target, pname, params);
 699 }
 700
 701 void
 702 glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
 703 {
 704         ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 705 }
 706
 707 void
 708 glUniform1f(GLint location, GLfloat x)
 709 {
 710         ovr_glUniform1f(location, x);
 711 }
 712
 713 void
 714 glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 715 {
 716         ovr_glUniform1fv(location, count, v);
 717 }
 718
 719 void
 720 glUniform1i(GLint location, GLint x)
 721 {
 722         ovr_glUniform1i(location, x);
 723 }
 724
 725 void
 726 glUniform1iv(GLint location, GLsizei count, const GLint* v)
 727 {
 728         ovr_glUniform1iv(location, count, v);
 729 }
 730
 731 void
 732 glUniform2f(GLint location, GLfloat x, GLfloat y)
 733 {
 734         ovr_glUniform2f(location, x, y);
 735 }
 736
 737 void
 738 glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 739 {
 740         ovr_glUniform2fv(location, count, v);
 741 }
 742
 743 void
 744 glUniform2i(GLint location, GLint x, GLint y)
 745 {
 746         ovr_glUniform2i(location, x, y);
 747 }
 748
 749 void
 750 glUniform2iv(GLint location, GLsizei count, const GLint* v)
 751 {
 752         ovr_glUniform2iv(location, count, v);
 753 }
 754
 755 void
 756 glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 757 {
 758         ovr_glUniform3f(location, x, y, z);
 759 }
 760
 761 void
 762 glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 763 {
 764         ovr_glUniform3fv(location, count, v);
 765 }
 766
 767 void
 768 glUniform3i(GLint location, GLint x, GLint y, GLint z)
 769 {
 770         ovr_glUniform3i(location, x, y, z);
 771 }
 772
 773 void
 774 glUniform3iv(GLint location, GLsizei count, const GLint* v)
 775 {
 776         ovr_glUniform3iv(location, count, v);
 777 }
 778
 779 void
 780 glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 781 {
 782         ovr_glUniform4f(location, x, y, z, w);
 783 }
 784
 785 void
 786 glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 787 {
 788         ovr_glUniform4fv(location, count, v);
 789 }
 790
 791 void
 792 glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 793 {
 794         ovr_glUniform4i(location, x, y, z, w);
 795 }
 796
 797 void
 798 glUniform4iv(GLint location, GLsizei count, const GLint* v)
 799 {
 800         ovr_glUniform4iv(location, count, v);
 801 }
 802
 803 void
 804 glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 805 {
 806         ovr_glUniformMatrix2fv(location, count, transpose, value);
 807 }
 808
 809 void
 810 glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 811 {
 812         ovr_glUniformMatrix3fv(location, count, transpose, value);
 813 }
 814
 815 void
 816 glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 817 {
 818         ovr_glUniformMatrix4fv(location, count, transpose, value);
 819 }
 820
 821 void
 822 glUseProgram(GLuint program)
 823 {
 824         ovr_glUseProgram(program);
 825 }
 826
 827 void
 828 glValidateProgram(GLuint program)
 829 {
 830         ovr_glValidateProgram(program);
 831 }
 832
 833 void
 834 glVertexAttrib1f(GLuint indx, GLfloat x)
 835 {
 836         ovr_glVertexAttrib1f(indx, x);
 837 }
 838
 839 void
 840 glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 841 {
 842         ovr_glVertexAttrib1fv(indx, values);
 843 }
 844
 845 void
 846 glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 847 {
 848         ovr_glVertexAttrib2f(indx, x, y);
 849 }
 850
 851 void
 852 glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 853 {
 854         ovr_glVertexAttrib2fv(indx, values);
 855 }
 856
 857 void
 858 glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 859 {
 860         ovr_glVertexAttrib3f(indx, x, y, z);
 861 }
 862
 863 void
 864 glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 865 {
 866         ovr_glVertexAttrib3fv(indx, values);
 867 }
 868
 869 void
 870 glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 871 {
 872         ovr_glVertexAttrib4f(indx, x, y, z, w);
 873 }
 874
 875 void
 876 glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 877 {
 878         ovr_glVertexAttrib4fv(indx, values);
 879 }
 880
 881 void
 882 glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
 883 {
 884         ovr_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 885 }
 886
 887 void
 888 glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 889 {
 890         ovr_glViewport(x, y, width, height);
 891 }
 892
 893
 894 // GLES Extensions...
 895 void
 896 glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 897 {
 898         ovr_glEGLImageTargetTexture2DOES(target, image);
 899 }
 900
 901 void
 902 glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 903 {
 904         ovr_glEGLImageTargetRenderbufferStorageOES(target, image);
 905 }
 906
 907 void
 908 glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei* length, GLenum* binaryFormat, void* binary)
 909 {
 910         ovr_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
 911 }
 912
 913 void
 914 glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLint length)
 915 {
 916         ovr_glProgramBinary(program, binaryFormat, binary, length);
 917 }
 918
 919
 920 void
 921 glProgramParameteri(GLuint program, GLuint pname, GLint value)
 922 {
 923         ovr_glProgramParameteri(program, pname, value);
 924 }
 925
 926 void
 927 glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 928 {
 929         ovr_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
 930 }
 931
 932 void
 933 glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 934 {
 935         ovr_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
 936 }
 937
 938 void
 939 glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 940 {
 941         ovr_glDiscardFramebufferEXT(target, numAttachments, attachments);
 942 }
 943
 944
 945