src/coregl_export_gl.c

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