src/coregl_export_gl.c

   1 #include "coregl_export.h"
   2
   3 void
   4 coregl_api_glActiveTexture(GLenum texture)
   5 {
   6         ovr_glActiveTexture(texture);
   7 }
   8
   9 void
  10 coregl_api_glAttachShader(GLuint program, GLuint shader)
  11 {
  12         ovr_glAttachShader(program, shader);
  13 }
  14
  15 void
  16 coregl_api_glBindAttribLocation(GLuint program, GLuint index, const char* name)
  17 {
  18         ovr_glBindAttribLocation(program, index, name);
  19 }
  20
  21 void
  22 coregl_api_glBindBuffer(GLenum target, GLuint buffer)
  23 {
  24         ovr_glBindBuffer(target, buffer);
  25 }
  26
  27 void
  28 coregl_api_glBindFramebuffer(GLenum target, GLuint framebuffer)
  29 {
  30         ovr_glBindFramebuffer(target, framebuffer);
  31 }
  32
  33 void
  34 coregl_api_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
  35 {
  36         ovr_glBindRenderbuffer(target, renderbuffer);
  37 }
  38
  39 void
  40 coregl_api_glBindTexture(GLenum target, GLuint texture)
  41 {
  42         ovr_glBindTexture(target, texture);
  43 }
  44
  45 void
  46 coregl_api_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
  47 {
  48         ovr_glBlendColor(red, green, blue, alpha);
  49 }
  50
  51 void
  52 coregl_api_glBlendEquation(GLenum mode)
  53 {
  54         ovr_glBlendEquation(mode);
  55 }
  56
  57 void
  58 coregl_api_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
  59 {
  60         ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
  61 }
  62
  63 void
  64 coregl_api_glBlendFunc(GLenum sfactor, GLenum dfactor)
  65 {
  66         ovr_glBlendFunc(sfactor, dfactor);
  67 }
  68
  69 void
  70 coregl_api_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
  71 {
  72         ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
  73 }
  74
  75 void
  76 coregl_api_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
  77 {
  78         ovr_glBufferData(target, size, data, usage);
  79 }
  80
  81 void
  82 coregl_api_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
  83 {
  84         ovr_glBufferSubData(target, offset, size, data);
  85 }
  86
  87 GLenum
  88 coregl_api_glCheckFramebufferStatus(GLenum target)
  89 {
  90         return ovr_glCheckFramebufferStatus(target);
  91 }
  92
  93 void
  94 coregl_api_glClear(GLbitfield mask)
  95 {
  96         ovr_glClear(mask);
  97 }
  98
  99 void
 100 coregl_api_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 101 {
 102         ovr_glClearColor(red, green, blue, alpha);
 103 }
 104
 105 void
 106 coregl_api_glClearDepthf(GLclampf depth)
 107 {
 108         ovr_glClearDepthf(depth);
 109 }
 110
 111 void
 112 coregl_api_glClearStencil(GLint s)
 113 {
 114         ovr_glClearStencil(s);
 115 }
 116
 117 void
 118 coregl_api_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 119 {
 120         ovr_glColorMask(red, green, blue, alpha);
 121 }
 122
 123 void
 124 coregl_api_glCompileShader(GLuint shader)
 125 {
 126         ovr_glCompileShader(shader);
 127 }
 128
 129 void
 130 coregl_api_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 coregl_api_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 coregl_api_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 coregl_api_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 coregl_api_glCreateProgram(void)
 155 {
 156         return ovr_glCreateProgram();
 157 }
 158
 159 GLuint
 160 coregl_api_glCreateShader(GLenum type)
 161 {
 162         return ovr_glCreateShader(type);
 163 }
 164
 165 void
 166 coregl_api_glCullFace(GLenum mode)
 167 {
 168         ovr_glCullFace(mode);
 169 }
 170
 171 void
 172 coregl_api_glDeleteBuffers(GLsizei n, const GLuint* buffers)
 173 {
 174         ovr_glDeleteBuffers(n, buffers);
 175 }
 176
 177 void
 178 coregl_api_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 179 {
 180         ovr_glDeleteFramebuffers(n, framebuffers);
 181 }
 182
 183 void
 184 coregl_api_glDeleteProgram(GLuint program)
 185 {
 186         ovr_glDeleteProgram(program);
 187 }
 188
 189 void
 190 coregl_api_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 191 {
 192         ovr_glDeleteRenderbuffers(n, renderbuffers);
 193 }
 194
 195 void
 196 coregl_api_glDeleteShader(GLuint shader)
 197 {
 198         ovr_glDeleteShader(shader);
 199 }
 200
 201 void
 202 coregl_api_glDeleteTextures(GLsizei n, const GLuint* textures)
 203 {
 204         ovr_glDeleteTextures(n, textures);
 205 }
 206
 207 void
 208 coregl_api_glDepthFunc(GLenum func)
 209 {
 210         ovr_glDepthFunc(func);
 211 }
 212
 213 void
 214 coregl_api_glDepthMask(GLboolean flag)
 215 {
 216         ovr_glDepthMask(flag);
 217 }
 218
 219 void
 220 coregl_api_glDepthRangef(GLclampf zNear, GLclampf zFar)
 221 {
 222         ovr_glDepthRangef(zNear, zFar);
 223 }
 224
 225 void
 226 coregl_api_glDetachShader(GLuint program, GLuint shader)
 227 {
 228         ovr_glDetachShader(program, shader);
 229 }
 230
 231 void
 232 coregl_api_glDisable(GLenum cap)
 233 {
 234         ovr_glDisable(cap);
 235 }
 236
 237 void
 238 coregl_api_glDisableVertexAttribArray(GLuint index)
 239 {
 240         ovr_glDisableVertexAttribArray(index);
 241 }
 242
 243 void
 244 coregl_api_glDrawArrays(GLenum mode, GLint first, GLsizei count)
 245 {
 246         ovr_glDrawArrays(mode, first, count);
 247 }
 248
 249 void
 250 coregl_api_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
 251 {
 252         ovr_glDrawElements(mode, count, type, indices);
 253 }
 254
 255 void
 256 coregl_api_glEnable(GLenum cap)
 257 {
 258         ovr_glEnable(cap);
 259 }
 260
 261 void
 262 coregl_api_glEnableVertexAttribArray(GLuint index)
 263 {
 264         ovr_glEnableVertexAttribArray(index);
 265 }
 266
 267 void
 268 coregl_api_glFinish(void)
 269 {
 270         ovr_glFinish();
 271 }
 272
 273 void
 274 coregl_api_glFlush(void)
 275 {
 276         ovr_glFlush();
 277 }
 278
 279 void
 280 coregl_api_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 281 {
 282         ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 283 }
 284
 285 void
 286 coregl_api_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 coregl_api_glFrontFace(GLenum mode)
 293 {
 294         ovr_glFrontFace(mode);
 295 }
 296
 297 void
 298 coregl_api_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 299 {
 300         ovr_glGetVertexAttribfv(index, pname, params);
 301 }
 302
 303 void
 304 coregl_api_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 305 {
 306         ovr_glGetVertexAttribiv(index, pname, params);
 307 }
 308
 309 void
 310 coregl_api_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
 311 {
 312         ovr_glGetVertexAttribPointerv(index, pname, pointer);
 313 }
 314
 315 void
 316 coregl_api_glHint(GLenum target, GLenum mode)
 317 {
 318         ovr_glHint(target, mode);
 319 }
 320
 321 void
 322 coregl_api_glGenBuffers(GLsizei n, GLuint* buffers)
 323 {
 324         ovr_glGenBuffers(n, buffers);
 325 }
 326
 327 void
 328 coregl_api_glGenerateMipmap(GLenum target)
 329 {
 330         ovr_glGenerateMipmap(target);
 331 }
 332
 333 void
 334 coregl_api_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 335 {
 336         ovr_glGenFramebuffers(n, framebuffers);
 337 }
 338
 339 void
 340 coregl_api_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 341 {
 342         ovr_glGenRenderbuffers(n, renderbuffers);
 343 }
 344
 345 void
 346 coregl_api_glGenTextures(GLsizei n, GLuint* textures)
 347 {
 348         ovr_glGenTextures(n, textures);
 349 }
 350
 351 void
 352 coregl_api_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 coregl_api_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 coregl_api_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 365 {
 366         ovr_glGetAttachedShaders(program, maxcount, count, shaders);
 367 }
 368
 369 int
 370 coregl_api_glGetAttribLocation(GLuint program, const char* name)
 371 {
 372         return ovr_glGetAttribLocation(program, name);
 373 }
 374
 375 void
 376 coregl_api_glGetBooleanv(GLenum pname, GLboolean* params)
 377 {
 378         ovr_glGetBooleanv(pname, params);
 379 }
 380
 381 void
 382 coregl_api_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 383 {
 384         ovr_glGetBufferParameteriv(target, pname, params);
 385 }
 386
 387 GLenum
 388 coregl_api_glGetError(void)
 389 {
 390         return ovr_glGetError();
 391 }
 392
 393 void
 394 coregl_api_glGetFloatv(GLenum pname, GLfloat* params)
 395 {
 396         ovr_glGetFloatv(pname, params);
 397 }
 398
 399 void
 400 coregl_api_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 401 {
 402         ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 403 }
 404
 405 void
 406 coregl_api_glGetIntegerv(GLenum pname, GLint* params)
 407 {
 408         ovr_glGetIntegerv(pname, params);
 409 }
 410
 411 void
 412 coregl_api_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 413 {
 414         ovr_glGetProgramiv(program, pname, params);
 415 }
 416
 417 void
 418 coregl_api_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
 419 {
 420         ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
 421 }
 422
 423 void
 424 coregl_api_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 425 {
 426         ovr_glGetRenderbufferParameteriv(target, pname, params);
 427 }
 428
 429 void
 430 coregl_api_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 431 {
 432         ovr_glGetShaderiv(shader, pname, params);
 433 }
 434
 435 void
 436 coregl_api_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
 437 {
 438         ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
 439 }
 440
 441 void
 442 coregl_api_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 443 {
 444         ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 445 }
 446
 447 void
 448 coregl_api_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
 449 {
 450         ovr_glGetShaderSource(shader, bufsize, length, source);
 451 }
 452
 453 const GLubyte *
 454 coregl_api_glGetString(GLenum name)
 455 {
 456         return ovr_glGetString(name);
 457 }
 458
 459 void
 460 coregl_api_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 461 {
 462         ovr_glGetTexParameterfv(target, pname, params);
 463 }
 464
 465 void
 466 coregl_api_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 467 {
 468         ovr_glGetTexParameteriv(target, pname, params);
 469 }
 470
 471 void
 472 coregl_api_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 473 {
 474         ovr_glGetUniformfv(program, location, params);
 475 }
 476
 477 void
 478 coregl_api_glGetUniformiv(GLuint program, GLint location, GLint* params)
 479 {
 480         ovr_glGetUniformiv(program, location, params);
 481 }
 482
 483 int
 484 coregl_api_glGetUniformLocation(GLuint program, const char* name)
 485 {
 486         return ovr_glGetUniformLocation(program, name);
 487 }
 488
 489 GLboolean
 490 coregl_api_glIsBuffer(GLuint buffer)
 491 {
 492         return ovr_glIsBuffer(buffer);
 493 }
 494
 495 GLboolean
 496 coregl_api_glIsEnabled(GLenum cap)
 497 {
 498         return ovr_glIsEnabled(cap);
 499 }
 500
 501 GLboolean
 502 coregl_api_glIsFramebuffer(GLuint framebuffer)
 503 {
 504         return ovr_glIsFramebuffer(framebuffer);
 505 }
 506
 507 GLboolean
 508 coregl_api_glIsProgram(GLuint program)
 509 {
 510         return ovr_glIsProgram(program);
 511 }
 512
 513 GLboolean
 514 coregl_api_glIsRenderbuffer(GLuint renderbuffer)
 515 {
 516         return ovr_glIsRenderbuffer(renderbuffer);
 517 }
 518
 519 GLboolean
 520 coregl_api_glIsShader(GLuint shader)
 521 {
 522         return ovr_glIsShader(shader);
 523 }
 524
 525 GLboolean
 526 coregl_api_glIsTexture(GLuint texture)
 527 {
 528         return ovr_glIsTexture(texture);
 529 }
 530
 531 void
 532 coregl_api_glLineWidth(GLfloat width)
 533 {
 534         ovr_glLineWidth(width);
 535 }
 536
 537 void
 538 coregl_api_glLinkProgram(GLuint program)
 539 {
 540         ovr_glLinkProgram(program);
 541 }
 542
 543 void
 544 coregl_api_glPixelStorei(GLenum pname, GLint param)
 545 {
 546         ovr_glPixelStorei(pname, param);
 547 }
 548
 549 void
 550 coregl_api_glPolygonOffset(GLfloat factor, GLfloat units)
 551 {
 552         ovr_glPolygonOffset(factor, units);
 553 }
 554
 555 void
 556 coregl_api_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 coregl_api_glReleaseShaderCompiler(void)
 563 {
 564         ovr_glReleaseShaderCompiler();
 565 }
 566
 567 void
 568 coregl_api_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 569 {
 570         ovr_glRenderbufferStorage(target, internalformat, width, height);
 571 }
 572
 573 void
 574 coregl_api_glSampleCoverage(GLclampf value, GLboolean invert)
 575 {
 576         ovr_glSampleCoverage(value, invert);
 577 }
 578
 579 void
 580 coregl_api_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 581 {
 582         ovr_glScissor(x, y, width, height);
 583 }
 584
 585 void
 586 coregl_api_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 coregl_api_glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
 593 {
 594         ovr_glShaderSource(shader, count, string, length);
 595 }
 596
 597 void
 598 coregl_api_glStencilFunc(GLenum func, GLint ref, GLuint mask)
 599 {
 600         ovr_glStencilFunc(func, ref, mask);
 601 }
 602
 603 void
 604 coregl_api_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 605 {
 606         ovr_glStencilFuncSeparate(face, func, ref, mask);
 607 }
 608
 609 void
 610 coregl_api_glStencilMask(GLuint mask)
 611 {
 612         ovr_glStencilMask(mask);
 613 }
 614
 615 void
 616 coregl_api_glStencilMaskSeparate(GLenum face, GLuint mask)
 617 {
 618         ovr_glStencilMaskSeparate(face, mask);
 619 }
 620
 621 void
 622 coregl_api_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 623 {
 624         ovr_glStencilOp(fail, zfail, zpass);
 625 }
 626
 627 void
 628 coregl_api_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 629 {
 630         ovr_glStencilOpSeparate(face, fail, zfail, zpass);
 631 }
 632
 633 void
 634 coregl_api_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 coregl_api_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 641 {
 642         ovr_glTexParameterf(target, pname, param);
 643 }
 644
 645 void
 646 coregl_api_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 647 {
 648         ovr_glTexParameterfv(target, pname, params);
 649 }
 650
 651 void
 652 coregl_api_glTexParameteri(GLenum target, GLenum pname, GLint param)
 653 {
 654         ovr_glTexParameteri(target, pname, param);
 655 }
 656
 657 void
 658 coregl_api_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 659 {
 660         ovr_glTexParameteriv(target, pname, params);
 661 }
 662
 663 void
 664 coregl_api_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 coregl_api_glUniform1f(GLint location, GLfloat x)
 671 {
 672         ovr_glUniform1f(location, x);
 673 }
 674
 675 void
 676 coregl_api_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 677 {
 678         ovr_glUniform1fv(location, count, v);
 679 }
 680
 681 void
 682 coregl_api_glUniform1i(GLint location, GLint x)
 683 {
 684         ovr_glUniform1i(location, x);
 685 }
 686
 687 void
 688 coregl_api_glUniform1iv(GLint location, GLsizei count, const GLint* v)
 689 {
 690         ovr_glUniform1iv(location, count, v);
 691 }
 692
 693 void
 694 coregl_api_glUniform2f(GLint location, GLfloat x, GLfloat y)
 695 {
 696         ovr_glUniform2f(location, x, y);
 697 }
 698
 699 void
 700 coregl_api_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 701 {
 702         ovr_glUniform2fv(location, count, v);
 703 }
 704
 705 void
 706 coregl_api_glUniform2i(GLint location, GLint x, GLint y)
 707 {
 708         ovr_glUniform2i(location, x, y);
 709 }
 710
 711 void
 712 coregl_api_glUniform2iv(GLint location, GLsizei count, const GLint* v)
 713 {
 714         ovr_glUniform2iv(location, count, v);
 715 }
 716
 717 void
 718 coregl_api_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 719 {
 720         ovr_glUniform3f(location, x, y, z);
 721 }
 722
 723 void
 724 coregl_api_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 725 {
 726         ovr_glUniform3fv(location, count, v);
 727 }
 728
 729 void
 730 coregl_api_glUniform3i(GLint location, GLint x, GLint y, GLint z)
 731 {
 732         ovr_glUniform3i(location, x, y, z);
 733 }
 734
 735 void
 736 coregl_api_glUniform3iv(GLint location, GLsizei count, const GLint* v)
 737 {
 738         ovr_glUniform3iv(location, count, v);
 739 }
 740
 741 void
 742 coregl_api_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 coregl_api_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 749 {
 750         ovr_glUniform4fv(location, count, v);
 751 }
 752
 753 void
 754 coregl_api_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 coregl_api_glUniform4iv(GLint location, GLsizei count, const GLint* v)
 761 {
 762         ovr_glUniform4iv(location, count, v);
 763 }
 764
 765 void
 766 coregl_api_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 767 {
 768         ovr_glUniformMatrix2fv(location, count, transpose, value);
 769 }
 770
 771 void
 772 coregl_api_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 773 {
 774         ovr_glUniformMatrix3fv(location, count, transpose, value);
 775 }
 776
 777 void
 778 coregl_api_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 779 {
 780         ovr_glUniformMatrix4fv(location, count, transpose, value);
 781 }
 782
 783 void
 784 coregl_api_glUseProgram(GLuint program)
 785 {
 786         ovr_glUseProgram(program);
 787 }
 788
 789 void
 790 coregl_api_glValidateProgram(GLuint program)
 791 {
 792         ovr_glValidateProgram(program);
 793 }
 794
 795 void
 796 coregl_api_glVertexAttrib1f(GLuint index, GLfloat x)
 797 {
 798         ovr_glVertexAttrib1f(index, x);
 799 }
 800
 801 void
 802 coregl_api_glVertexAttrib1fv(GLuint index, const GLfloat* values)
 803 {
 804         ovr_glVertexAttrib1fv(index, values);
 805 }
 806
 807 void
 808 coregl_api_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 809 {
 810         ovr_glVertexAttrib2f(index, x, y);
 811 }
 812
 813 void
 814 coregl_api_glVertexAttrib2fv(GLuint index, const GLfloat* values)
 815 {
 816         ovr_glVertexAttrib2fv(index, values);
 817 }
 818
 819 void
 820 coregl_api_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 821 {
 822         ovr_glVertexAttrib3f(index, x, y, z);
 823 }
 824
 825 void
 826 coregl_api_glVertexAttrib3fv(GLuint index, const GLfloat* values)
 827 {
 828         ovr_glVertexAttrib3fv(index, values);
 829 }
 830
 831 void
 832 coregl_api_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 833 {
 834         ovr_glVertexAttrib4f(index, x, y, z, w);
 835 }
 836
 837 void
 838 coregl_api_glVertexAttrib4fv(GLuint index, const GLfloat* values)
 839 {
 840         ovr_glVertexAttrib4fv(index, values);
 841 }
 842
 843 void
 844 coregl_api_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer)
 845 {
 846         ovr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
 847 }
 848
 849 void
 850 coregl_api_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 851 {
 852         ovr_glViewport(x, y, width, height);
 853 }
 854
 855 /* OpenGL ES 3.0 */
 856 void
 857 coregl_api_glReadBuffer(GLenum mode)
 858 {
 859         ovr_glReadBuffer(mode);
 860 }
 861
 862 void
 863 coregl_api_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
 864 {
 865         ovr_glDrawRangeElements(mode, start, end, count, type, indices);
 866 }
 867
 868 void
 869 coregl_api_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 870 {
 871         ovr_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border, format, type, pixels);
 872 }
 873
 874 void
 875 coregl_api_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 876 {
 877         ovr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 878 }
 879
 880 void
 881 coregl_api_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 882 {
 883         ovr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 884 }
 885
 886 void
 887 coregl_api_glCompressedTexImage3D(GLenum target, GLint level, GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 888 {
 889         ovr_glCompressedTexImage3D(target, level, GLinternalformat, width, height, depth, border, imageSize, data);
 890 }
 891
 892 void
 893 coregl_api_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 894 {
 895         ovr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 896 }
 897
 898 void
 899 coregl_api_glGenQueries(GLsizei n, GLuint* ids)
 900 {
 901         ovr_glGenQueries(n, ids);
 902 }
 903
 904 void
 905 coregl_api_glDeleteQueries(GLsizei n, const GLuint* ids)
 906 {
 907         ovr_glDeleteQueries(n, ids);
 908 }
 909
 910 GLboolean
 911 coregl_api_glIsQuery(GLuint id)
 912 {
 913         return ovr_glIsQuery(id);
 914 }
 915
 916 void
 917 coregl_api_glBeginQuery(GLenum target, GLuint id)
 918 {
 919         ovr_glBeginQuery(target, id);
 920 }
 921
 922 void
 923 coregl_api_glEndQuery(GLenum target)
 924 {
 925         ovr_glEndQuery(target);
 926 }
 927
 928 void
 929 coregl_api_glGetQueryiv(GLenum target, GLenum pname, GLint* params)
 930 {
 931         ovr_glGetQueryiv(target, pname, params);
 932 }
 933
 934 void
 935 coregl_api_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
 936 {
 937         ovr_glGetQueryObjectuiv(id, pname, params);
 938 }
 939
 940 GLboolean
 941 coregl_api_glUnmapBuffer(GLenum target)
 942 {
 943         return ovr_glUnmapBuffer(target);
 944 }
 945
 946 void
 947 coregl_api_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
 948 {
 949         ovr_glGetBufferPointerv(target, pname, params);
 950 }
 951
 952 void
 953 coregl_api_glDrawBuffers(GLsizei n, const GLenum* bufs)
 954 {
 955         ovr_glDrawBuffers(n, bufs);
 956 }
 957
 958 void
 959 coregl_api_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 960 {
 961         ovr_glUniformMatrix2x3fv(location, count, transpose, value);
 962 }
 963
 964 void
 965 coregl_api_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 966 {
 967         ovr_glUniformMatrix3x2fv(location, count, transpose, value);
 968 }
 969
 970 void
 971 coregl_api_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 972 {
 973         ovr_glUniformMatrix2x4fv(location, count, transpose, value);
 974 }
 975
 976 void
 977 coregl_api_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 978 {
 979         ovr_glUniformMatrix4x2fv(location, count, transpose, value);
 980 }
 981
 982 void
 983 coregl_api_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 984 {
 985         ovr_glUniformMatrix3x4fv(location, count, transpose, value);
 986 }
 987
 988 void
 989 coregl_api_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 990 {
 991         ovr_glUniformMatrix4x3fv(location, count, transpose, value);
 992 }
 993
 994 void
 995 coregl_api_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 996 {
 997         ovr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 998 }
 999
1000 void
1001 coregl_api_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1002 {
1003         ovr_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
1004 }
1005
1006 void
1007 coregl_api_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1008 {
1009         ovr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
1010 }
1011
1012 GLvoid*
1013 coregl_api_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
1014 {
1015         return ovr_glMapBufferRange(target, offset, length, access);
1016 }
1017
1018 void
1019 coregl_api_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
1020 {
1021         ovr_glFlushMappedBufferRange(target, offset, length);
1022 }
1023
1024 void
1025 coregl_api_glBindVertexArray(GLuint array)
1026 {
1027         ovr_glBindVertexArray(array);
1028 }
1029
1030 void
1031 coregl_api_glDeleteVertexArrays(GLsizei n, const GLuint* arrays)
1032 {
1033         ovr_glDeleteVertexArrays(n, arrays);
1034 }
1035
1036 void
1037 coregl_api_glGenVertexArrays(GLsizei n, GLuint* arrays)
1038 {
1039         ovr_glGenVertexArrays(n, arrays);
1040 }
1041
1042 GLboolean
1043 coregl_api_glIsVertexArray(GLuint array)
1044 {
1045         return ovr_glIsVertexArray(array);
1046 }
1047
1048 void
1049 coregl_api_glGetIntegeri_v(GLenum target, GLuint index, GLint* data)
1050 {
1051         ovr_glGetIntegeri_v(target, index, data);
1052 }
1053
1054 void
1055 coregl_api_glBeginTransformFeedback(GLenum primitiveMode)
1056 {
1057         ovr_glBeginTransformFeedback(primitiveMode);
1058 }
1059
1060 void
1061 coregl_api_glEndTransformFeedback()
1062 {
1063         ovr_glEndTransformFeedback();
1064 }
1065
1066 void
1067 coregl_api_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
1068 {
1069         ovr_glBindBufferRange(target, index, buffer, offset, size);
1070 }
1071
1072 void
1073 coregl_api_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
1074 {
1075         ovr_glBindBufferBase(target, index, buffer);
1076 }
1077
1078 void
1079 coregl_api_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
1080 {
1081         ovr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
1082 }
1083
1084 void
1085 coregl_api_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
1086 {
1087         ovr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
1088 }
1089
1090 void
1091 coregl_api_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
1092 {
1093         ovr_glVertexAttribIPointer(index, size, type, stride, pointer);
1094 }
1095
1096 void
1097 coregl_api_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
1098 {
1099         ovr_glGetVertexAttribIiv(index, pname, params);
1100 }
1101
1102 void
1103 coregl_api_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
1104 {
1105         ovr_glGetVertexAttribIuiv(index, pname, params);
1106 }
1107
1108 void
1109 coregl_api_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1110 {
1111         ovr_glVertexAttribI4i(index, x, y, z, w);
1112 }
1113
1114 void
1115 coregl_api_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
1116 {
1117         ovr_glVertexAttribI4ui(index, x, y, z, w);
1118 }
1119
1120 void
1121 coregl_api_glVertexAttribI4iv(GLuint index, const GLint* v)
1122 {
1123         ovr_glVertexAttribI4iv(index, v);
1124 }
1125
1126 void
1127 coregl_api_glVertexAttribI4uiv(GLuint index, const GLuint* v)
1128 {
1129         ovr_glVertexAttribI4uiv(index, v);
1130 }
1131
1132 void
1133 coregl_api_glGetUniformuiv(GLuint program, GLint location, GLuint* params)
1134 {
1135         ovr_glGetUniformuiv(program, location, params);
1136 }
1137
1138 GLint
1139 coregl_api_glGetFragDataLocation(GLuint program, const GLchar *name)
1140 {
1141         return ovr_glGetFragDataLocation(program, name);
1142 }
1143
1144 void
1145 coregl_api_glUniform1ui(GLint location, GLuint v0)
1146 {
1147         ovr_glUniform1ui(location, v0);
1148 }
1149
1150 void
1151 coregl_api_glUniform2ui(GLint location, GLuint v0, GLuint v1)
1152 {
1153         ovr_glUniform2ui(location, v0, v1);
1154 }
1155
1156 void
1157 coregl_api_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1158 {
1159         ovr_glUniform3ui(location, v0, v1, v2);
1160 }
1161
1162 void
1163 coregl_api_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
1164 {
1165         ovr_glUniform4ui(location, v0, v1, v2, v3);
1166 }
1167
1168 void
1169 coregl_api_glUniform1uiv(GLint location, GLsizei count, const GLuint* value)
1170 {
1171         ovr_glUniform1uiv(location, count, value);
1172 }
1173
1174 void
1175 coregl_api_glUniform2uiv(GLint location, GLsizei count, const GLuint* value)
1176 {
1177         ovr_glUniform2uiv(location, count, value);
1178 }
1179
1180 void
1181 coregl_api_glUniform3uiv(GLint location, GLsizei count, const GLuint* value)
1182 {
1183         ovr_glUniform3uiv(location, count, value);
1184 }
1185
1186 void
1187 coregl_api_glUniform4uiv(GLint location, GLsizei count, const GLuint* value)
1188 {
1189         ovr_glUniform4uiv(location, count, value);
1190 }
1191
1192 void
1193 coregl_api_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
1194 {
1195         ovr_glClearBufferiv(buffer, drawbuffer, value);
1196 }
1197
1198 void
1199 coregl_api_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
1200 {
1201         ovr_glClearBufferuiv(buffer, drawbuffer, value);
1202 }
1203
1204 void
1205 coregl_api_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
1206 {
1207         ovr_glClearBufferfv(buffer, drawbuffer, value);
1208 }
1209
1210 void
1211 coregl_api_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
1212 {
1213         ovr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
1214 }
1215
1216 const GLubyte*
1217 coregl_api_glGetStringi(GLenum name, GLuint index)
1218 {
1219         return ovr_glGetStringi(name, index);
1220 }
1221
1222 void
1223 coregl_api_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
1224 {
1225         ovr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
1226 }
1227
1228 void
1229 coregl_api_glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
1230 {
1231         ovr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
1232 }
1233
1234 void
1235 coregl_api_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
1236 {
1237         ovr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1238 }
1239
1240 GLuint
1241 coregl_api_glGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
1242 {
1243         return ovr_glGetUniformBlockIndex(program, uniformBlockName);
1244 }
1245
1246 void
1247 coregl_api_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
1248 {
1249         ovr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1250 }
1251
1252 void
1253 coregl_api_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
1254 {
1255         ovr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
1256 }
1257
1258 void
1259 coregl_api_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
1260 {
1261         ovr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
1262 }
1263
1264 void
1265 coregl_api_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
1266 {
1267         ovr_glDrawArraysInstanced(mode, first, count, instanceCount);
1268 }
1269
1270 void
1271 coregl_api_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
1272 {
1273         ovr_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
1274 }
1275
1276 GLsync
1277 coregl_api_glFenceSync(GLenum condition, GLbitfield flags)
1278 {
1279         return ovr_glFenceSync(condition, flags);
1280 }
1281
1282 GLboolean
1283 coregl_api_glIsSync(GLsync sync)
1284 {
1285         return ovr_glIsSync(sync);
1286 }
1287
1288 void
1289 coregl_api_glDeleteSync(GLsync sync)
1290 {
1291         ovr_glDeleteSync(sync);
1292 }
1293
1294 GLenum
1295 coregl_api_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1296 {
1297         return ovr_glClientWaitSync(sync, flags, timeout);
1298 }
1299
1300 void
1301 coregl_api_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1302 {
1303         ovr_glWaitSync(sync, flags, timeout);
1304 }
1305
1306 void
1307 coregl_api_glGetInteger64v(GLenum pname, GLint64* params)
1308 {
1309         ovr_glGetInteger64v(pname, params);
1310 }
1311
1312 void
1313 coregl_api_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
1314 {
1315         ovr_glGetSynciv(sync, pname, bufSize, length, values);
1316 }
1317
1318 void
1319 coregl_api_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data)
1320 {
1321         ovr_glGetInteger64i_v(target, index, data);
1322 }
1323
1324 void
1325 coregl_api_glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
1326 {
1327         ovr_glGetBufferParameteri64v(target, pname, params);
1328 }
1329
1330 void
1331 coregl_api_glGenSamplers(GLsizei n, GLuint* samplers)
1332 {
1333         ovr_glGenSamplers(n, samplers);
1334 }
1335
1336 void
1337 coregl_api_glDeleteSamplers(GLsizei n, const GLuint* samplers)
1338 {
1339         ovr_glDeleteSamplers(n, samplers);
1340 }
1341
1342 GLboolean
1343 coregl_api_glIsSampler(GLuint sampler)
1344 {
1345         return ovr_glIsSampler(sampler);
1346 }
1347
1348 void
1349 coregl_api_glBindSampler(GLuint unit, GLuint sampler)
1350 {
1351         ovr_glBindSampler(unit, sampler);
1352 }
1353
1354 void
1355 coregl_api_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1356 {
1357         ovr_glSamplerParameteri(sampler, pname, param);
1358 }
1359
1360 void
1361 coregl_api_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
1362 {
1363         ovr_glSamplerParameteriv(sampler, pname, param);
1364 }
1365
1366 void
1367 coregl_api_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1368 {
1369         ovr_glSamplerParameterf(sampler, pname, param);
1370 }
1371
1372 void
1373 coregl_api_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
1374 {
1375         ovr_glSamplerParameterfv(sampler, pname, param);
1376 }
1377
1378 void
1379 coregl_api_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
1380 {
1381         ovr_glGetSamplerParameteriv(sampler, pname, params);
1382 }
1383
1384 void
1385 coregl_api_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
1386 {
1387         ovr_glGetSamplerParameterfv(sampler, pname, params);
1388 }
1389
1390 void
1391 coregl_api_glVertexAttribDivisor(GLuint index, GLuint divisor)
1392 {
1393         ovr_glVertexAttribDivisor(index, divisor);
1394 }
1395
1396 void
1397 coregl_api_glBindTransformFeedback(GLenum target, GLuint id)
1398 {
1399         ovr_glBindTransformFeedback(target, id);
1400 }
1401
1402 void
1403 coregl_api_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
1404 {
1405         ovr_glDeleteTransformFeedbacks(n, ids);
1406 }
1407
1408 void
1409 coregl_api_glGenTransformFeedbacks(GLsizei n, GLuint* ids)
1410 {
1411         ovr_glGenTransformFeedbacks(n, ids);
1412 }
1413
1414 GLboolean
1415 coregl_api_glIsTransformFeedback(GLuint id)
1416 {
1417         return ovr_glIsTransformFeedback(id);
1418 }
1419
1420 void
1421 coregl_api_glPauseTransformFeedback()
1422 {
1423         ovr_glPauseTransformFeedback();
1424 }
1425
1426 void
1427 coregl_api_glResumeTransformFeedback()
1428 {
1429         ovr_glResumeTransformFeedback();
1430 }
1431
1432 void
1433 coregl_api_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
1434 {
1435         ovr_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
1436 }
1437
1438 void
1439 coregl_api_glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
1440 {
1441         ovr_glProgramBinary(program, binaryFormat, binary, length);
1442 }
1443
1444 void
1445 coregl_api_glProgramParameteri(GLuint program, GLenum pname, GLint value)
1446 {
1447         ovr_glProgramParameteri(program, pname, value);
1448 }
1449
1450 void
1451 coregl_api_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
1452 {
1453         ovr_glInvalidateFramebuffer(target, numAttachments, attachments);
1454 }
1455
1456 void
1457 coregl_api_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1458 {
1459         ovr_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
1460 }
1461
1462 void
1463 coregl_api_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
1464 {
1465         ovr_glTexStorage2D(target, levels, internalformat, width, height);
1466 }
1467
1468 void
1469 coregl_api_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
1470 {
1471         ovr_glTexStorage3D(target, levels, internalformat, width, height, depth);
1472 }
1473
1474 void
1475 coregl_api_glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
1476 {
1477         ovr_glGetInternalformativ(target, internalformat, pname, bufSize, params);
1478 }
1479
1480