-
Notifications
You must be signed in to change notification settings - Fork 7
/
gl.c
1956 lines (1635 loc) · 101 KB
/
gl.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// clang-format off
#include "gl.h"
/* This file was auto-generated by Galogen */
#include <assert.h>
#include "dtrampoline.h"
typedef void * HMODULE;
typedef const char *LPCSTR;
HMODULE LoadLibraryA(LPCSTR lpLibFileName);
static void *
GalogenGetProcAddressWin(const char *name, unsigned arity)
{
static int64_t opengl32module = 0;
static void *(__attribute__((ms_abi)) * wglGetProcAddress)(
LPCSTR name) = 0;
if (!wglGetProcAddress) {
if (!opengl32module) {
opengl32module = (int64_t)LoadLibraryA("opengl32.dll");
}
wglGetProcAddress = GetProcAddress(opengl32module, "wglGetProcAddress");
assert(wglGetProcAddress);
}
void *ptr = wglGetProcAddress(name);
if (ptr == 0 || (ptr == (void *)1) || (ptr == (void *)2) ||
(ptr == (void *)3) || (ptr == (void *)-1)) {
if (opengl32module == 0) {
opengl32module = (int64_t)LoadLibraryA("opengl32.dll");
assert(opengl32module);
}
ptr = GetProcAddress(opengl32module, name);
}
assert(ptr);
return dtrampoline(ptr, arity);
}
#include <dlfcn.h>
static void *
GalogenGetProcAddressA(const char *name, unsigned arity)
{
if (IsWindows())
return GalogenGetProcAddressWin(name, arity);
static void *lib = NULL;
static void *(*glXGetProcAddressARB)() = NULL;
if (NULL == lib) {
lib = dlopen("libGL.so", RTLD_LAZY);
if (!lib)
lib = dlopen("libGL.so.1", RTLD_LAZY);
assert(lib);
glXGetProcAddressARB = dlsym(lib, "glXGetProcAddressARB");
}
return glXGetProcAddressARB(name);
}
static void *
GalogenGetProcAddress(const char *n)
{
return GalogenGetProcAddressA(n, 0);
}
static void GL_APIENTRY _impl_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat * val) {
_glptr_glGetMultisamplefv = (PFN_glGetMultisamplefv)GalogenGetProcAddress("glGetMultisamplefv");
_glptr_glGetMultisamplefv(pname, index, val);
}
PFN_glGetMultisamplefv _glptr_glGetMultisamplefv = _impl_glGetMultisamplefv;
static void GL_APIENTRY _impl_glTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
_glptr_glTexImage3DMultisample = (PFN_glTexImage3DMultisample)GalogenGetProcAddress("glTexImage3DMultisample");
_glptr_glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}
PFN_glTexImage3DMultisample _glptr_glTexImage3DMultisample = _impl_glTexImage3DMultisample;
static void GL_APIENTRY _impl_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level) {
_glptr_glFramebufferTexture = (PFN_glFramebufferTexture)GalogenGetProcAddress("glFramebufferTexture");
_glptr_glFramebufferTexture(target, attachment, texture, level);
}
PFN_glFramebufferTexture _glptr_glFramebufferTexture = _impl_glFramebufferTexture;
static void GL_APIENTRY _impl_glGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 * params) {
_glptr_glGetBufferParameteri64v = (PFN_glGetBufferParameteri64v)GalogenGetProcAddress("glGetBufferParameteri64v");
_glptr_glGetBufferParameteri64v(target, pname, params);
}
PFN_glGetBufferParameteri64v _glptr_glGetBufferParameteri64v = _impl_glGetBufferParameteri64v;
static void GL_APIENTRY _impl_glGetInteger64i_v (GLenum target, GLuint index, GLint64 * data) {
_glptr_glGetInteger64i_v = (PFN_glGetInteger64i_v)GalogenGetProcAddress("glGetInteger64i_v");
_glptr_glGetInteger64i_v(target, index, data);
}
PFN_glGetInteger64i_v _glptr_glGetInteger64i_v = _impl_glGetInteger64i_v;
static void GL_APIENTRY _impl_glWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) {
_glptr_glWaitSync = (PFN_glWaitSync)GalogenGetProcAddress("glWaitSync");
_glptr_glWaitSync(sync, flags, timeout);
}
PFN_glWaitSync _glptr_glWaitSync = _impl_glWaitSync;
static GLboolean GL_APIENTRY _impl_glIsSync (GLsync sync) {
_glptr_glIsSync = (PFN_glIsSync)GalogenGetProcAddress("glIsSync");
return _glptr_glIsSync(sync);
}
PFN_glIsSync _glptr_glIsSync = _impl_glIsSync;
static GLsync GL_APIENTRY _impl_glFenceSync (GLenum condition, GLbitfield flags) {
_glptr_glFenceSync = (PFN_glFenceSync)GalogenGetProcAddress("glFenceSync");
return _glptr_glFenceSync(condition, flags);
}
PFN_glFenceSync _glptr_glFenceSync = _impl_glFenceSync;
static void GL_APIENTRY _impl_glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex) {
_glptr_glMultiDrawElementsBaseVertex = (PFN_glMultiDrawElementsBaseVertex)GalogenGetProcAddress("glMultiDrawElementsBaseVertex");
_glptr_glMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
}
PFN_glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex = _impl_glMultiDrawElementsBaseVertex;
static void GL_APIENTRY _impl_glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex) {
_glptr_glDrawElementsInstancedBaseVertex = (PFN_glDrawElementsInstancedBaseVertex)GalogenGetProcAddress("glDrawElementsInstancedBaseVertex");
_glptr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
}
PFN_glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex = _impl_glDrawElementsInstancedBaseVertex;
static void GL_APIENTRY _impl_glGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName) {
_glptr_glGetActiveUniformBlockName = (PFN_glGetActiveUniformBlockName)GalogenGetProcAddress("glGetActiveUniformBlockName");
_glptr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}
PFN_glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName = _impl_glGetActiveUniformBlockName;
static GLuint GL_APIENTRY _impl_glGetUniformBlockIndex (GLuint program, const GLchar * uniformBlockName) {
_glptr_glGetUniformBlockIndex = (PFN_glGetUniformBlockIndex)GalogenGetProcAddress("glGetUniformBlockIndex");
return _glptr_glGetUniformBlockIndex(program, uniformBlockName);
}
PFN_glGetUniformBlockIndex _glptr_glGetUniformBlockIndex = _impl_glGetUniformBlockIndex;
static void GL_APIENTRY _impl_glGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName) {
_glptr_glGetActiveUniformName = (PFN_glGetActiveUniformName)GalogenGetProcAddress("glGetActiveUniformName");
_glptr_glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
}
PFN_glGetActiveUniformName _glptr_glGetActiveUniformName = _impl_glGetActiveUniformName;
static void GL_APIENTRY _impl_glGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices) {
_glptr_glGetUniformIndices = (PFN_glGetUniformIndices)GalogenGetProcAddress("glGetUniformIndices");
_glptr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}
PFN_glGetUniformIndices _glptr_glGetUniformIndices = _impl_glGetUniformIndices;
static void GL_APIENTRY _impl_glTexBuffer (GLenum target, GLenum internalformat, GLuint buffer) {
_glptr_glTexBuffer = (PFN_glTexBuffer)GalogenGetProcAddress("glTexBuffer");
_glptr_glTexBuffer(target, internalformat, buffer);
}
PFN_glTexBuffer _glptr_glTexBuffer = _impl_glTexBuffer;
static GLboolean GL_APIENTRY _impl_glIsVertexArray (GLuint array) {
_glptr_glIsVertexArray = (PFN_glIsVertexArray)GalogenGetProcAddress("glIsVertexArray");
return _glptr_glIsVertexArray(array);
}
PFN_glIsVertexArray _glptr_glIsVertexArray = _impl_glIsVertexArray;
static void GL_APIENTRY _impl_glBindVertexArray (GLuint array) {
_glptr_glBindVertexArray = (PFN_glBindVertexArray)GalogenGetProcAddress("glBindVertexArray");
_glptr_glBindVertexArray(array);
}
PFN_glBindVertexArray _glptr_glBindVertexArray = _impl_glBindVertexArray;
static void GL_APIENTRY _impl_glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length) {
_glptr_glFlushMappedBufferRange = (PFN_glFlushMappedBufferRange)GalogenGetProcAddress("glFlushMappedBufferRange");
_glptr_glFlushMappedBufferRange(target, offset, length);
}
PFN_glFlushMappedBufferRange _glptr_glFlushMappedBufferRange = _impl_glFlushMappedBufferRange;
static void * GL_APIENTRY _impl_glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
_glptr_glMapBufferRange = (PFN_glMapBufferRange)GalogenGetProcAddress("glMapBufferRange");
return _glptr_glMapBufferRange(target, offset, length, access);
}
PFN_glMapBufferRange _glptr_glMapBufferRange = _impl_glMapBufferRange;
static void GL_APIENTRY _impl_glGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params) {
_glptr_glGetActiveUniformsiv = (PFN_glGetActiveUniformsiv)GalogenGetProcAddress("glGetActiveUniformsiv");
_glptr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}
PFN_glGetActiveUniformsiv _glptr_glGetActiveUniformsiv = _impl_glGetActiveUniformsiv;
static void GL_APIENTRY _impl_glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
_glptr_glFramebufferTextureLayer = (PFN_glFramebufferTextureLayer)GalogenGetProcAddress("glFramebufferTextureLayer");
_glptr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
PFN_glFramebufferTextureLayer _glptr_glFramebufferTextureLayer = _impl_glFramebufferTextureLayer;
static void GL_APIENTRY _impl_glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint * params) {
_glptr_glGetFramebufferAttachmentParameteriv = (PFN_glGetFramebufferAttachmentParameteriv)GalogenGetProcAddress("glGetFramebufferAttachmentParameteriv");
_glptr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
PFN_glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv = _impl_glGetFramebufferAttachmentParameteriv;
static void GL_APIENTRY _impl_glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
_glptr_glFramebufferTexture3D = (PFN_glFramebufferTexture3D)GalogenGetProcAddress("glFramebufferTexture3D");
_glptr_glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
PFN_glFramebufferTexture3D _glptr_glFramebufferTexture3D = _impl_glFramebufferTexture3D;
static void GL_APIENTRY _impl_glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
_glptr_glFramebufferTexture1D = (PFN_glFramebufferTexture1D)GalogenGetProcAddress("glFramebufferTexture1D");
_glptr_glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
PFN_glFramebufferTexture1D _glptr_glFramebufferTexture1D = _impl_glFramebufferTexture1D;
static void GL_APIENTRY _impl_glGenFramebuffers (GLsizei n, GLuint * framebuffers) {
_glptr_glGenFramebuffers = (PFN_glGenFramebuffers)GalogenGetProcAddress("glGenFramebuffers");
_glptr_glGenFramebuffers(n, framebuffers);
}
PFN_glGenFramebuffers _glptr_glGenFramebuffers = _impl_glGenFramebuffers;
static void GL_APIENTRY _impl_glBindFramebuffer (GLenum target, GLuint framebuffer) {
_glptr_glBindFramebuffer = (PFN_glBindFramebuffer)GalogenGetProcAddress("glBindFramebuffer");
_glptr_glBindFramebuffer(target, framebuffer);
}
PFN_glBindFramebuffer _glptr_glBindFramebuffer = _impl_glBindFramebuffer;
static void GL_APIENTRY _impl_glGetInteger64v (GLenum pname, GLint64 * data) {
_glptr_glGetInteger64v = (PFN_glGetInteger64v)GalogenGetProcAddress("glGetInteger64v");
_glptr_glGetInteger64v(pname, data);
}
PFN_glGetInteger64v _glptr_glGetInteger64v = _impl_glGetInteger64v;
static GLboolean GL_APIENTRY _impl_glIsFramebuffer (GLuint framebuffer) {
_glptr_glIsFramebuffer = (PFN_glIsFramebuffer)GalogenGetProcAddress("glIsFramebuffer");
return _glptr_glIsFramebuffer(framebuffer);
}
PFN_glIsFramebuffer _glptr_glIsFramebuffer = _impl_glIsFramebuffer;
static void GL_APIENTRY _impl_glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint * params) {
_glptr_glGetRenderbufferParameteriv = (PFN_glGetRenderbufferParameteriv)GalogenGetProcAddress("glGetRenderbufferParameteriv");
_glptr_glGetRenderbufferParameteriv(target, pname, params);
}
PFN_glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv = _impl_glGetRenderbufferParameteriv;
static void GL_APIENTRY _impl_glBindRenderbuffer (GLenum target, GLuint renderbuffer) {
_glptr_glBindRenderbuffer = (PFN_glBindRenderbuffer)GalogenGetProcAddress("glBindRenderbuffer");
_glptr_glBindRenderbuffer(target, renderbuffer);
}
PFN_glBindRenderbuffer _glptr_glBindRenderbuffer = _impl_glBindRenderbuffer;
static GLboolean GL_APIENTRY _impl_glIsRenderbuffer (GLuint renderbuffer) {
_glptr_glIsRenderbuffer = (PFN_glIsRenderbuffer)GalogenGetProcAddress("glIsRenderbuffer");
return _glptr_glIsRenderbuffer(renderbuffer);
}
PFN_glIsRenderbuffer _glptr_glIsRenderbuffer = _impl_glIsRenderbuffer;
static const GLubyte * GL_APIENTRY _impl_glGetStringi (GLenum name, GLuint index) {
_glptr_glGetStringi = (PFN_glGetStringi)GalogenGetProcAddress("glGetStringi");
return _glptr_glGetStringi(name, index);
}
PFN_glGetStringi _glptr_glGetStringi = _impl_glGetStringi;
static void GL_APIENTRY _impl_glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
_glptr_glClearBufferfi = (PFN_glClearBufferfi)GalogenGetProcAddress("glClearBufferfi");
_glptr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
PFN_glClearBufferfi _glptr_glClearBufferfi = _impl_glClearBufferfi;
static void GL_APIENTRY _impl_glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat * value) {
_glptr_glClearBufferfv = (PFN_glClearBufferfv)GalogenGetProcAddress("glClearBufferfv");
_glptr_glClearBufferfv(buffer, drawbuffer, value);
}
PFN_glClearBufferfv _glptr_glClearBufferfv = _impl_glClearBufferfv;
static void GL_APIENTRY _impl_glGetTexParameterIiv (GLenum target, GLenum pname, GLint * params) {
_glptr_glGetTexParameterIiv = (PFN_glGetTexParameterIiv)GalogenGetProcAddress("glGetTexParameterIiv");
_glptr_glGetTexParameterIiv(target, pname, params);
}
PFN_glGetTexParameterIiv _glptr_glGetTexParameterIiv = _impl_glGetTexParameterIiv;
static void GL_APIENTRY _impl_glTexParameterIiv (GLenum target, GLenum pname, const GLint * params) {
_glptr_glTexParameterIiv = (PFN_glTexParameterIiv)GalogenGetProcAddress("glTexParameterIiv");
_glptr_glTexParameterIiv(target, pname, params);
}
PFN_glTexParameterIiv _glptr_glTexParameterIiv = _impl_glTexParameterIiv;
static void GL_APIENTRY _impl_glUniform4uiv (GLint location, GLsizei count, const GLuint * value) {
_glptr_glUniform4uiv = (PFN_glUniform4uiv)GalogenGetProcAddress("glUniform4uiv");
_glptr_glUniform4uiv(location, count, value);
}
PFN_glUniform4uiv _glptr_glUniform4uiv = _impl_glUniform4uiv;
static void GL_APIENTRY _impl_glUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2) {
_glptr_glUniform3ui = (PFN_glUniform3ui)GalogenGetProcAddress("glUniform3ui");
_glptr_glUniform3ui(location, v0, v1, v2);
}
PFN_glUniform3ui _glptr_glUniform3ui = _impl_glUniform3ui;
static void GL_APIENTRY _impl_glUniform1ui (GLint location, GLuint v0) {
_glptr_glUniform1ui = (PFN_glUniform1ui)GalogenGetProcAddress("glUniform1ui");
_glptr_glUniform1ui(location, v0);
}
PFN_glUniform1ui _glptr_glUniform1ui = _impl_glUniform1ui;
static GLint GL_APIENTRY _impl_glGetFragDataLocation (GLuint program, const GLchar * name) {
_glptr_glGetFragDataLocation = (PFN_glGetFragDataLocation)GalogenGetProcAddress("glGetFragDataLocation");
return _glptr_glGetFragDataLocation(program, name);
}
PFN_glGetFragDataLocation _glptr_glGetFragDataLocation = _impl_glGetFragDataLocation;
static void GL_APIENTRY _impl_glBindFragDataLocation (GLuint program, GLuint color, const GLchar * name) {
_glptr_glBindFragDataLocation = (PFN_glBindFragDataLocation)GalogenGetProcAddress("glBindFragDataLocation");
_glptr_glBindFragDataLocation(program, color, name);
}
PFN_glBindFragDataLocation _glptr_glBindFragDataLocation = _impl_glBindFragDataLocation;
static void GL_APIENTRY _impl_glVertexAttribI4iv (GLuint index, const GLint * v) {
_glptr_glVertexAttribI4iv = (PFN_glVertexAttribI4iv)GalogenGetProcAddress("glVertexAttribI4iv");
_glptr_glVertexAttribI4iv(index, v);
}
PFN_glVertexAttribI4iv _glptr_glVertexAttribI4iv = _impl_glVertexAttribI4iv;
static void GL_APIENTRY _impl_glVertexAttribI2iv (GLuint index, const GLint * v) {
_glptr_glVertexAttribI2iv = (PFN_glVertexAttribI2iv)GalogenGetProcAddress("glVertexAttribI2iv");
_glptr_glVertexAttribI2iv(index, v);
}
PFN_glVertexAttribI2iv _glptr_glVertexAttribI2iv = _impl_glVertexAttribI2iv;
static void GL_APIENTRY _impl_glVertexAttribI1iv (GLuint index, const GLint * v) {
_glptr_glVertexAttribI1iv = (PFN_glVertexAttribI1iv)GalogenGetProcAddress("glVertexAttribI1iv");
_glptr_glVertexAttribI1iv(index, v);
}
PFN_glVertexAttribI1iv _glptr_glVertexAttribI1iv = _impl_glVertexAttribI1iv;
static void GL_APIENTRY _impl_glVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {
_glptr_glVertexAttribI4ui = (PFN_glVertexAttribI4ui)GalogenGetProcAddress("glVertexAttribI4ui");
_glptr_glVertexAttribI4ui(index, x, y, z, w);
}
PFN_glVertexAttribI4ui _glptr_glVertexAttribI4ui = _impl_glVertexAttribI4ui;
static void GL_APIENTRY _impl_glVertexAttribI2ui (GLuint index, GLuint x, GLuint y) {
_glptr_glVertexAttribI2ui = (PFN_glVertexAttribI2ui)GalogenGetProcAddress("glVertexAttribI2ui");
_glptr_glVertexAttribI2ui(index, x, y);
}
PFN_glVertexAttribI2ui _glptr_glVertexAttribI2ui = _impl_glVertexAttribI2ui;
static void GL_APIENTRY _impl_glVertexAttribI1ui (GLuint index, GLuint x) {
_glptr_glVertexAttribI1ui = (PFN_glVertexAttribI1ui)GalogenGetProcAddress("glVertexAttribI1ui");
_glptr_glVertexAttribI1ui(index, x);
}
PFN_glVertexAttribI1ui _glptr_glVertexAttribI1ui = _impl_glVertexAttribI1ui;
static void GL_APIENTRY _impl_glVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w) {
_glptr_glVertexAttribI4i = (PFN_glVertexAttribI4i)GalogenGetProcAddress("glVertexAttribI4i");
_glptr_glVertexAttribI4i(index, x, y, z, w);
}
PFN_glVertexAttribI4i _glptr_glVertexAttribI4i = _impl_glVertexAttribI4i;
static void GL_APIENTRY _impl_glVertexAttribI4bv (GLuint index, const GLbyte * v) {
_glptr_glVertexAttribI4bv = (PFN_glVertexAttribI4bv)GalogenGetProcAddress("glVertexAttribI4bv");
_glptr_glVertexAttribI4bv(index, v);
}
PFN_glVertexAttribI4bv _glptr_glVertexAttribI4bv = _impl_glVertexAttribI4bv;
static void GL_APIENTRY _impl_glVertexAttribI2i (GLuint index, GLint x, GLint y) {
_glptr_glVertexAttribI2i = (PFN_glVertexAttribI2i)GalogenGetProcAddress("glVertexAttribI2i");
_glptr_glVertexAttribI2i(index, x, y);
}
PFN_glVertexAttribI2i _glptr_glVertexAttribI2i = _impl_glVertexAttribI2i;
static void GL_APIENTRY _impl_glVertexAttribI1i (GLuint index, GLint x) {
_glptr_glVertexAttribI1i = (PFN_glVertexAttribI1i)GalogenGetProcAddress("glVertexAttribI1i");
_glptr_glVertexAttribI1i(index, x);
}
PFN_glVertexAttribI1i _glptr_glVertexAttribI1i = _impl_glVertexAttribI1i;
static void GL_APIENTRY _impl_glGetVertexAttribIiv (GLuint index, GLenum pname, GLint * params) {
_glptr_glGetVertexAttribIiv = (PFN_glGetVertexAttribIiv)GalogenGetProcAddress("glGetVertexAttribIiv");
_glptr_glGetVertexAttribIiv(index, pname, params);
}
PFN_glGetVertexAttribIiv _glptr_glGetVertexAttribIiv = _impl_glGetVertexAttribIiv;
static void GL_APIENTRY _impl_glVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) {
_glptr_glVertexAttribIPointer = (PFN_glVertexAttribIPointer)GalogenGetProcAddress("glVertexAttribIPointer");
_glptr_glVertexAttribIPointer(index, size, type, stride, pointer);
}
PFN_glVertexAttribIPointer _glptr_glVertexAttribIPointer = _impl_glVertexAttribIPointer;
static void GL_APIENTRY _impl_glBeginConditionalRender (GLuint id, GLenum mode) {
_glptr_glBeginConditionalRender = (PFN_glBeginConditionalRender)GalogenGetProcAddress("glBeginConditionalRender");
_glptr_glBeginConditionalRender(id, mode);
}
PFN_glBeginConditionalRender _glptr_glBeginConditionalRender = _impl_glBeginConditionalRender;
static void GL_APIENTRY _impl_glClampColor (GLenum target, GLenum clamp) {
_glptr_glClampColor = (PFN_glClampColor)GalogenGetProcAddress("glClampColor");
_glptr_glClampColor(target, clamp);
}
PFN_glClampColor _glptr_glClampColor = _impl_glClampColor;
static void GL_APIENTRY _impl_glBindBufferBase (GLenum target, GLuint index, GLuint buffer) {
_glptr_glBindBufferBase = (PFN_glBindBufferBase)GalogenGetProcAddress("glBindBufferBase");
_glptr_glBindBufferBase(target, index, buffer);
}
PFN_glBindBufferBase _glptr_glBindBufferBase = _impl_glBindBufferBase;
static void GL_APIENTRY _impl_glBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
_glptr_glBindBufferRange = (PFN_glBindBufferRange)GalogenGetProcAddress("glBindBufferRange");
_glptr_glBindBufferRange(target, index, buffer, offset, size);
}
PFN_glBindBufferRange _glptr_glBindBufferRange = _impl_glBindBufferRange;
static void GL_APIENTRY _impl_glBeginTransformFeedback (GLenum primitiveMode) {
_glptr_glBeginTransformFeedback = (PFN_glBeginTransformFeedback)GalogenGetProcAddress("glBeginTransformFeedback");
_glptr_glBeginTransformFeedback(primitiveMode);
}
PFN_glBeginTransformFeedback _glptr_glBeginTransformFeedback = _impl_glBeginTransformFeedback;
static GLboolean GL_APIENTRY _impl_glIsEnabledi (GLenum target, GLuint index) {
_glptr_glIsEnabledi = (PFN_glIsEnabledi)GalogenGetProcAddress("glIsEnabledi");
return _glptr_glIsEnabledi(target, index);
}
PFN_glIsEnabledi _glptr_glIsEnabledi = _impl_glIsEnabledi;
static void GL_APIENTRY _impl_glGetIntegeri_v (GLenum target, GLuint index, GLint * data) {
_glptr_glGetIntegeri_v = (PFN_glGetIntegeri_v)GalogenGetProcAddress("glGetIntegeri_v");
_glptr_glGetIntegeri_v(target, index, data);
}
PFN_glGetIntegeri_v _glptr_glGetIntegeri_v = _impl_glGetIntegeri_v;
static void GL_APIENTRY _impl_glColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
_glptr_glColorMaski = (PFN_glColorMaski)GalogenGetProcAddress("glColorMaski");
_glptr_glColorMaski(index, r, g, b, a);
}
PFN_glColorMaski _glptr_glColorMaski = _impl_glColorMaski;
static void GL_APIENTRY _impl_glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix4x3fv = (PFN_glUniformMatrix4x3fv)GalogenGetProcAddress("glUniformMatrix4x3fv");
_glptr_glUniformMatrix4x3fv(location, count, transpose, value);
}
PFN_glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv = _impl_glUniformMatrix4x3fv;
static void GL_APIENTRY _impl_glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix3x4fv = (PFN_glUniformMatrix3x4fv)GalogenGetProcAddress("glUniformMatrix3x4fv");
_glptr_glUniformMatrix3x4fv(location, count, transpose, value);
}
PFN_glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv = _impl_glUniformMatrix3x4fv;
static void GL_APIENTRY _impl_glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix2x4fv = (PFN_glUniformMatrix2x4fv)GalogenGetProcAddress("glUniformMatrix2x4fv");
_glptr_glUniformMatrix2x4fv(location, count, transpose, value);
}
PFN_glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv = _impl_glUniformMatrix2x4fv;
static void GL_APIENTRY _impl_glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix3x2fv = (PFN_glUniformMatrix3x2fv)GalogenGetProcAddress("glUniformMatrix3x2fv");
_glptr_glUniformMatrix3x2fv(location, count, transpose, value);
}
PFN_glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv = _impl_glUniformMatrix3x2fv;
static void GL_APIENTRY _impl_glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix2x3fv = (PFN_glUniformMatrix2x3fv)GalogenGetProcAddress("glUniformMatrix2x3fv");
_glptr_glUniformMatrix2x3fv(location, count, transpose, value);
}
PFN_glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv = _impl_glUniformMatrix2x3fv;
static void GL_APIENTRY _impl_glVertexAttrib4ubv (GLuint index, const GLubyte * v) {
_glptr_glVertexAttrib4ubv = (PFN_glVertexAttrib4ubv)GalogenGetProcAddress("glVertexAttrib4ubv");
_glptr_glVertexAttrib4ubv(index, v);
}
PFN_glVertexAttrib4ubv _glptr_glVertexAttrib4ubv = _impl_glVertexAttrib4ubv;
static void GL_APIENTRY _impl_glVertexAttrib4sv (GLuint index, const GLshort * v) {
_glptr_glVertexAttrib4sv = (PFN_glVertexAttrib4sv)GalogenGetProcAddress("glVertexAttrib4sv");
_glptr_glVertexAttrib4sv(index, v);
}
PFN_glVertexAttrib4sv _glptr_glVertexAttrib4sv = _impl_glVertexAttrib4sv;
static void GL_APIENTRY _impl_glVertexAttrib4fv (GLuint index, const GLfloat * v) {
_glptr_glVertexAttrib4fv = (PFN_glVertexAttrib4fv)GalogenGetProcAddress("glVertexAttrib4fv");
_glptr_glVertexAttrib4fv(index, v);
}
PFN_glVertexAttrib4fv _glptr_glVertexAttrib4fv = _impl_glVertexAttrib4fv;
static void GL_APIENTRY _impl_glVertexAttrib4Nusv (GLuint index, const GLushort * v) {
_glptr_glVertexAttrib4Nusv = (PFN_glVertexAttrib4Nusv)GalogenGetProcAddress("glVertexAttrib4Nusv");
_glptr_glVertexAttrib4Nusv(index, v);
}
PFN_glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv = _impl_glVertexAttrib4Nusv;
static void GL_APIENTRY _impl_glVertexAttrib4Nuiv (GLuint index, const GLuint * v) {
_glptr_glVertexAttrib4Nuiv = (PFN_glVertexAttrib4Nuiv)GalogenGetProcAddress("glVertexAttrib4Nuiv");
_glptr_glVertexAttrib4Nuiv(index, v);
}
PFN_glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv = _impl_glVertexAttrib4Nuiv;
static void GL_APIENTRY _impl_glVertexAttrib4Nubv (GLuint index, const GLubyte * v) {
_glptr_glVertexAttrib4Nubv = (PFN_glVertexAttrib4Nubv)GalogenGetProcAddress("glVertexAttrib4Nubv");
_glptr_glVertexAttrib4Nubv(index, v);
}
PFN_glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv = _impl_glVertexAttrib4Nubv;
static void GL_APIENTRY _impl_glProvokingVertex (GLenum mode) {
_glptr_glProvokingVertex = (PFN_glProvokingVertex)GalogenGetProcAddress("glProvokingVertex");
_glptr_glProvokingVertex(mode);
}
PFN_glProvokingVertex _glptr_glProvokingVertex = _impl_glProvokingVertex;
static void GL_APIENTRY _impl_glVertexAttrib4Nsv (GLuint index, const GLshort * v) {
_glptr_glVertexAttrib4Nsv = (PFN_glVertexAttrib4Nsv)GalogenGetProcAddress("glVertexAttrib4Nsv");
_glptr_glVertexAttrib4Nsv(index, v);
}
PFN_glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv = _impl_glVertexAttrib4Nsv;
static void GL_APIENTRY _impl_glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z) {
_glptr_glVertexAttrib3f = (PFN_glVertexAttrib3f)GalogenGetProcAddress("glVertexAttrib3f");
_glptr_glVertexAttrib3f(index, x, y, z);
}
PFN_glVertexAttrib3f _glptr_glVertexAttrib3f = _impl_glVertexAttrib3f;
static void GL_APIENTRY _impl_glVertexAttribI1uiv (GLuint index, const GLuint * v) {
_glptr_glVertexAttribI1uiv = (PFN_glVertexAttribI1uiv)GalogenGetProcAddress("glVertexAttribI1uiv");
_glptr_glVertexAttribI1uiv(index, v);
}
PFN_glVertexAttribI1uiv _glptr_glVertexAttribI1uiv = _impl_glVertexAttribI1uiv;
static void GL_APIENTRY _impl_glVertexAttrib3dv (GLuint index, const GLdouble * v) {
_glptr_glVertexAttrib3dv = (PFN_glVertexAttrib3dv)GalogenGetProcAddress("glVertexAttrib3dv");
_glptr_glVertexAttrib3dv(index, v);
}
PFN_glVertexAttrib3dv _glptr_glVertexAttrib3dv = _impl_glVertexAttrib3dv;
static void GL_APIENTRY _impl_glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z) {
_glptr_glVertexAttrib3d = (PFN_glVertexAttrib3d)GalogenGetProcAddress("glVertexAttrib3d");
_glptr_glVertexAttrib3d(index, x, y, z);
}
PFN_glVertexAttrib3d _glptr_glVertexAttrib3d = _impl_glVertexAttrib3d;
static void GL_APIENTRY _impl_glVertexAttrib2sv (GLuint index, const GLshort * v) {
_glptr_glVertexAttrib2sv = (PFN_glVertexAttrib2sv)GalogenGetProcAddress("glVertexAttrib2sv");
_glptr_glVertexAttrib2sv(index, v);
}
PFN_glVertexAttrib2sv _glptr_glVertexAttrib2sv = _impl_glVertexAttrib2sv;
static void GL_APIENTRY _impl_glVertexAttrib2fv (GLuint index, const GLfloat * v) {
_glptr_glVertexAttrib2fv = (PFN_glVertexAttrib2fv)GalogenGetProcAddress("glVertexAttrib2fv");
_glptr_glVertexAttrib2fv(index, v);
}
PFN_glVertexAttrib2fv _glptr_glVertexAttrib2fv = _impl_glVertexAttrib2fv;
static void GL_APIENTRY _impl_glVertexAttrib2dv (GLuint index, const GLdouble * v) {
_glptr_glVertexAttrib2dv = (PFN_glVertexAttrib2dv)GalogenGetProcAddress("glVertexAttrib2dv");
_glptr_glVertexAttrib2dv(index, v);
}
PFN_glVertexAttrib2dv _glptr_glVertexAttrib2dv = _impl_glVertexAttrib2dv;
static void GL_APIENTRY _impl_glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y) {
_glptr_glVertexAttrib2d = (PFN_glVertexAttrib2d)GalogenGetProcAddress("glVertexAttrib2d");
_glptr_glVertexAttrib2d(index, x, y);
}
PFN_glVertexAttrib2d _glptr_glVertexAttrib2d = _impl_glVertexAttrib2d;
static void GL_APIENTRY _impl_glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y) {
_glptr_glVertexAttrib2f = (PFN_glVertexAttrib2f)GalogenGetProcAddress("glVertexAttrib2f");
_glptr_glVertexAttrib2f(index, x, y);
}
PFN_glVertexAttrib2f _glptr_glVertexAttrib2f = _impl_glVertexAttrib2f;
static void GL_APIENTRY _impl_glVertexAttrib1s (GLuint index, GLshort x) {
_glptr_glVertexAttrib1s = (PFN_glVertexAttrib1s)GalogenGetProcAddress("glVertexAttrib1s");
_glptr_glVertexAttrib1s(index, x);
}
PFN_glVertexAttrib1s _glptr_glVertexAttrib1s = _impl_glVertexAttrib1s;
static void GL_APIENTRY _impl_glVertexAttrib1fv (GLuint index, const GLfloat * v) {
_glptr_glVertexAttrib1fv = (PFN_glVertexAttrib1fv)GalogenGetProcAddress("glVertexAttrib1fv");
_glptr_glVertexAttrib1fv(index, v);
}
PFN_glVertexAttrib1fv _glptr_glVertexAttrib1fv = _impl_glVertexAttrib1fv;
static void GL_APIENTRY _impl_glVertexAttrib1f (GLuint index, GLfloat x) {
_glptr_glVertexAttrib1f = (PFN_glVertexAttrib1f)GalogenGetProcAddress("glVertexAttrib1f");
_glptr_glVertexAttrib1f(index, x);
}
PFN_glVertexAttrib1f _glptr_glVertexAttrib1f = _impl_glVertexAttrib1f;
static void GL_APIENTRY _impl_glVertexAttrib1dv (GLuint index, const GLdouble * v) {
_glptr_glVertexAttrib1dv = (PFN_glVertexAttrib1dv)GalogenGetProcAddress("glVertexAttrib1dv");
_glptr_glVertexAttrib1dv(index, v);
}
PFN_glVertexAttrib1dv _glptr_glVertexAttrib1dv = _impl_glVertexAttrib1dv;
static void GL_APIENTRY _impl_glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint * value) {
_glptr_glClearBufferuiv = (PFN_glClearBufferuiv)GalogenGetProcAddress("glClearBufferuiv");
_glptr_glClearBufferuiv(buffer, drawbuffer, value);
}
PFN_glClearBufferuiv _glptr_glClearBufferuiv = _impl_glClearBufferuiv;
static void GL_APIENTRY _impl_glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix3fv = (PFN_glUniformMatrix3fv)GalogenGetProcAddress("glUniformMatrix3fv");
_glptr_glUniformMatrix3fv(location, count, transpose, value);
}
PFN_glUniformMatrix3fv _glptr_glUniformMatrix3fv = _impl_glUniformMatrix3fv;
static void GL_APIENTRY _impl_glDeleteRenderbuffers (GLsizei n, const GLuint * renderbuffers) {
_glptr_glDeleteRenderbuffers = (PFN_glDeleteRenderbuffers)GalogenGetProcAddress("glDeleteRenderbuffers");
_glptr_glDeleteRenderbuffers(n, renderbuffers);
}
PFN_glDeleteRenderbuffers _glptr_glDeleteRenderbuffers = _impl_glDeleteRenderbuffers;
static void GL_APIENTRY _impl_glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix2fv = (PFN_glUniformMatrix2fv)GalogenGetProcAddress("glUniformMatrix2fv");
_glptr_glUniformMatrix2fv(location, count, transpose, value);
}
PFN_glUniformMatrix2fv _glptr_glUniformMatrix2fv = _impl_glUniformMatrix2fv;
static void GL_APIENTRY _impl_glUniform4iv (GLint location, GLsizei count, const GLint * value) {
_glptr_glUniform4iv = (PFN_glUniform4iv)GalogenGetProcAddress("glUniform4iv");
_glptr_glUniform4iv(location, count, value);
}
PFN_glUniform4iv _glptr_glUniform4iv = _impl_glUniform4iv;
static void GL_APIENTRY _impl_glUniform1iv (GLint location, GLsizei count, const GLint * value) {
_glptr_glUniform1iv = (PFN_glUniform1iv)GalogenGetProcAddress("glUniform1iv");
_glptr_glUniform1iv(location, count, value);
}
PFN_glUniform1iv _glptr_glUniform1iv = _impl_glUniform1iv;
static void GL_APIENTRY _impl_glUniform4fv (GLint location, GLsizei count, const GLfloat * value) {
_glptr_glUniform4fv = (PFN_glUniform4fv)GalogenGetProcAddress("glUniform4fv");
_glptr_glUniform4fv(location, count, value);
}
PFN_glUniform4fv _glptr_glUniform4fv = _impl_glUniform4fv;
static void GL_APIENTRY _impl_glUniform2fv (GLint location, GLsizei count, const GLfloat * value) {
_glptr_glUniform2fv = (PFN_glUniform2fv)GalogenGetProcAddress("glUniform2fv");
_glptr_glUniform2fv(location, count, value);
}
PFN_glUniform2fv _glptr_glUniform2fv = _impl_glUniform2fv;
static void GL_APIENTRY _impl_glUniform3i (GLint location, GLint v0, GLint v1, GLint v2) {
_glptr_glUniform3i = (PFN_glUniform3i)GalogenGetProcAddress("glUniform3i");
_glptr_glUniform3i(location, v0, v1, v2);
}
PFN_glUniform3i _glptr_glUniform3i = _impl_glUniform3i;
static void GL_APIENTRY _impl_glUniform2i (GLint location, GLint v0, GLint v1) {
_glptr_glUniform2i = (PFN_glUniform2i)GalogenGetProcAddress("glUniform2i");
_glptr_glUniform2i(location, v0, v1);
}
PFN_glUniform2i _glptr_glUniform2i = _impl_glUniform2i;
static void GL_APIENTRY _impl_glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
_glptr_glUniform4f = (PFN_glUniform4f)GalogenGetProcAddress("glUniform4f");
_glptr_glUniform4f(location, v0, v1, v2, v3);
}
PFN_glUniform4f _glptr_glUniform4f = _impl_glUniform4f;
static void GL_APIENTRY _impl_glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
_glptr_glUniform3f = (PFN_glUniform3f)GalogenGetProcAddress("glUniform3f");
_glptr_glUniform3f(location, v0, v1, v2);
}
PFN_glUniform3f _glptr_glUniform3f = _impl_glUniform3f;
static void GL_APIENTRY _impl_glUniform1f (GLint location, GLfloat v0) {
_glptr_glUniform1f = (PFN_glUniform1f)GalogenGetProcAddress("glUniform1f");
_glptr_glUniform1f(location, v0);
}
PFN_glUniform1f _glptr_glUniform1f = _impl_glUniform1f;
static void GL_APIENTRY _impl_glUseProgram (GLuint program) {
_glptr_glUseProgram = (PFN_glUseProgram)GalogenGetProcAddress("glUseProgram");
_glptr_glUseProgram(program);
}
PFN_glUseProgram _glptr_glUseProgram = _impl_glUseProgram;
static void GL_APIENTRY _impl_glShaderSource (GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length) {
_glptr_glShaderSource = (PFN_glShaderSource)GalogenGetProcAddress("glShaderSource");
_glptr_glShaderSource(shader, count, string, length);
}
PFN_glShaderSource _glptr_glShaderSource = _impl_glShaderSource;
static void GL_APIENTRY _impl_glLinkProgram (GLuint program) {
_glptr_glLinkProgram = (PFN_glLinkProgram)GalogenGetProcAddress("glLinkProgram");
_glptr_glLinkProgram(program);
}
PFN_glLinkProgram _glptr_glLinkProgram = _impl_glLinkProgram;
static GLboolean GL_APIENTRY _impl_glIsShader (GLuint shader) {
_glptr_glIsShader = (PFN_glIsShader)GalogenGetProcAddress("glIsShader");
return _glptr_glIsShader(shader);
}
PFN_glIsShader _glptr_glIsShader = _impl_glIsShader;
static void GL_APIENTRY _impl_glGetVertexAttribPointerv (GLuint index, GLenum pname, void ** pointer) {
_glptr_glGetVertexAttribPointerv = (PFN_glGetVertexAttribPointerv)GalogenGetProcAddress("glGetVertexAttribPointerv");
_glptr_glGetVertexAttribPointerv(index, pname, pointer);
}
PFN_glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv = _impl_glGetVertexAttribPointerv;
static void GL_APIENTRY _impl_glGetVertexAttribiv (GLuint index, GLenum pname, GLint * params) {
_glptr_glGetVertexAttribiv = (PFN_glGetVertexAttribiv)GalogenGetProcAddress("glGetVertexAttribiv");
_glptr_glGetVertexAttribiv(index, pname, params);
}
PFN_glGetVertexAttribiv _glptr_glGetVertexAttribiv = _impl_glGetVertexAttribiv;
static void GL_APIENTRY _impl_glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat * params) {
_glptr_glGetVertexAttribfv = (PFN_glGetVertexAttribfv)GalogenGetProcAddress("glGetVertexAttribfv");
_glptr_glGetVertexAttribfv(index, pname, params);
}
PFN_glGetVertexAttribfv _glptr_glGetVertexAttribfv = _impl_glGetVertexAttribfv;
static void GL_APIENTRY _impl_glUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
_glptr_glUniformBlockBinding = (PFN_glUniformBlockBinding)GalogenGetProcAddress("glUniformBlockBinding");
_glptr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
PFN_glUniformBlockBinding _glptr_glUniformBlockBinding = _impl_glUniformBlockBinding;
static GLint GL_APIENTRY _impl_glGetUniformLocation (GLuint program, const GLchar * name) {
_glptr_glGetUniformLocation = (PFN_glGetUniformLocation)GalogenGetProcAddress("glGetUniformLocation");
return _glptr_glGetUniformLocation(program, name);
}
PFN_glGetUniformLocation _glptr_glGetUniformLocation = _impl_glGetUniformLocation;
static void GL_APIENTRY _impl_glGetShaderiv (GLuint shader, GLenum pname, GLint * params) {
_glptr_glGetShaderiv = (PFN_glGetShaderiv)GalogenGetProcAddress("glGetShaderiv");
_glptr_glGetShaderiv(shader, pname, params);
}
PFN_glGetShaderiv _glptr_glGetShaderiv = _impl_glGetShaderiv;
static void GL_APIENTRY _impl_glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {
_glptr_glGetProgramInfoLog = (PFN_glGetProgramInfoLog)GalogenGetProcAddress("glGetProgramInfoLog");
_glptr_glGetProgramInfoLog(program, bufSize, length, infoLog);
}
PFN_glGetProgramInfoLog _glptr_glGetProgramInfoLog = _impl_glGetProgramInfoLog;
static GLint GL_APIENTRY _impl_glGetAttribLocation (GLuint program, const GLchar * name) {
_glptr_glGetAttribLocation = (PFN_glGetAttribLocation)GalogenGetProcAddress("glGetAttribLocation");
return _glptr_glGetAttribLocation(program, name);
}
PFN_glGetAttribLocation _glptr_glGetAttribLocation = _impl_glGetAttribLocation;
static void GL_APIENTRY _impl_glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders) {
_glptr_glGetAttachedShaders = (PFN_glGetAttachedShaders)GalogenGetProcAddress("glGetAttachedShaders");
_glptr_glGetAttachedShaders(program, maxCount, count, shaders);
}
PFN_glGetAttachedShaders _glptr_glGetAttachedShaders = _impl_glGetAttachedShaders;
static void GL_APIENTRY _impl_glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {
_glptr_glGetActiveUniform = (PFN_glGetActiveUniform)GalogenGetProcAddress("glGetActiveUniform");
_glptr_glGetActiveUniform(program, index, bufSize, length, size, type, name);
}
PFN_glGetActiveUniform _glptr_glGetActiveUniform = _impl_glGetActiveUniform;
static void GL_APIENTRY _impl_glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {
_glptr_glGetActiveAttrib = (PFN_glGetActiveAttrib)GalogenGetProcAddress("glGetActiveAttrib");
_glptr_glGetActiveAttrib(program, index, bufSize, length, size, type, name);
}
PFN_glGetActiveAttrib _glptr_glGetActiveAttrib = _impl_glGetActiveAttrib;
static void GL_APIENTRY _impl_glVertexAttrib4iv (GLuint index, const GLint * v) {
_glptr_glVertexAttrib4iv = (PFN_glVertexAttrib4iv)GalogenGetProcAddress("glVertexAttrib4iv");
_glptr_glVertexAttrib4iv(index, v);
}
PFN_glVertexAttrib4iv _glptr_glVertexAttrib4iv = _impl_glVertexAttrib4iv;
static void GL_APIENTRY _impl_glDisableVertexAttribArray (GLuint index) {
_glptr_glDisableVertexAttribArray = (PFN_glDisableVertexAttribArray)GalogenGetProcAddress("glDisableVertexAttribArray");
_glptr_glDisableVertexAttribArray(index);
}
PFN_glDisableVertexAttribArray _glptr_glDisableVertexAttribArray = _impl_glDisableVertexAttribArray;
static void GL_APIENTRY _impl_glDeleteShader (GLuint shader) {
_glptr_glDeleteShader = (PFN_glDeleteShader)GalogenGetProcAddress("glDeleteShader");
_glptr_glDeleteShader(shader);
}
PFN_glDeleteShader _glptr_glDeleteShader = _impl_glDeleteShader;
static void GL_APIENTRY _impl_glDeleteProgram (GLuint program) {
_glptr_glDeleteProgram = (PFN_glDeleteProgram)GalogenGetProcAddress("glDeleteProgram");
_glptr_glDeleteProgram(program);
}
PFN_glDeleteProgram _glptr_glDeleteProgram = _impl_glDeleteProgram;
static void GL_APIENTRY _impl_glGetBooleani_v (GLenum target, GLuint index, GLboolean * data) {
_glptr_glGetBooleani_v = (PFN_glGetBooleani_v)GalogenGetProcAddress("glGetBooleani_v");
_glptr_glGetBooleani_v(target, index, data);
}
PFN_glGetBooleani_v _glptr_glGetBooleani_v = _impl_glGetBooleani_v;
static void GL_APIENTRY _impl_glCompileShader (GLuint shader) {
_glptr_glCompileShader = (PFN_glCompileShader)GalogenGetProcAddress("glCompileShader");
_glptr_glCompileShader(shader);
}
PFN_glCompileShader _glptr_glCompileShader = _impl_glCompileShader;
static void GL_APIENTRY _impl_glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask) {
_glptr_glStencilFuncSeparate = (PFN_glStencilFuncSeparate)GalogenGetProcAddress("glStencilFuncSeparate");
_glptr_glStencilFuncSeparate(face, func, ref, mask);
}
PFN_glStencilFuncSeparate _glptr_glStencilFuncSeparate = _impl_glStencilFuncSeparate;
static void GL_APIENTRY _impl_glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
_glptr_glStencilOpSeparate = (PFN_glStencilOpSeparate)GalogenGetProcAddress("glStencilOpSeparate");
_glptr_glStencilOpSeparate(face, sfail, dpfail, dppass);
}
PFN_glStencilOpSeparate _glptr_glStencilOpSeparate = _impl_glStencilOpSeparate;
static void GL_APIENTRY _impl_glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
_glptr_glRenderbufferStorageMultisample = (PFN_glRenderbufferStorageMultisample)GalogenGetProcAddress("glRenderbufferStorageMultisample");
_glptr_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
PFN_glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample = _impl_glRenderbufferStorageMultisample;
static void GL_APIENTRY _impl_glDrawBuffers (GLsizei n, const GLenum * bufs) {
_glptr_glDrawBuffers = (PFN_glDrawBuffers)GalogenGetProcAddress("glDrawBuffers");
_glptr_glDrawBuffers(n, bufs);
}
PFN_glDrawBuffers _glptr_glDrawBuffers = _impl_glDrawBuffers;
static void GL_APIENTRY _impl_glGetBufferParameteriv (GLenum target, GLenum pname, GLint * params) {
_glptr_glGetBufferParameteriv = (PFN_glGetBufferParameteriv)GalogenGetProcAddress("glGetBufferParameteriv");
_glptr_glGetBufferParameteriv(target, pname, params);
}
PFN_glGetBufferParameteriv _glptr_glGetBufferParameteriv = _impl_glGetBufferParameteriv;
static GLboolean GL_APIENTRY _impl_glUnmapBuffer (GLenum target) {
_glptr_glUnmapBuffer = (PFN_glUnmapBuffer)GalogenGetProcAddress("glUnmapBuffer");
return _glptr_glUnmapBuffer(target);
}
PFN_glUnmapBuffer _glptr_glUnmapBuffer = _impl_glUnmapBuffer;
static void GL_APIENTRY _impl_glVertexAttrib4dv (GLuint index, const GLdouble * v) {
_glptr_glVertexAttrib4dv = (PFN_glVertexAttrib4dv)GalogenGetProcAddress("glVertexAttrib4dv");
_glptr_glVertexAttrib4dv(index, v);
}
PFN_glVertexAttrib4dv _glptr_glVertexAttrib4dv = _impl_glVertexAttrib4dv;
static void * GL_APIENTRY _impl_glMapBuffer (GLenum target, GLenum access) {
_glptr_glMapBuffer = (PFN_glMapBuffer)GalogenGetProcAddress("glMapBuffer");
return _glptr_glMapBuffer(target, access);
}
PFN_glMapBuffer _glptr_glMapBuffer = _impl_glMapBuffer;
static void GL_APIENTRY _impl_glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void * data) {
_glptr_glBufferSubData = (PFN_glBufferSubData)GalogenGetProcAddress("glBufferSubData");
_glptr_glBufferSubData(target, offset, size, data);
}
PFN_glBufferSubData _glptr_glBufferSubData = _impl_glBufferSubData;
static void GL_APIENTRY _impl_glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint * params) {
_glptr_glGetQueryObjectuiv = (PFN_glGetQueryObjectuiv)GalogenGetProcAddress("glGetQueryObjectuiv");
_glptr_glGetQueryObjectuiv(id, pname, params);
}
PFN_glGetQueryObjectuiv _glptr_glGetQueryObjectuiv = _impl_glGetQueryObjectuiv;
static void GL_APIENTRY _impl_glGetQueryObjectiv (GLuint id, GLenum pname, GLint * params) {
_glptr_glGetQueryObjectiv = (PFN_glGetQueryObjectiv)GalogenGetProcAddress("glGetQueryObjectiv");
_glptr_glGetQueryObjectiv(id, pname, params);
}
PFN_glGetQueryObjectiv _glptr_glGetQueryObjectiv = _impl_glGetQueryObjectiv;
static GLboolean GL_APIENTRY _impl_glIsQuery (GLuint id) {
_glptr_glIsQuery = (PFN_glIsQuery)GalogenGetProcAddress("glIsQuery");
return _glptr_glIsQuery(id);
}
PFN_glIsQuery _glptr_glIsQuery = _impl_glIsQuery;
static void GL_APIENTRY _impl_glDeleteQueries (GLsizei n, const GLuint * ids) {
_glptr_glDeleteQueries = (PFN_glDeleteQueries)GalogenGetProcAddress("glDeleteQueries");
_glptr_glDeleteQueries(n, ids);
}
PFN_glDeleteQueries _glptr_glDeleteQueries = _impl_glDeleteQueries;
static void GL_APIENTRY _impl_glGenQueries (GLsizei n, GLuint * ids) {
_glptr_glGenQueries = (PFN_glGenQueries)GalogenGetProcAddress("glGenQueries");
_glptr_glGenQueries(n, ids);
}
PFN_glGenQueries _glptr_glGenQueries = _impl_glGenQueries;
static void GL_APIENTRY _impl_glBlendEquation (GLenum mode) {
_glptr_glBlendEquation = (PFN_glBlendEquation)GalogenGetProcAddress("glBlendEquation");
_glptr_glBlendEquation(mode);
}
PFN_glBlendEquation _glptr_glBlendEquation = _impl_glBlendEquation;
static void GL_APIENTRY _impl_glVertexAttrib3sv (GLuint index, const GLshort * v) {
_glptr_glVertexAttrib3sv = (PFN_glVertexAttrib3sv)GalogenGetProcAddress("glVertexAttrib3sv");
_glptr_glVertexAttrib3sv(index, v);
}
PFN_glVertexAttrib3sv _glptr_glVertexAttrib3sv = _impl_glVertexAttrib3sv;
static void GL_APIENTRY _impl_glVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z) {
_glptr_glVertexAttribI3ui = (PFN_glVertexAttribI3ui)GalogenGetProcAddress("glVertexAttribI3ui");
_glptr_glVertexAttribI3ui(index, x, y, z);
}
PFN_glVertexAttribI3ui _glptr_glVertexAttribI3ui = _impl_glVertexAttribI3ui;
static void GL_APIENTRY _impl_glGenBuffers (GLsizei n, GLuint * buffers) {
_glptr_glGenBuffers = (PFN_glGenBuffers)GalogenGetProcAddress("glGenBuffers");
_glptr_glGenBuffers(n, buffers);
}
PFN_glGenBuffers _glptr_glGenBuffers = _impl_glGenBuffers;
static GLenum GL_APIENTRY _impl_glCheckFramebufferStatus (GLenum target) {
_glptr_glCheckFramebufferStatus = (PFN_glCheckFramebufferStatus)GalogenGetProcAddress("glCheckFramebufferStatus");
return _glptr_glCheckFramebufferStatus(target);
}
PFN_glCheckFramebufferStatus _glptr_glCheckFramebufferStatus = _impl_glCheckFramebufferStatus;
static void GL_APIENTRY _impl_glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
_glptr_glUniform4i = (PFN_glUniform4i)GalogenGetProcAddress("glUniform4i");
_glptr_glUniform4i(location, v0, v1, v2, v3);
}
PFN_glUniform4i _glptr_glUniform4i = _impl_glUniform4i;
static void GL_APIENTRY _impl_glPointParameteriv (GLenum pname, const GLint * params) {
_glptr_glPointParameteriv = (PFN_glPointParameteriv)GalogenGetProcAddress("glPointParameteriv");
_glptr_glPointParameteriv(pname, params);
}
PFN_glPointParameteriv _glptr_glPointParameteriv = _impl_glPointParameteriv;
static void GL_APIENTRY _impl_glVertexAttrib2s (GLuint index, GLshort x, GLshort y) {
_glptr_glVertexAttrib2s = (PFN_glVertexAttrib2s)GalogenGetProcAddress("glVertexAttrib2s");
_glptr_glVertexAttrib2s(index, x, y);
}
PFN_glVertexAttrib2s _glptr_glVertexAttrib2s = _impl_glVertexAttrib2s;
static void GL_APIENTRY _impl_glFinish () {
_glptr_glFinish = (PFN_glFinish)GalogenGetProcAddress("glFinish");
_glptr_glFinish();
}
PFN_glFinish _glptr_glFinish = _impl_glFinish;
static void GL_APIENTRY _impl_glPointParameteri (GLenum pname, GLint param) {
_glptr_glPointParameteri = (PFN_glPointParameteri)GalogenGetProcAddress("glPointParameteri");
_glptr_glPointParameteri(pname, param);
}
PFN_glPointParameteri _glptr_glPointParameteri = _impl_glPointParameteri;
static void GL_APIENTRY _impl_glMultiDrawArrays (GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount) {
_glptr_glMultiDrawArrays = (PFN_glMultiDrawArrays)GalogenGetProcAddress("glMultiDrawArrays");
_glptr_glMultiDrawArrays(mode, first, count, drawcount);
}
PFN_glMultiDrawArrays _glptr_glMultiDrawArrays = _impl_glMultiDrawArrays;
static void GL_APIENTRY _impl_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
_glptr_glFramebufferRenderbuffer = (PFN_glFramebufferRenderbuffer)GalogenGetProcAddress("glFramebufferRenderbuffer");
_glptr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
PFN_glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer = _impl_glFramebufferRenderbuffer;
static void GL_APIENTRY _impl_glGetQueryiv (GLenum target, GLenum pname, GLint * params) {
_glptr_glGetQueryiv = (PFN_glGetQueryiv)GalogenGetProcAddress("glGetQueryiv");
_glptr_glGetQueryiv(target, pname, params);
}
PFN_glGetQueryiv _glptr_glGetQueryiv = _impl_glGetQueryiv;
static void GL_APIENTRY _impl_glGetUniformfv (GLuint program, GLint location, GLfloat * params) {
_glptr_glGetUniformfv = (PFN_glGetUniformfv)GalogenGetProcAddress("glGetUniformfv");
_glptr_glGetUniformfv(program, location, params);
}
PFN_glGetUniformfv _glptr_glGetUniformfv = _impl_glGetUniformfv;
static void GL_APIENTRY _impl_glVertexAttrib4usv (GLuint index, const GLushort * v) {
_glptr_glVertexAttrib4usv = (PFN_glVertexAttrib4usv)GalogenGetProcAddress("glVertexAttrib4usv");
_glptr_glVertexAttrib4usv(index, v);
}
PFN_glVertexAttrib4usv _glptr_glVertexAttrib4usv = _impl_glVertexAttrib4usv;
static void GL_APIENTRY _impl_glDeleteSync (GLsync sync) {
_glptr_glDeleteSync = (PFN_glDeleteSync)GalogenGetProcAddress("glDeleteSync");
_glptr_glDeleteSync(sync);
}
PFN_glDeleteSync _glptr_glDeleteSync = _impl_glDeleteSync;
static void GL_APIENTRY _impl_glGetCompressedTexImage (GLenum target, GLint level, void * img) {
_glptr_glGetCompressedTexImage = (PFN_glGetCompressedTexImage)GalogenGetProcAddress("glGetCompressedTexImage");
_glptr_glGetCompressedTexImage(target, level, img);
}
PFN_glGetCompressedTexImage _glptr_glGetCompressedTexImage = _impl_glGetCompressedTexImage;
static void GL_APIENTRY _impl_glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) {
_glptr_glCompressedTexSubImage2D = (PFN_glCompressedTexSubImage2D)GalogenGetProcAddress("glCompressedTexSubImage2D");
_glptr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
PFN_glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D = _impl_glCompressedTexSubImage2D;
static void GL_APIENTRY _impl_glUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
_glptr_glUniform4ui = (PFN_glUniform4ui)GalogenGetProcAddress("glUniform4ui");
_glptr_glUniform4ui(location, v0, v1, v2, v3);
}
PFN_glUniform4ui _glptr_glUniform4ui = _impl_glUniform4ui;
static void GL_APIENTRY _impl_glVertexAttribI4usv (GLuint index, const GLushort * v) {
_glptr_glVertexAttribI4usv = (PFN_glVertexAttribI4usv)GalogenGetProcAddress("glVertexAttribI4usv");
_glptr_glVertexAttribI4usv(index, v);
}
PFN_glVertexAttribI4usv _glptr_glVertexAttribI4usv = _impl_glVertexAttribI4usv;
static void GL_APIENTRY _impl_glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data) {
_glptr_glCompressedTexImage2D = (PFN_glCompressedTexImage2D)GalogenGetProcAddress("glCompressedTexImage2D");
_glptr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
PFN_glCompressedTexImage2D _glptr_glCompressedTexImage2D = _impl_glCompressedTexImage2D;
static void GL_APIENTRY _impl_glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data) {
_glptr_glCompressedTexImage3D = (PFN_glCompressedTexImage3D)GalogenGetProcAddress("glCompressedTexImage3D");
_glptr_glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);