Add coding style guide.
[platform/core/uifw/coregl.git] / 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,
47                         GLclampf alpha)
48 {
49         ovr_glBlendColor(red, green, blue, alpha);
50 }
51
52 void
53 coregl_api_glBlendEquation(GLenum mode)
54 {
55         ovr_glBlendEquation(mode);
56 }
57
58 void
59 coregl_api_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
60 {
61         ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
62 }
63
64 void
65 coregl_api_glBlendFunc(GLenum sfactor, GLenum dfactor)
66 {
67         ovr_glBlendFunc(sfactor, dfactor);
68 }
69
70 void
71 coregl_api_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
72                                GLenum dstAlpha)
73 {
74         ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
75 }
76
77 void
78 coregl_api_glBufferData(GLenum target, GLsizeiptr size, const void *data,
79                         GLenum usage)
80 {
81         ovr_glBufferData(target, size, data, usage);
82 }
83
84 void
85 coregl_api_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
86                            const void *data)
87 {
88         ovr_glBufferSubData(target, offset, size, data);
89 }
90
91 GLenum
92 coregl_api_glCheckFramebufferStatus(GLenum target)
93 {
94         return ovr_glCheckFramebufferStatus(target);
95 }
96
97 void
98 coregl_api_glClear(GLbitfield mask)
99 {
100         ovr_glClear(mask);
101 }
102
103 void
104 coregl_api_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
105                         GLclampf alpha)
106 {
107         ovr_glClearColor(red, green, blue, alpha);
108 }
109
110 void
111 coregl_api_glClearDepthf(GLclampf depth)
112 {
113         ovr_glClearDepthf(depth);
114 }
115
116 void
117 coregl_api_glClearStencil(GLint s)
118 {
119         ovr_glClearStencil(s);
120 }
121
122 void
123 coregl_api_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
124                        GLboolean alpha)
125 {
126         ovr_glColorMask(red, green, blue, alpha);
127 }
128
129 void
130 coregl_api_glCompileShader(GLuint shader)
131 {
132         ovr_glCompileShader(shader);
133 }
134
135 void
136 coregl_api_glCompressedTexImage2D(GLenum target, GLint level,
137                                   GLenum internalformat, GLsizei width, GLsizei height, GLint border,
138                                   GLsizei imageSize, const void *data)
139 {
140         ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border,
141                                    imageSize, data);
142 }
143
144 void
145 coregl_api_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
146                                      GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
147                                      const void *data)
148 {
149         ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
150                                       format, imageSize, data);
151 }
152
153 void
154 coregl_api_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
155                             GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
156 {
157         ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height,
158                              border);
159 }
160
161 void
162 coregl_api_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
163                                GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
164 {
165         ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
166 }
167
168 GLuint
169 coregl_api_glCreateProgram(void)
170 {
171         return ovr_glCreateProgram();
172 }
173
174 GLuint
175 coregl_api_glCreateShader(GLenum type)
176 {
177         return ovr_glCreateShader(type);
178 }
179
180 void
181 coregl_api_glCullFace(GLenum mode)
182 {
183         ovr_glCullFace(mode);
184 }
185
186 void
187 coregl_api_glDeleteBuffers(GLsizei n, const GLuint *buffers)
188 {
189         ovr_glDeleteBuffers(n, buffers);
190 }
191
192 void
193 coregl_api_glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
194 {
195         ovr_glDeleteFramebuffers(n, framebuffers);
196 }
197
198 void
199 coregl_api_glDeleteProgram(GLuint program)
200 {
201         ovr_glDeleteProgram(program);
202 }
203
204 void
205 coregl_api_glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
206 {
207         ovr_glDeleteRenderbuffers(n, renderbuffers);
208 }
209
210 void
211 coregl_api_glDeleteShader(GLuint shader)
212 {
213         ovr_glDeleteShader(shader);
214 }
215
216 void
217 coregl_api_glDeleteTextures(GLsizei n, const GLuint *textures)
218 {
219         ovr_glDeleteTextures(n, textures);
220 }
221
222 void
223 coregl_api_glDepthFunc(GLenum func)
224 {
225         ovr_glDepthFunc(func);
226 }
227
228 void
229 coregl_api_glDepthMask(GLboolean flag)
230 {
231         ovr_glDepthMask(flag);
232 }
233
234 void
235 coregl_api_glDepthRangef(GLclampf zNear, GLclampf zFar)
236 {
237         ovr_glDepthRangef(zNear, zFar);
238 }
239
240 void
241 coregl_api_glDetachShader(GLuint program, GLuint shader)
242 {
243         ovr_glDetachShader(program, shader);
244 }
245
246 void
247 coregl_api_glDisable(GLenum cap)
248 {
249         ovr_glDisable(cap);
250 }
251
252 void
253 coregl_api_glDisableVertexAttribArray(GLuint index)
254 {
255         ovr_glDisableVertexAttribArray(index);
256 }
257
258 void
259 coregl_api_glDrawArrays(GLenum mode, GLint first, GLsizei count)
260 {
261         ovr_glDrawArrays(mode, first, count);
262 }
263
264 void
265 coregl_api_glDrawElements(GLenum mode, GLsizei count, GLenum type,
266                           const void *indices)
267 {
268         ovr_glDrawElements(mode, count, type, indices);
269 }
270
271 void
272 coregl_api_glEnable(GLenum cap)
273 {
274         ovr_glEnable(cap);
275 }
276
277 void
278 coregl_api_glEnableVertexAttribArray(GLuint index)
279 {
280         ovr_glEnableVertexAttribArray(index);
281 }
282
283 void
284 coregl_api_glFinish(void)
285 {
286         ovr_glFinish();
287 }
288
289 void
290 coregl_api_glFlush(void)
291 {
292         ovr_glFlush();
293 }
294
295 void
296 coregl_api_glFramebufferRenderbuffer(GLenum target, GLenum attachment,
297                                      GLenum renderbuffertarget, GLuint renderbuffer)
298 {
299         ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
300                                       renderbuffer);
301 }
302
303 void
304 coregl_api_glFramebufferTexture2D(GLenum target, GLenum attachment,
305                                   GLenum textarget, GLuint texture, GLint level)
306 {
307         ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
308 }
309
310 void
311 coregl_api_glFrontFace(GLenum mode)
312 {
313         ovr_glFrontFace(mode);
314 }
315
316 void
317 coregl_api_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
318 {
319         ovr_glGetVertexAttribfv(index, pname, params);
320 }
321
322 void
323 coregl_api_glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
324 {
325         ovr_glGetVertexAttribiv(index, pname, params);
326 }
327
328 void
329 coregl_api_glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
330 {
331         ovr_glGetVertexAttribPointerv(index, pname, pointer);
332 }
333
334 void
335 coregl_api_glHint(GLenum target, GLenum mode)
336 {
337         ovr_glHint(target, mode);
338 }
339
340 void
341 coregl_api_glGenBuffers(GLsizei n, GLuint *buffers)
342 {
343         ovr_glGenBuffers(n, buffers);
344 }
345
346 void
347 coregl_api_glGenerateMipmap(GLenum target)
348 {
349         ovr_glGenerateMipmap(target);
350 }
351
352 void
353 coregl_api_glGenFramebuffers(GLsizei n, GLuint *framebuffers)
354 {
355         ovr_glGenFramebuffers(n, framebuffers);
356 }
357
358 void
359 coregl_api_glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
360 {
361         ovr_glGenRenderbuffers(n, renderbuffers);
362 }
363
364 void
365 coregl_api_glGenTextures(GLsizei n, GLuint *textures)
366 {
367         ovr_glGenTextures(n, textures);
368 }
369
370 void
371 coregl_api_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
372                              GLsizei *length, GLint *size, GLenum *type, char *name)
373 {
374         ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
375 }
376
377 void
378 coregl_api_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
379                               GLsizei *length, GLint *size, GLenum *type, char *name)
380 {
381         ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
382 }
383
384 void
385 coregl_api_glGetAttachedShaders(GLuint program, GLsizei maxcount,
386                                 GLsizei *count, GLuint *shaders)
387 {
388         ovr_glGetAttachedShaders(program, maxcount, count, shaders);
389 }
390
391 int
392 coregl_api_glGetAttribLocation(GLuint program, const char *name)
393 {
394         return ovr_glGetAttribLocation(program, name);
395 }
396
397 void
398 coregl_api_glGetBooleanv(GLenum pname, GLboolean *params)
399 {
400         ovr_glGetBooleanv(pname, params);
401 }
402
403 void
404 coregl_api_glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
405 {
406         ovr_glGetBufferParameteriv(target, pname, params);
407 }
408
409 GLenum
410 coregl_api_glGetError(void)
411 {
412         return ovr_glGetError();
413 }
414
415 void
416 coregl_api_glGetFloatv(GLenum pname, GLfloat *params)
417 {
418         ovr_glGetFloatv(pname, params);
419 }
420
421 void
422 coregl_api_glGetFramebufferAttachmentParameteriv(GLenum target,
423                 GLenum attachment, GLenum pname, GLint *params)
424 {
425         ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
426 }
427
428 void
429 coregl_api_glGetIntegerv(GLenum pname, GLint *params)
430 {
431         ovr_glGetIntegerv(pname, params);
432 }
433
434 void
435 coregl_api_glGetProgramiv(GLuint program, GLenum pname, GLint *params)
436 {
437         ovr_glGetProgramiv(program, pname, params);
438 }
439
440 void
441 coregl_api_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
442                                char *infolog)
443 {
444         ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
445 }
446
447 void
448 coregl_api_glGetRenderbufferParameteriv(GLenum target, GLenum pname,
449                                         GLint *params)
450 {
451         ovr_glGetRenderbufferParameteriv(target, pname, params);
452 }
453
454 void
455 coregl_api_glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
456 {
457         ovr_glGetShaderiv(shader, pname, params);
458 }
459
460 void
461 coregl_api_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
462                               char *infolog)
463 {
464         ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
465 }
466
467 void
468 coregl_api_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
469                                       GLint *range, GLint *precision)
470 {
471         ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
472 }
473
474 void
475 coregl_api_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length,
476                              char *source)
477 {
478         ovr_glGetShaderSource(shader, bufsize, length, source);
479 }
480
481 const GLubyte *
482 coregl_api_glGetString(GLenum name)
483 {
484         return ovr_glGetString(name);
485 }
486
487 void
488 coregl_api_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
489 {
490         ovr_glGetTexParameterfv(target, pname, params);
491 }
492
493 void
494 coregl_api_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
495 {
496         ovr_glGetTexParameteriv(target, pname, params);
497 }
498
499 void
500 coregl_api_glGetUniformfv(GLuint program, GLint location, GLfloat *params)
501 {
502         ovr_glGetUniformfv(program, location, params);
503 }
504
505 void
506 coregl_api_glGetUniformiv(GLuint program, GLint location, GLint *params)
507 {
508         ovr_glGetUniformiv(program, location, params);
509 }
510
511 int
512 coregl_api_glGetUniformLocation(GLuint program, const char *name)
513 {
514         return ovr_glGetUniformLocation(program, name);
515 }
516
517 GLboolean
518 coregl_api_glIsBuffer(GLuint buffer)
519 {
520         return ovr_glIsBuffer(buffer);
521 }
522
523 GLboolean
524 coregl_api_glIsEnabled(GLenum cap)
525 {
526         return ovr_glIsEnabled(cap);
527 }
528
529 GLboolean
530 coregl_api_glIsFramebuffer(GLuint framebuffer)
531 {
532         return ovr_glIsFramebuffer(framebuffer);
533 }
534
535 GLboolean
536 coregl_api_glIsProgram(GLuint program)
537 {
538         return ovr_glIsProgram(program);
539 }
540
541 GLboolean
542 coregl_api_glIsRenderbuffer(GLuint renderbuffer)
543 {
544         return ovr_glIsRenderbuffer(renderbuffer);
545 }
546
547 GLboolean
548 coregl_api_glIsShader(GLuint shader)
549 {
550         return ovr_glIsShader(shader);
551 }
552
553 GLboolean
554 coregl_api_glIsTexture(GLuint texture)
555 {
556         return ovr_glIsTexture(texture);
557 }
558
559 void
560 coregl_api_glLineWidth(GLfloat width)
561 {
562         ovr_glLineWidth(width);
563 }
564
565 void
566 coregl_api_glLinkProgram(GLuint program)
567 {
568         ovr_glLinkProgram(program);
569 }
570
571 void
572 coregl_api_glPixelStorei(GLenum pname, GLint param)
573 {
574         ovr_glPixelStorei(pname, param);
575 }
576
577 void
578 coregl_api_glPolygonOffset(GLfloat factor, GLfloat units)
579 {
580         ovr_glPolygonOffset(factor, units);
581 }
582
583 void
584 coregl_api_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
585                         GLenum format, GLenum type, void *pixels)
586 {
587         ovr_glReadPixels(x, y, width, height, format, type, pixels);
588 }
589
590 void
591 coregl_api_glReleaseShaderCompiler(void)
592 {
593         ovr_glReleaseShaderCompiler();
594 }
595
596 void
597 coregl_api_glRenderbufferStorage(GLenum target, GLenum internalformat,
598                                  GLsizei width, GLsizei height)
599 {
600         ovr_glRenderbufferStorage(target, internalformat, width, height);
601 }
602
603 void
604 coregl_api_glSampleCoverage(GLclampf value, GLboolean invert)
605 {
606         ovr_glSampleCoverage(value, invert);
607 }
608
609 void
610 coregl_api_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
611 {
612         ovr_glScissor(x, y, width, height);
613 }
614
615 void
616 coregl_api_glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
617                           const void *binary, GLsizei length)
618 {
619         ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
620 }
621
622 void
623 coregl_api_glShaderSource(GLuint shader, GLsizei count, const char **string,
624                           const GLint *length)
625 {
626         ovr_glShaderSource(shader, count, string, length);
627 }
628
629 void
630 coregl_api_glStencilFunc(GLenum func, GLint ref, GLuint mask)
631 {
632         ovr_glStencilFunc(func, ref, mask);
633 }
634
635 void
636 coregl_api_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
637                                  GLuint mask)
638 {
639         ovr_glStencilFuncSeparate(face, func, ref, mask);
640 }
641
642 void
643 coregl_api_glStencilMask(GLuint mask)
644 {
645         ovr_glStencilMask(mask);
646 }
647
648 void
649 coregl_api_glStencilMaskSeparate(GLenum face, GLuint mask)
650 {
651         ovr_glStencilMaskSeparate(face, mask);
652 }
653
654 void
655 coregl_api_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
656 {
657         ovr_glStencilOp(fail, zfail, zpass);
658 }
659
660 void
661 coregl_api_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
662                                GLenum zpass)
663 {
664         ovr_glStencilOpSeparate(face, fail, zfail, zpass);
665 }
666
667 void
668 coregl_api_glTexImage2D(GLenum target, GLint level, GLint internalformat,
669                         GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
670                         const void *pixels)
671 {
672         ovr_glTexImage2D(target, level, internalformat, width, height, border, format,
673                          type, pixels);
674 }
675
676 void
677 coregl_api_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
678 {
679         ovr_glTexParameterf(target, pname, param);
680 }
681
682 void
683 coregl_api_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
684 {
685         ovr_glTexParameterfv(target, pname, params);
686 }
687
688 void
689 coregl_api_glTexParameteri(GLenum target, GLenum pname, GLint param)
690 {
691         ovr_glTexParameteri(target, pname, param);
692 }
693
694 void
695 coregl_api_glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
696 {
697         ovr_glTexParameteriv(target, pname, params);
698 }
699
700 void
701 coregl_api_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
702                            GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
703                            const void *pixels)
704 {
705         ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
706                             type, pixels);
707 }
708
709 void
710 coregl_api_glUniform1f(GLint location, GLfloat x)
711 {
712         ovr_glUniform1f(location, x);
713 }
714
715 void
716 coregl_api_glUniform1fv(GLint location, GLsizei count, const GLfloat *v)
717 {
718         ovr_glUniform1fv(location, count, v);
719 }
720
721 void
722 coregl_api_glUniform1i(GLint location, GLint x)
723 {
724         ovr_glUniform1i(location, x);
725 }
726
727 void
728 coregl_api_glUniform1iv(GLint location, GLsizei count, const GLint *v)
729 {
730         ovr_glUniform1iv(location, count, v);
731 }
732
733 void
734 coregl_api_glUniform2f(GLint location, GLfloat x, GLfloat y)
735 {
736         ovr_glUniform2f(location, x, y);
737 }
738
739 void
740 coregl_api_glUniform2fv(GLint location, GLsizei count, const GLfloat *v)
741 {
742         ovr_glUniform2fv(location, count, v);
743 }
744
745 void
746 coregl_api_glUniform2i(GLint location, GLint x, GLint y)
747 {
748         ovr_glUniform2i(location, x, y);
749 }
750
751 void
752 coregl_api_glUniform2iv(GLint location, GLsizei count, const GLint *v)
753 {
754         ovr_glUniform2iv(location, count, v);
755 }
756
757 void
758 coregl_api_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
759 {
760         ovr_glUniform3f(location, x, y, z);
761 }
762
763 void
764 coregl_api_glUniform3fv(GLint location, GLsizei count, const GLfloat *v)
765 {
766         ovr_glUniform3fv(location, count, v);
767 }
768
769 void
770 coregl_api_glUniform3i(GLint location, GLint x, GLint y, GLint z)
771 {
772         ovr_glUniform3i(location, x, y, z);
773 }
774
775 void
776 coregl_api_glUniform3iv(GLint location, GLsizei count, const GLint *v)
777 {
778         ovr_glUniform3iv(location, count, v);
779 }
780
781 void
782 coregl_api_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z,
783                        GLfloat w)
784 {
785         ovr_glUniform4f(location, x, y, z, w);
786 }
787
788 void
789 coregl_api_glUniform4fv(GLint location, GLsizei count, const GLfloat *v)
790 {
791         ovr_glUniform4fv(location, count, v);
792 }
793
794 void
795 coregl_api_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
796 {
797         ovr_glUniform4i(location, x, y, z, w);
798 }
799
800 void
801 coregl_api_glUniform4iv(GLint location, GLsizei count, const GLint *v)
802 {
803         ovr_glUniform4iv(location, count, v);
804 }
805
806 void
807 coregl_api_glUniformMatrix2fv(GLint location, GLsizei count,
808                               GLboolean transpose, const GLfloat *value)
809 {
810         ovr_glUniformMatrix2fv(location, count, transpose, value);
811 }
812
813 void
814 coregl_api_glUniformMatrix3fv(GLint location, GLsizei count,
815                               GLboolean transpose, const GLfloat *value)
816 {
817         ovr_glUniformMatrix3fv(location, count, transpose, value);
818 }
819
820 void
821 coregl_api_glUniformMatrix4fv(GLint location, GLsizei count,
822                               GLboolean transpose, const GLfloat *value)
823 {
824         ovr_glUniformMatrix4fv(location, count, transpose, value);
825 }
826
827 void
828 coregl_api_glUseProgram(GLuint program)
829 {
830         ovr_glUseProgram(program);
831 }
832
833 void
834 coregl_api_glValidateProgram(GLuint program)
835 {
836         ovr_glValidateProgram(program);
837 }
838
839 void
840 coregl_api_glVertexAttrib1f(GLuint index, GLfloat x)
841 {
842         ovr_glVertexAttrib1f(index, x);
843 }
844
845 void
846 coregl_api_glVertexAttrib1fv(GLuint index, const GLfloat *values)
847 {
848         ovr_glVertexAttrib1fv(index, values);
849 }
850
851 void
852 coregl_api_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
853 {
854         ovr_glVertexAttrib2f(index, x, y);
855 }
856
857 void
858 coregl_api_glVertexAttrib2fv(GLuint index, const GLfloat *values)
859 {
860         ovr_glVertexAttrib2fv(index, values);
861 }
862
863 void
864 coregl_api_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
865 {
866         ovr_glVertexAttrib3f(index, x, y, z);
867 }
868
869 void
870 coregl_api_glVertexAttrib3fv(GLuint index, const GLfloat *values)
871 {
872         ovr_glVertexAttrib3fv(index, values);
873 }
874
875 void
876 coregl_api_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
877                             GLfloat w)
878 {
879         ovr_glVertexAttrib4f(index, x, y, z, w);
880 }
881
882 void
883 coregl_api_glVertexAttrib4fv(GLuint index, const GLfloat *values)
884 {
885         ovr_glVertexAttrib4fv(index, values);
886 }
887
888 void
889 coregl_api_glVertexAttribPointer(GLuint index, GLint size, GLenum type,
890                                  GLboolean normalized, GLsizei stride, const void *pointer)
891 {
892         ovr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
893 }
894
895 void
896 coregl_api_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
897 {
898         ovr_glViewport(x, y, width, height);
899 }
900
901 /* OpenGL ES 3.0 */
902 void
903 coregl_api_glReadBuffer(GLenum mode)
904 {
905         ovr_glReadBuffer(mode);
906 }
907
908 void
909 coregl_api_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
910                                GLsizei count, GLenum type, const GLvoid *indices)
911 {
912         ovr_glDrawRangeElements(mode, start, end, count, type, indices);
913 }
914
915 void
916 coregl_api_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat,
917                         GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
918                         GLenum type, const GLvoid *pixels)
919 {
920         ovr_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border,
921                          format, type, pixels);
922 }
923
924 void
925 coregl_api_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
926                            GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
927                            GLenum format, GLenum type, const GLvoid *pixels)
928 {
929         ovr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
930                             depth, format, type, pixels);
931 }
932
933 void
934 coregl_api_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
935                                GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
936 {
937         ovr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
938                                 height);
939 }
940
941 void
942 coregl_api_glCompressedTexImage3D(GLenum target, GLint level,
943                                   GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
944                                   GLint border, GLsizei imageSize, const GLvoid *data)
945 {
946         ovr_glCompressedTexImage3D(target, level, GLinternalformat, width, height,
947                                    depth, border, imageSize, data);
948 }
949
950 void
951 coregl_api_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
952                                      GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
953                                      GLenum format, GLsizei imageSize, const GLvoid *data)
954 {
955         ovr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
956                                       height, depth, format, imageSize, data);
957 }
958
959 void
960 coregl_api_glGenQueries(GLsizei n, GLuint *ids)
961 {
962         ovr_glGenQueries(n, ids);
963 }
964
965 void
966 coregl_api_glDeleteQueries(GLsizei n, const GLuint *ids)
967 {
968         ovr_glDeleteQueries(n, ids);
969 }
970
971 GLboolean
972 coregl_api_glIsQuery(GLuint id)
973 {
974         return ovr_glIsQuery(id);
975 }
976
977 void
978 coregl_api_glBeginQuery(GLenum target, GLuint id)
979 {
980         ovr_glBeginQuery(target, id);
981 }
982
983 void
984 coregl_api_glEndQuery(GLenum target)
985 {
986         ovr_glEndQuery(target);
987 }
988
989 void
990 coregl_api_glGetQueryiv(GLenum target, GLenum pname, GLint *params)
991 {
992         ovr_glGetQueryiv(target, pname, params);
993 }
994
995 void
996 coregl_api_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
997 {
998         ovr_glGetQueryObjectuiv(id, pname, params);
999 }
1000
1001 GLboolean
1002 coregl_api_glUnmapBuffer(GLenum target)
1003 {
1004         return ovr_glUnmapBuffer(target);
1005 }
1006
1007 void
1008 coregl_api_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
1009 {
1010         ovr_glGetBufferPointerv(target, pname, params);
1011 }
1012
1013 void
1014 coregl_api_glDrawBuffers(GLsizei n, const GLenum *bufs)
1015 {
1016         ovr_glDrawBuffers(n, bufs);
1017 }
1018
1019 void
1020 coregl_api_glUniformMatrix2x3fv(GLint location, GLsizei count,
1021                                 GLboolean transpose, const GLfloat *value)
1022 {
1023         ovr_glUniformMatrix2x3fv(location, count, transpose, value);
1024 }
1025
1026 void
1027 coregl_api_glUniformMatrix3x2fv(GLint location, GLsizei count,
1028                                 GLboolean transpose, const GLfloat *value)
1029 {
1030         ovr_glUniformMatrix3x2fv(location, count, transpose, value);
1031 }
1032
1033 void
1034 coregl_api_glUniformMatrix2x4fv(GLint location, GLsizei count,
1035                                 GLboolean transpose, const GLfloat *value)
1036 {
1037         ovr_glUniformMatrix2x4fv(location, count, transpose, value);
1038 }
1039
1040 void
1041 coregl_api_glUniformMatrix4x2fv(GLint location, GLsizei count,
1042                                 GLboolean transpose, const GLfloat *value)
1043 {
1044         ovr_glUniformMatrix4x2fv(location, count, transpose, value);
1045 }
1046
1047 void
1048 coregl_api_glUniformMatrix3x4fv(GLint location, GLsizei count,
1049                                 GLboolean transpose, const GLfloat *value)
1050 {
1051         ovr_glUniformMatrix3x4fv(location, count, transpose, value);
1052 }
1053
1054 void
1055 coregl_api_glUniformMatrix4x3fv(GLint location, GLsizei count,
1056                                 GLboolean transpose, const GLfloat *value)
1057 {
1058         ovr_glUniformMatrix4x3fv(location, count, transpose, value);
1059 }
1060
1061 void
1062 coregl_api_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
1063                              GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
1064                              GLenum filter)
1065 {
1066         ovr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
1067                               mask, filter);
1068 }
1069
1070 void
1071 coregl_api_glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
1072                 GLenum internalformat, GLsizei width, GLsizei height)
1073 {
1074         ovr_glRenderbufferStorageMultisample(target, samples, internalformat, width,
1075                                              height);
1076 }
1077
1078 void
1079 coregl_api_glFramebufferTextureLayer(GLenum target, GLenum attachment,
1080                                      GLuint texture, GLint level, GLint layer)
1081 {
1082         ovr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
1083 }
1084
1085 GLvoid *
1086 coregl_api_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
1087                             GLbitfield access)
1088 {
1089         return ovr_glMapBufferRange(target, offset, length, access);
1090 }
1091
1092 void
1093 coregl_api_glFlushMappedBufferRange(GLenum target, GLintptr offset,
1094                                     GLsizeiptr length)
1095 {
1096         ovr_glFlushMappedBufferRange(target, offset, length);
1097 }
1098
1099 void
1100 coregl_api_glBindVertexArray(GLuint array)
1101 {
1102         ovr_glBindVertexArray(array);
1103 }
1104
1105 void
1106 coregl_api_glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
1107 {
1108         ovr_glDeleteVertexArrays(n, arrays);
1109 }
1110
1111 void
1112 coregl_api_glGenVertexArrays(GLsizei n, GLuint *arrays)
1113 {
1114         ovr_glGenVertexArrays(n, arrays);
1115 }
1116
1117 GLboolean
1118 coregl_api_glIsVertexArray(GLuint array)
1119 {
1120         return ovr_glIsVertexArray(array);
1121 }
1122
1123 void
1124 coregl_api_glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
1125 {
1126         ovr_glGetIntegeri_v(target, index, data);
1127 }
1128
1129 void
1130 coregl_api_glBeginTransformFeedback(GLenum primitiveMode)
1131 {
1132         ovr_glBeginTransformFeedback(primitiveMode);
1133 }
1134
1135 void
1136 coregl_api_glEndTransformFeedback()
1137 {
1138         ovr_glEndTransformFeedback();
1139 }
1140
1141 void
1142 coregl_api_glBindBufferRange(GLenum target, GLuint index, GLuint buffer,
1143                              GLintptr offset, GLsizeiptr size)
1144 {
1145         ovr_glBindBufferRange(target, index, buffer, offset, size);
1146 }
1147
1148 void
1149 coregl_api_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
1150 {
1151         ovr_glBindBufferBase(target, index, buffer);
1152 }
1153
1154 void
1155 coregl_api_glTransformFeedbackVaryings(GLuint program, GLsizei count,
1156                                        const GLchar *const *varyings, GLenum bufferMode)
1157 {
1158         ovr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
1159 }
1160
1161 void
1162 coregl_api_glGetTransformFeedbackVarying(GLuint program, GLuint index,
1163                 GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
1164 {
1165         ovr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type,
1166                                           name);
1167 }
1168
1169 void
1170 coregl_api_glVertexAttribIPointer(GLuint index, GLint size, GLenum type,
1171                                   GLsizei stride, const GLvoid *pointer)
1172 {
1173         ovr_glVertexAttribIPointer(index, size, type, stride, pointer);
1174 }
1175
1176 void
1177 coregl_api_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
1178 {
1179         ovr_glGetVertexAttribIiv(index, pname, params);
1180 }
1181
1182 void
1183 coregl_api_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
1184 {
1185         ovr_glGetVertexAttribIuiv(index, pname, params);
1186 }
1187
1188 void
1189 coregl_api_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
1190 {
1191         ovr_glVertexAttribI4i(index, x, y, z, w);
1192 }
1193
1194 void
1195 coregl_api_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
1196                               GLuint w)
1197 {
1198         ovr_glVertexAttribI4ui(index, x, y, z, w);
1199 }
1200
1201 void
1202 coregl_api_glVertexAttribI4iv(GLuint index, const GLint *v)
1203 {
1204         ovr_glVertexAttribI4iv(index, v);
1205 }
1206
1207 void
1208 coregl_api_glVertexAttribI4uiv(GLuint index, const GLuint *v)
1209 {
1210         ovr_glVertexAttribI4uiv(index, v);
1211 }
1212
1213 void
1214 coregl_api_glGetUniformuiv(GLuint program, GLint location, GLuint *params)
1215 {
1216         ovr_glGetUniformuiv(program, location, params);
1217 }
1218
1219 GLint
1220 coregl_api_glGetFragDataLocation(GLuint program, const GLchar *name)
1221 {
1222         return ovr_glGetFragDataLocation(program, name);
1223 }
1224
1225 void
1226 coregl_api_glUniform1ui(GLint location, GLuint v0)
1227 {
1228         ovr_glUniform1ui(location, v0);
1229 }
1230
1231 void
1232 coregl_api_glUniform2ui(GLint location, GLuint v0, GLuint v1)
1233 {
1234         ovr_glUniform2ui(location, v0, v1);
1235 }
1236
1237 void
1238 coregl_api_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
1239 {
1240         ovr_glUniform3ui(location, v0, v1, v2);
1241 }
1242
1243 void
1244 coregl_api_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2,
1245                         GLuint v3)
1246 {
1247         ovr_glUniform4ui(location, v0, v1, v2, v3);
1248 }
1249
1250 void
1251 coregl_api_glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
1252 {
1253         ovr_glUniform1uiv(location, count, value);
1254 }
1255
1256 void
1257 coregl_api_glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
1258 {
1259         ovr_glUniform2uiv(location, count, value);
1260 }
1261
1262 void
1263 coregl_api_glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
1264 {
1265         ovr_glUniform3uiv(location, count, value);
1266 }
1267
1268 void
1269 coregl_api_glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
1270 {
1271         ovr_glUniform4uiv(location, count, value);
1272 }
1273
1274 void
1275 coregl_api_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
1276 {
1277         ovr_glClearBufferiv(buffer, drawbuffer, value);
1278 }
1279
1280 void
1281 coregl_api_glClearBufferuiv(GLenum buffer, GLint drawbuffer,
1282                             const GLuint *value)
1283 {
1284         ovr_glClearBufferuiv(buffer, drawbuffer, value);
1285 }
1286
1287 void
1288 coregl_api_glClearBufferfv(GLenum buffer, GLint drawbuffer,
1289                            const GLfloat *value)
1290 {
1291         ovr_glClearBufferfv(buffer, drawbuffer, value);
1292 }
1293
1294 void
1295 coregl_api_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth,
1296                            GLint stencil)
1297 {
1298         ovr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
1299 }
1300
1301 const GLubyte *
1302 coregl_api_glGetStringi(GLenum name, GLuint index)
1303 {
1304         return ovr_glGetStringi(name, index);
1305 }
1306
1307 void
1308 coregl_api_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget,
1309                                GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
1310 {
1311         ovr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
1312 }
1313
1314 void
1315 coregl_api_glGetUniformIndices(GLuint program, GLsizei uniformCount,
1316                                const GLchar *const *uniformNames, GLuint *uniformIndices)
1317 {
1318         ovr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
1319 }
1320
1321 void
1322 coregl_api_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
1323                                  const GLuint *uniformIndices, GLenum pname, GLint *params)
1324 {
1325         ovr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1326 }
1327
1328 GLuint
1329 coregl_api_glGetUniformBlockIndex(GLuint program,
1330                                   const GLchar *uniformBlockName)
1331 {
1332         return ovr_glGetUniformBlockIndex(program, uniformBlockName);
1333 }
1334
1335 void
1336 coregl_api_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
1337                                      GLenum pname, GLint *params)
1338 {
1339         ovr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1340 }
1341
1342 void
1343 coregl_api_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
1344                                        GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
1345 {
1346         ovr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
1347                                         uniformBlockName);
1348 }
1349
1350 void
1351 coregl_api_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
1352                                  GLuint uniformBlockBinding)
1353 {
1354         ovr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
1355 }
1356
1357 void
1358 coregl_api_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
1359                                  GLsizei instanceCount)
1360 {
1361         ovr_glDrawArraysInstanced(mode, first, count, instanceCount);
1362 }
1363
1364 void
1365 coregl_api_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
1366                                    const GLvoid *indices, GLsizei instanceCount)
1367 {
1368         ovr_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
1369 }
1370
1371 GLsync
1372 coregl_api_glFenceSync(GLenum condition, GLbitfield flags)
1373 {
1374         return ovr_glFenceSync(condition, flags);
1375 }
1376
1377 GLboolean
1378 coregl_api_glIsSync(GLsync sync)
1379 {
1380         return ovr_glIsSync(sync);
1381 }
1382
1383 void
1384 coregl_api_glDeleteSync(GLsync sync)
1385 {
1386         ovr_glDeleteSync(sync);
1387 }
1388
1389 GLenum
1390 coregl_api_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1391 {
1392         return ovr_glClientWaitSync(sync, flags, timeout);
1393 }
1394
1395 void
1396 coregl_api_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
1397 {
1398         ovr_glWaitSync(sync, flags, timeout);
1399 }
1400
1401 void
1402 coregl_api_glGetInteger64v(GLenum pname, GLint64 *params)
1403 {
1404         ovr_glGetInteger64v(pname, params);
1405 }
1406
1407 void
1408 coregl_api_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize,
1409                        GLsizei *length, GLint *values)
1410 {
1411         ovr_glGetSynciv(sync, pname, bufSize, length, values);
1412 }
1413
1414 void
1415 coregl_api_glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
1416 {
1417         ovr_glGetInteger64i_v(target, index, data);
1418 }
1419
1420 void
1421 coregl_api_glGetBufferParameteri64v(GLenum target, GLenum pname,
1422                                     GLint64 *params)
1423 {
1424         ovr_glGetBufferParameteri64v(target, pname, params);
1425 }
1426
1427 void
1428 coregl_api_glGenSamplers(GLsizei n, GLuint *samplers)
1429 {
1430         ovr_glGenSamplers(n, samplers);
1431 }
1432
1433 void
1434 coregl_api_glDeleteSamplers(GLsizei n, const GLuint *samplers)
1435 {
1436         ovr_glDeleteSamplers(n, samplers);
1437 }
1438
1439 GLboolean
1440 coregl_api_glIsSampler(GLuint sampler)
1441 {
1442         return ovr_glIsSampler(sampler);
1443 }
1444
1445 void
1446 coregl_api_glBindSampler(GLuint unit, GLuint sampler)
1447 {
1448         ovr_glBindSampler(unit, sampler);
1449 }
1450
1451 void
1452 coregl_api_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
1453 {
1454         ovr_glSamplerParameteri(sampler, pname, param);
1455 }
1456
1457 void
1458 coregl_api_glSamplerParameteriv(GLuint sampler, GLenum pname,
1459                                 const GLint *param)
1460 {
1461         ovr_glSamplerParameteriv(sampler, pname, param);
1462 }
1463
1464 void
1465 coregl_api_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
1466 {
1467         ovr_glSamplerParameterf(sampler, pname, param);
1468 }
1469
1470 void
1471 coregl_api_glSamplerParameterfv(GLuint sampler, GLenum pname,
1472                                 const GLfloat *param)
1473 {
1474         ovr_glSamplerParameterfv(sampler, pname, param);
1475 }
1476
1477 void
1478 coregl_api_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
1479 {
1480         ovr_glGetSamplerParameteriv(sampler, pname, params);
1481 }
1482
1483 void
1484 coregl_api_glGetSamplerParameterfv(GLuint sampler, GLenum pname,
1485                                    GLfloat *params)
1486 {
1487         ovr_glGetSamplerParameterfv(sampler, pname, params);
1488 }
1489
1490 void
1491 coregl_api_glVertexAttribDivisor(GLuint index, GLuint divisor)
1492 {
1493         ovr_glVertexAttribDivisor(index, divisor);
1494 }
1495
1496 void
1497 coregl_api_glBindTransformFeedback(GLenum target, GLuint id)
1498 {
1499         ovr_glBindTransformFeedback(target, id);
1500 }
1501
1502 void
1503 coregl_api_glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
1504 {
1505         ovr_glDeleteTransformFeedbacks(n, ids);
1506 }
1507
1508 void
1509 coregl_api_glGenTransformFeedbacks(GLsizei n, GLuint *ids)
1510 {
1511         ovr_glGenTransformFeedbacks(n, ids);
1512 }
1513
1514 GLboolean
1515 coregl_api_glIsTransformFeedback(GLuint id)
1516 {
1517         return ovr_glIsTransformFeedback(id);
1518 }
1519
1520 void
1521 coregl_api_glPauseTransformFeedback()
1522 {
1523         ovr_glPauseTransformFeedback();
1524 }
1525
1526 void
1527 coregl_api_glResumeTransformFeedback()
1528 {
1529         ovr_glResumeTransformFeedback();
1530 }
1531
1532 void
1533 coregl_api_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
1534                               GLenum *binaryFormat, GLvoid *binary)
1535 {
1536         ovr_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
1537 }
1538
1539 void
1540 coregl_api_glProgramBinary(GLuint program, GLenum binaryFormat,
1541                            const GLvoid *binary, GLsizei length)
1542 {
1543         ovr_glProgramBinary(program, binaryFormat, binary, length);
1544 }
1545
1546 void
1547 coregl_api_glProgramParameteri(GLuint program, GLenum pname, GLint value)
1548 {
1549         ovr_glProgramParameteri(program, pname, value);
1550 }
1551
1552 void
1553 coregl_api_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
1554                                    const GLenum *attachments)
1555 {
1556         ovr_glInvalidateFramebuffer(target, numAttachments, attachments);
1557 }
1558
1559 void
1560 coregl_api_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
1561                                       const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
1562 {
1563         ovr_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
1564                                        height);
1565 }
1566
1567 void
1568 coregl_api_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
1569                           GLsizei width, GLsizei height)
1570 {
1571         ovr_glTexStorage2D(target, levels, internalformat, width, height);
1572 }
1573
1574 void
1575 coregl_api_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
1576                           GLsizei width, GLsizei height, GLsizei depth)
1577 {
1578         ovr_glTexStorage3D(target, levels, internalformat, width, height, depth);
1579 }
1580
1581 void
1582 coregl_api_glGetInternalformativ(GLenum target, GLenum internalformat,
1583                                  GLenum pname, GLsizei bufSize, GLint *params)
1584 {
1585         ovr_glGetInternalformativ(target, internalformat, pname, bufSize, params);
1586 }
1587
1588 /* GLES3.1 API */
1589 GLuint
1590 coregl_api_glCreateShaderProgramv(GLenum type,  GLsizei count,
1591                                   const GLchar *const *strings)
1592 {
1593         return ovr_glCreateShaderProgramv(type, count, strings);
1594 }
1595
1596 void
1597 coregl_api_glGenProgramPipelines( GLsizei n,  GLuint *pipelines)
1598 {
1599         ovr_glGenProgramPipelines(n, pipelines);
1600 }
1601
1602 void
1603 coregl_api_glBindProgramPipeline( GLuint pipeline)
1604 {
1605         ovr_glBindProgramPipeline(pipeline);
1606 }
1607
1608 void
1609 coregl_api_glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
1610 {
1611         ovr_glGetProgramPipelineiv(pipeline, pname, params);
1612 }
1613
1614 void
1615 coregl_api_glDeleteProgramPipelines(GLsizei n, GLuint const *pipelines)
1616 {
1617         ovr_glDeleteProgramPipelines(n, pipelines);
1618 }
1619
1620 GLboolean
1621 coregl_api_glIsProgramPipeline( GLuint pipeline)
1622 {
1623         return ovr_glIsProgramPipeline(pipeline);
1624 }
1625
1626 void
1627 coregl_api_glValidateProgramPipeline(GLuint pipeline)
1628 {
1629         ovr_glValidateProgramPipeline(pipeline);
1630 }
1631
1632 void
1633 coregl_api_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
1634                                        GLsizei *length, GLchar *infoLog)
1635 {
1636         ovr_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
1637 }
1638
1639 void
1640 coregl_api_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
1641                              GLuint num_groups_z)
1642 {
1643         ovr_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
1644 }
1645
1646 void
1647 coregl_api_glDispatchComputeIndirect( GLintptr indirect)
1648 {
1649         ovr_glDispatchComputeIndirect(indirect);
1650 }
1651
1652 void
1653 coregl_api_glDrawArraysIndirect(GLenum mode, GLvoid const *indirect)
1654 {
1655         ovr_glDrawArraysIndirect(mode, indirect);
1656 }
1657
1658 void
1659 coregl_api_glDrawElementsIndirect(GLenum mode, GLenum type,
1660                                   GLvoid const *indirect)
1661 {
1662         ovr_glDrawElementsIndirect(mode, type, indirect);
1663 }
1664
1665 void
1666 coregl_api_glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
1667 {
1668         ovr_glFramebufferParameteri(target, pname, param);
1669 }
1670
1671 void
1672 coregl_api_glGetFramebufferParameteriv( GLenum target,  GLenum pname,
1673                                         GLint *params)
1674 {
1675         ovr_glGetFramebufferParameteriv(target,  pname,  params);
1676 }
1677
1678 void
1679 coregl_api_glGetProgramInterfaceiv(GLuint program,  GLenum programInterface,
1680                                    GLenum pname,  GLint *params)
1681 {
1682         ovr_glGetProgramInterfaceiv(program, programInterface, pname, params);
1683 }
1684
1685 GLuint
1686 coregl_api_glGetProgramResourceIndex( GLuint program,  GLenum programInterface,
1687                                       const char *name)
1688 {
1689         return ovr_glGetProgramResourceIndex(program,  programInterface,  name);
1690 }
1691
1692 void
1693 coregl_api_glGetProgramResourceName(GLuint program, GLenum programInterface,
1694                                     GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
1695 {
1696         ovr_glGetProgramResourceName(program, programInterface, index, bufSize, length,
1697                                      name);
1698 }
1699
1700 void
1701 coregl_api_glGetProgramResourceiv( GLuint program,  GLenum programInterface,
1702                                    GLuint index,  GLsizei propCount,  const GLenum *props,  GLsizei bufSize,
1703                                    GLsizei *length,  GLint *params)
1704 {
1705         ovr_glGetProgramResourceiv(program,  programInterface,  index,  propCount,
1706                                    props,  bufSize,  length,  params);
1707 }
1708
1709 GLint
1710 coregl_api_glGetProgramResourceLocation(GLuint program, GLenum programInterface,
1711                                         GLchar const *name)
1712 {
1713         return ovr_glGetProgramResourceLocation(program, programInterface, name);
1714 }
1715
1716 void
1717 coregl_api_glUseProgramStages(GLuint pipeline, GLbitfield stages,
1718                               GLuint program)
1719 {
1720         ovr_glUseProgramStages(pipeline, stages, program);
1721 }
1722
1723 void
1724 coregl_api_glActiveShaderProgram(GLuint pipeline, GLuint program)
1725 {
1726         ovr_glActiveShaderProgram(pipeline, program);
1727 }
1728
1729 void
1730 coregl_api_glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
1731                                const GLint *value)
1732 {
1733         ovr_glProgramUniform1iv(program, location, count, value);
1734 }
1735
1736
1737 void
1738 coregl_api_glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
1739                                const GLint *value)
1740 {
1741         ovr_glProgramUniform2iv(program, location, count, value);
1742 }
1743
1744
1745 void
1746 coregl_api_glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
1747                                const GLint *value)
1748 {
1749         ovr_glProgramUniform3iv(program, location, count, value);
1750 }
1751
1752
1753 void
1754 coregl_api_glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
1755                                const GLint *value)
1756 {
1757         ovr_glProgramUniform4iv(program, location, count, value);
1758 }
1759
1760 void
1761 coregl_api_glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
1762                                const GLfloat *value)
1763 {
1764         ovr_glProgramUniform1fv(program, location, count, value);
1765 }
1766
1767
1768 void
1769 coregl_api_glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
1770                                const GLfloat *value)
1771 {
1772         ovr_glProgramUniform2fv(program, location, count, value);
1773 }
1774
1775
1776 void
1777 coregl_api_glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
1778                                const GLfloat *value)
1779 {
1780         ovr_glProgramUniform3fv(program, location, count, value);
1781 }
1782
1783
1784 void
1785 coregl_api_glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
1786                                const GLfloat *value)
1787 {
1788         ovr_glProgramUniform4fv(program, location, count, value);
1789 }
1790
1791 void
1792 coregl_api_glProgramUniformMatrix2fv(GLuint program, GLint location,
1793                                      GLsizei count, GLboolean transpose, const GLfloat *value)
1794 {
1795         ovr_glProgramUniformMatrix2fv(program, location, count, transpose, value);
1796 }
1797
1798
1799 void
1800 coregl_api_glProgramUniformMatrix3fv(GLuint program, GLint location,
1801                                      GLsizei count, GLboolean transpose, const GLfloat *value)
1802 {
1803         ovr_glProgramUniformMatrix3fv(program, location, count, transpose, value);
1804 }
1805
1806
1807 void
1808 coregl_api_glProgramUniformMatrix4fv(GLuint program, GLint location,
1809                                      GLsizei count, GLboolean transpose, const GLfloat *value)
1810 {
1811         ovr_glProgramUniformMatrix4fv(program, location, count, transpose, value);
1812 }
1813
1814 void
1815 coregl_api_glProgramUniform1i(GLuint program, GLint location, GLint x)
1816 {
1817         ovr_glProgramUniform1i(program, location, x);
1818 }
1819
1820
1821 void
1822 coregl_api_glProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
1823 {
1824         ovr_glProgramUniform2i(program, location, x, y);
1825 }
1826
1827
1828 void
1829 coregl_api_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y,
1830                               GLint z)
1831 {
1832         ovr_glProgramUniform3i(program, location, x, y, z);
1833 }
1834
1835
1836 void
1837 coregl_api_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y,
1838                               GLint z, GLint w)
1839 {
1840         ovr_glProgramUniform4i(program, location, x, y, z, w);
1841 }
1842
1843
1844 void
1845 coregl_api_glProgramUniform1f(GLuint program, GLint location, GLfloat x)
1846 {
1847         ovr_glProgramUniform1f(program, location, x);
1848 }
1849
1850
1851 void
1852 coregl_api_glProgramUniform2f(GLuint program, GLint location, GLfloat x,
1853                               GLfloat y)
1854 {
1855         ovr_glProgramUniform2f(program, location, x, y);
1856 }
1857
1858
1859 void
1860 coregl_api_glProgramUniform3f(GLuint program, GLint location, GLfloat x,
1861                               GLfloat y, GLfloat z)
1862 {
1863         ovr_glProgramUniform3f(program, location, x, y, z);
1864 }
1865
1866
1867 void
1868 coregl_api_glProgramUniform4f(GLuint program, GLint location, GLfloat x,
1869                               GLfloat y, GLfloat z, GLfloat w)
1870 {
1871         ovr_glProgramUniform4f(program, location, x, y, z, w);
1872 }
1873
1874 void
1875 coregl_api_glProgramUniform1ui(GLuint program, GLint location, GLuint x)
1876 {
1877         ovr_glProgramUniform1i(program, location, x);
1878 }
1879
1880 void
1881 coregl_api_glProgramUniform2ui(GLuint program, GLint location, GLuint x,
1882                                GLuint y)
1883 {
1884         ovr_glProgramUniform2ui(program, location, x, y);
1885 }
1886
1887 void
1888 coregl_api_glProgramUniform3ui(GLuint program, GLint location, GLuint x,
1889                                GLuint y, GLuint z)
1890 {
1891         ovr_glProgramUniform3ui(program, location, x, y, z);
1892 }
1893
1894 void
1895 coregl_api_glProgramUniform4ui(GLuint program, GLint location, GLuint x,
1896                                GLuint y, GLuint z, GLuint w)
1897 {
1898         ovr_glProgramUniform4ui(program, location, x, y, z, w);
1899 }
1900
1901 void
1902 coregl_api_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
1903                                 const GLuint *value)
1904 {
1905         ovr_glProgramUniform1uiv(program, location, count, value);
1906 }
1907
1908
1909 void
1910 coregl_api_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
1911                                 const GLuint *value)
1912 {
1913         ovr_glProgramUniform2uiv(program, location, count, value);
1914 }
1915
1916
1917 void
1918 coregl_api_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
1919                                 const GLuint *value)
1920 {
1921         ovr_glProgramUniform3uiv(program, location, count, value);
1922 }
1923
1924
1925 void
1926 coregl_api_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
1927                                 const GLuint *value)
1928 {
1929         ovr_glProgramUniform4uiv(program, location, count, value);
1930 }
1931
1932 void
1933 coregl_api_glProgramUniformMatrix2x3fv(GLuint program, GLint location,
1934                                        GLsizei count, GLboolean transpose, const GLfloat *value)
1935 {
1936         ovr_glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
1937 }
1938
1939 void
1940 coregl_api_glProgramUniformMatrix3x2fv(GLuint program, GLint location,
1941                                        GLsizei count, GLboolean transpose, const GLfloat *value)
1942 {
1943         ovr_glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
1944 }
1945
1946 void
1947 coregl_api_glProgramUniformMatrix2x4fv(GLuint program, GLint location,
1948                                        GLsizei count, GLboolean transpose, const GLfloat *value)
1949 {
1950         ovr_glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
1951 }
1952
1953 void
1954 coregl_api_glProgramUniformMatrix4x2fv(GLuint program, GLint location,
1955                                        GLsizei count, GLboolean transpose, const GLfloat *value)
1956 {
1957         ovr_glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
1958 }
1959
1960 void
1961 coregl_api_glProgramUniformMatrix3x4fv(GLuint program, GLint location,
1962                                        GLsizei count, GLboolean transpose, const GLfloat *value)
1963 {
1964         ovr_glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
1965 }
1966
1967 void
1968 coregl_api_glProgramUniformMatrix4x3fv(GLuint program, GLint location,
1969                                        GLsizei count, GLboolean transpose, const GLfloat *value)
1970 {
1971         ovr_glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
1972 }
1973
1974 void
1975 coregl_api_glBindImageTexture (GLuint unit, GLuint texture, GLint level,
1976                                GLboolean layered, GLint layer, GLenum access, GLenum format)
1977 {
1978         ovr_glBindImageTexture (unit, texture, level, layered, layer, access, format);
1979 }
1980
1981 void
1982 coregl_api_glGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
1983 {
1984         ovr_glGetBooleani_v (target, index, data);
1985 }
1986
1987 void
1988 coregl_api_glMemoryBarrier (GLbitfield barriers)
1989 {
1990         ovr_glMemoryBarrier (barriers);
1991 }
1992
1993 void
1994 coregl_api_glMemoryBarrierByRegion (GLbitfield barriers)
1995 {
1996         ovr_glMemoryBarrierByRegion (barriers);
1997 }
1998
1999 void
2000 coregl_api_glTexStorage2DMultisample (GLenum target, GLsizei samples,
2001                                       GLenum internalformat, GLsizei width, GLsizei height,
2002                                       GLboolean fixedsamplelocations)
2003 {
2004         ovr_glTexStorage2DMultisample (target, samples, internalformat, width, height,
2005                                        fixedsamplelocations);
2006 }
2007
2008 void
2009 coregl_api_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
2010 {
2011         ovr_glGetMultisamplefv (pname, index, val);
2012 }
2013
2014 void
2015 coregl_api_glSampleMaski (GLuint maskNumber, GLbitfield mask)
2016 {
2017         ovr_glSampleMaski (maskNumber, mask);
2018 }
2019
2020 void
2021 coregl_api_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
2022                                      GLint *params)
2023 {
2024         ovr_glGetTexLevelParameteriv (target, level, pname, params);
2025 }
2026
2027 void
2028 coregl_api_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
2029                                      GLfloat *params)
2030 {
2031         ovr_glGetTexLevelParameterfv (target, level, pname, params);
2032 }
2033
2034 void
2035 coregl_api_glBindVertexBuffer (GLuint bindingindex, GLuint buffer,
2036                                GLintptr offset, GLsizei stride)
2037 {
2038         ovr_glBindVertexBuffer (bindingindex, buffer, offset, stride);
2039 }
2040
2041 void
2042 coregl_api_glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type,
2043                                  GLboolean normalized, GLuint relativeoffset)
2044 {
2045         ovr_glVertexAttribFormat (attribindex, size, type, normalized, relativeoffset);
2046 }
2047
2048 void
2049 coregl_api_glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type,
2050                                   GLuint relativeoffset)
2051 {
2052         ovr_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
2053 }
2054
2055 void
2056 coregl_api_glVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
2057 {
2058         ovr_glVertexAttribBinding (attribindex, bindingindex);
2059 }
2060
2061 void
2062 coregl_api_glVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
2063 {
2064         ovr_glVertexBindingDivisor (bindingindex, divisor);
2065 }
2066
2067 void
2068 coregl_api_glGetPointerv(GLenum pname, GLvoid **params)
2069 {
2070         ovr_glGetPointerv(pname, params);
2071 }
2072
2073
2074