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 indx, GLfloat x)
 797 {
 798         ovr_glVertexAttrib1f(indx, x);
 799 }
 800
 801 void
 802 coregl_api_glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 803 {
 804         ovr_glVertexAttrib1fv(indx, values);
 805 }
 806
 807 void
 808 coregl_api_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 809 {
 810         ovr_glVertexAttrib2f(indx, x, y);
 811 }
 812
 813 void
 814 coregl_api_glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 815 {
 816         ovr_glVertexAttrib2fv(indx, values);
 817 }
 818
 819 void
 820 coregl_api_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 821 {
 822         ovr_glVertexAttrib3f(indx, x, y, z);
 823 }
 824
 825 void
 826 coregl_api_glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 827 {
 828         ovr_glVertexAttrib3fv(indx, values);
 829 }
 830
 831 void
 832 coregl_api_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 coregl_api_glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 839 {
 840         ovr_glVertexAttrib4fv(indx, values);
 841 }
 842
 843 void
 844 coregl_api_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 coregl_api_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 851 {
 852         ovr_glViewport(x, y, width, height);
 853 }
 854