-
Notifications
You must be signed in to change notification settings - Fork 3
/
Copy pathgl33.c
4687 lines (3910 loc) · 224 KB
/
gl33.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
#include "gl33.h"
#include <Windows.h>
/* This file was auto-generated by Galogen */
#include <assert.h>
#if defined(_WIN32)
void* GalogenGetProcAddress(const char *name) {
static HMODULE opengl32module = NULL;
static PROC(WINAPI *wgl_get_proc_address)(LPCSTR name) = NULL;
if (!wgl_get_proc_address) {
if (!opengl32module) {
//opengl32module = LoadLibraryA("opengl32.dll");
opengl32module = GetModuleHandleA("opengl32.dll");
}
wgl_get_proc_address = (PROC(WINAPI*)(LPCSTR))GetProcAddress(opengl32module, "wglGetProcAddress");
assert(wgl_get_proc_address);
}
void *ptr = (void *)wgl_get_proc_address(name);
if(ptr == 0 || (ptr == (void*)1) || (ptr == (void*)2) || (ptr == (void*)3) ||
(ptr == (void*)-1) ) {
if (opengl32module == NULL) {
opengl32module = LoadLibraryA("opengl32.dll");
assert(opengl32module);
}
ptr = (void *)GetProcAddress(opengl32module, name);
}
return ptr;
}
#elif defined(__APPLE__)
#include <dlfcn.h>
static void* GalogenGetProcAddress (const char *name)
{
static void* lib = NULL;
if (NULL == lib)
lib = dlopen(
"/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL",
RTLD_LAZY);
return lib ? dlsym(lib, name) : NULL;
}
#elif defined(__ANDROID__)
#include <dlfcn.h>
#if GALOGEN_API_VER_MAJ == 3
#define GALOGEN_GLES_LIB "libGLESv3.so"
#elif GALOGEN_API_VER_MAJ == 2
#define GALOGEN_GLES_LIB "libGLESv2.so"
#else
#define GALOGEN_GLES_LIB "libGLESv1_CM.so"
#endif
static void* GalogenGetProcAddress(const char *name)
{
static void* lib = NULL;
if (NULL == lib) {
lib = dlopen(GALOGEN_GLES_LIB, RTLD_LAZY);
assert(lib);
}
return lib ? dlsym(lib, name) : NULL;
}
#else
#include <GL/glx.h>
#define GalogenGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
#endif
static void GL_APIENTRY _impl_glEndQueryIndexed (GLenum target, GLuint index) {
_glptr_glEndQueryIndexed = (PFN_glEndQueryIndexed)GalogenGetProcAddress("glEndQueryIndexed");
_glptr_glEndQueryIndexed(target, index);
}
PFN_glEndQueryIndexed _glptr_glEndQueryIndexed = _impl_glEndQueryIndexed;
static void GL_APIENTRY _impl_glDrawTransformFeedback (GLenum mode, GLuint id) {
_glptr_glDrawTransformFeedback = (PFN_glDrawTransformFeedback)GalogenGetProcAddress("glDrawTransformFeedback");
_glptr_glDrawTransformFeedback(mode, id);
}
PFN_glDrawTransformFeedback _glptr_glDrawTransformFeedback = _impl_glDrawTransformFeedback;
static GLboolean GL_APIENTRY _impl_glIsTransformFeedback (GLuint id) {
_glptr_glIsTransformFeedback = (PFN_glIsTransformFeedback)GalogenGetProcAddress("glIsTransformFeedback");
return _glptr_glIsTransformFeedback(id);
}
PFN_glIsTransformFeedback _glptr_glIsTransformFeedback = _impl_glIsTransformFeedback;
static void GL_APIENTRY _impl_glGenTransformFeedbacks (GLsizei n, GLuint * ids) {
_glptr_glGenTransformFeedbacks = (PFN_glGenTransformFeedbacks)GalogenGetProcAddress("glGenTransformFeedbacks");
_glptr_glGenTransformFeedbacks(n, ids);
}
PFN_glGenTransformFeedbacks _glptr_glGenTransformFeedbacks = _impl_glGenTransformFeedbacks;
static void GL_APIENTRY _impl_glDeleteTransformFeedbacks (GLsizei n, const GLuint * ids) {
_glptr_glDeleteTransformFeedbacks = (PFN_glDeleteTransformFeedbacks)GalogenGetProcAddress("glDeleteTransformFeedbacks");
_glptr_glDeleteTransformFeedbacks(n, ids);
}
PFN_glDeleteTransformFeedbacks _glptr_glDeleteTransformFeedbacks = _impl_glDeleteTransformFeedbacks;
static void GL_APIENTRY _impl_glPatchParameterfv (GLenum pname, const GLfloat * values) {
_glptr_glPatchParameterfv = (PFN_glPatchParameterfv)GalogenGetProcAddress("glPatchParameterfv");
_glptr_glPatchParameterfv(pname, values);
}
PFN_glPatchParameterfv _glptr_glPatchParameterfv = _impl_glPatchParameterfv;
static void GL_APIENTRY _impl_glPatchParameteri (GLenum pname, GLint value) {
_glptr_glPatchParameteri = (PFN_glPatchParameteri)GalogenGetProcAddress("glPatchParameteri");
_glptr_glPatchParameteri(pname, value);
}
PFN_glPatchParameteri _glptr_glPatchParameteri = _impl_glPatchParameteri;
static void GL_APIENTRY _impl_glGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint * values) {
_glptr_glGetProgramStageiv = (PFN_glGetProgramStageiv)GalogenGetProcAddress("glGetProgramStageiv");
_glptr_glGetProgramStageiv(program, shadertype, pname, values);
}
PFN_glGetProgramStageiv _glptr_glGetProgramStageiv = _impl_glGetProgramStageiv;
static void GL_APIENTRY _impl_glGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name) {
_glptr_glGetActiveSubroutineName = (PFN_glGetActiveSubroutineName)GalogenGetProcAddress("glGetActiveSubroutineName");
_glptr_glGetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}
PFN_glGetActiveSubroutineName _glptr_glGetActiveSubroutineName = _impl_glGetActiveSubroutineName;
static GLuint GL_APIENTRY _impl_glGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar * name) {
_glptr_glGetSubroutineIndex = (PFN_glGetSubroutineIndex)GalogenGetProcAddress("glGetSubroutineIndex");
return _glptr_glGetSubroutineIndex(program, shadertype, name);
}
PFN_glGetSubroutineIndex _glptr_glGetSubroutineIndex = _impl_glGetSubroutineIndex;
static GLint GL_APIENTRY _impl_glGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar * name) {
_glptr_glGetSubroutineUniformLocation = (PFN_glGetSubroutineUniformLocation)GalogenGetProcAddress("glGetSubroutineUniformLocation");
return _glptr_glGetSubroutineUniformLocation(program, shadertype, name);
}
PFN_glGetSubroutineUniformLocation _glptr_glGetSubroutineUniformLocation = _impl_glGetSubroutineUniformLocation;
static void GL_APIENTRY _impl_glUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
_glptr_glUniformMatrix2x4dv = (PFN_glUniformMatrix2x4dv)GalogenGetProcAddress("glUniformMatrix2x4dv");
_glptr_glUniformMatrix2x4dv(location, count, transpose, value);
}
PFN_glUniformMatrix2x4dv _glptr_glUniformMatrix2x4dv = _impl_glUniformMatrix2x4dv;
static void GL_APIENTRY _impl_glUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
_glptr_glUniformMatrix3dv = (PFN_glUniformMatrix3dv)GalogenGetProcAddress("glUniformMatrix3dv");
_glptr_glUniformMatrix3dv(location, count, transpose, value);
}
PFN_glUniformMatrix3dv _glptr_glUniformMatrix3dv = _impl_glUniformMatrix3dv;
static void GL_APIENTRY _impl_glUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
_glptr_glUniformMatrix2dv = (PFN_glUniformMatrix2dv)GalogenGetProcAddress("glUniformMatrix2dv");
_glptr_glUniformMatrix2dv(location, count, transpose, value);
}
PFN_glUniformMatrix2dv _glptr_glUniformMatrix2dv = _impl_glUniformMatrix2dv;
static void GL_APIENTRY _impl_glUniform4dv (GLint location, GLsizei count, const GLdouble * value) {
_glptr_glUniform4dv = (PFN_glUniform4dv)GalogenGetProcAddress("glUniform4dv");
_glptr_glUniform4dv(location, count, value);
}
PFN_glUniform4dv _glptr_glUniform4dv = _impl_glUniform4dv;
static void GL_APIENTRY _impl_glUniform1dv (GLint location, GLsizei count, const GLdouble * value) {
_glptr_glUniform1dv = (PFN_glUniform1dv)GalogenGetProcAddress("glUniform1dv");
_glptr_glUniform1dv(location, count, value);
}
PFN_glUniform1dv _glptr_glUniform1dv = _impl_glUniform1dv;
static void GL_APIENTRY _impl_glUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z) {
_glptr_glUniform3d = (PFN_glUniform3d)GalogenGetProcAddress("glUniform3d");
_glptr_glUniform3d(location, x, y, z);
}
PFN_glUniform3d _glptr_glUniform3d = _impl_glUniform3d;
static void GL_APIENTRY _impl_glUniform2d (GLint location, GLdouble x, GLdouble y) {
_glptr_glUniform2d = (PFN_glUniform2d)GalogenGetProcAddress("glUniform2d");
_glptr_glUniform2d(location, x, y);
}
PFN_glUniform2d _glptr_glUniform2d = _impl_glUniform2d;
static void GL_APIENTRY _impl_glUniform1d (GLint location, GLdouble x) {
_glptr_glUniform1d = (PFN_glUniform1d)GalogenGetProcAddress("glUniform1d");
_glptr_glUniform1d(location, x);
}
PFN_glUniform1d _glptr_glUniform1d = _impl_glUniform1d;
static void GL_APIENTRY _impl_glBindTransformFeedback (GLenum target, GLuint id) {
_glptr_glBindTransformFeedback = (PFN_glBindTransformFeedback)GalogenGetProcAddress("glBindTransformFeedback");
_glptr_glBindTransformFeedback(target, id);
}
PFN_glBindTransformFeedback _glptr_glBindTransformFeedback = _impl_glBindTransformFeedback;
static void GL_APIENTRY _impl_glDrawArraysIndirect (GLenum mode, const void * indirect) {
_glptr_glDrawArraysIndirect = (PFN_glDrawArraysIndirect)GalogenGetProcAddress("glDrawArraysIndirect");
_glptr_glDrawArraysIndirect(mode, indirect);
}
PFN_glDrawArraysIndirect _glptr_glDrawArraysIndirect = _impl_glDrawArraysIndirect;
static void GL_APIENTRY _impl_glBlendEquationi (GLuint buf, GLenum mode) {
_glptr_glBlendEquationi = (PFN_glBlendEquationi)GalogenGetProcAddress("glBlendEquationi");
_glptr_glBlendEquationi(buf, mode);
}
PFN_glBlendEquationi _glptr_glBlendEquationi = _impl_glBlendEquationi;
static void GL_APIENTRY _impl_glSecondaryColorP3uiv (GLenum type, const GLuint * color) {
_glptr_glSecondaryColorP3uiv = (PFN_glSecondaryColorP3uiv)GalogenGetProcAddress("glSecondaryColorP3uiv");
_glptr_glSecondaryColorP3uiv(type, color);
}
PFN_glSecondaryColorP3uiv _glptr_glSecondaryColorP3uiv = _impl_glSecondaryColorP3uiv;
static void GL_APIENTRY _impl_glSecondaryColorP3ui (GLenum type, GLuint color) {
_glptr_glSecondaryColorP3ui = (PFN_glSecondaryColorP3ui)GalogenGetProcAddress("glSecondaryColorP3ui");
_glptr_glSecondaryColorP3ui(type, color);
}
PFN_glSecondaryColorP3ui _glptr_glSecondaryColorP3ui = _impl_glSecondaryColorP3ui;
static void GL_APIENTRY _impl_glColorP3uiv (GLenum type, const GLuint * color) {
_glptr_glColorP3uiv = (PFN_glColorP3uiv)GalogenGetProcAddress("glColorP3uiv");
_glptr_glColorP3uiv(type, color);
}
PFN_glColorP3uiv _glptr_glColorP3uiv = _impl_glColorP3uiv;
static void GL_APIENTRY _impl_glNormalP3uiv (GLenum type, const GLuint * coords) {
_glptr_glNormalP3uiv = (PFN_glNormalP3uiv)GalogenGetProcAddress("glNormalP3uiv");
_glptr_glNormalP3uiv(type, coords);
}
PFN_glNormalP3uiv _glptr_glNormalP3uiv = _impl_glNormalP3uiv;
static void GL_APIENTRY _impl_glMultiTexCoordP3ui (GLenum texture, GLenum type, GLuint coords) {
_glptr_glMultiTexCoordP3ui = (PFN_glMultiTexCoordP3ui)GalogenGetProcAddress("glMultiTexCoordP3ui");
_glptr_glMultiTexCoordP3ui(texture, type, coords);
}
PFN_glMultiTexCoordP3ui _glptr_glMultiTexCoordP3ui = _impl_glMultiTexCoordP3ui;
static void GL_APIENTRY _impl_glTexCoordP4uiv (GLenum type, const GLuint * coords) {
_glptr_glTexCoordP4uiv = (PFN_glTexCoordP4uiv)GalogenGetProcAddress("glTexCoordP4uiv");
_glptr_glTexCoordP4uiv(type, coords);
}
PFN_glTexCoordP4uiv _glptr_glTexCoordP4uiv = _impl_glTexCoordP4uiv;
static void GL_APIENTRY _impl_glTexCoordP4ui (GLenum type, GLuint coords) {
_glptr_glTexCoordP4ui = (PFN_glTexCoordP4ui)GalogenGetProcAddress("glTexCoordP4ui");
_glptr_glTexCoordP4ui(type, coords);
}
PFN_glTexCoordP4ui _glptr_glTexCoordP4ui = _impl_glTexCoordP4ui;
static void GL_APIENTRY _impl_glTexCoordP1uiv (GLenum type, const GLuint * coords) {
_glptr_glTexCoordP1uiv = (PFN_glTexCoordP1uiv)GalogenGetProcAddress("glTexCoordP1uiv");
_glptr_glTexCoordP1uiv(type, coords);
}
PFN_glTexCoordP1uiv _glptr_glTexCoordP1uiv = _impl_glTexCoordP1uiv;
static void GL_APIENTRY _impl_glTexCoordP1ui (GLenum type, GLuint coords) {
_glptr_glTexCoordP1ui = (PFN_glTexCoordP1ui)GalogenGetProcAddress("glTexCoordP1ui");
_glptr_glTexCoordP1ui(type, coords);
}
PFN_glTexCoordP1ui _glptr_glTexCoordP1ui = _impl_glTexCoordP1ui;
static void GL_APIENTRY _impl_glVertexP4uiv (GLenum type, const GLuint * value) {
_glptr_glVertexP4uiv = (PFN_glVertexP4uiv)GalogenGetProcAddress("glVertexP4uiv");
_glptr_glVertexP4uiv(type, value);
}
PFN_glVertexP4uiv _glptr_glVertexP4uiv = _impl_glVertexP4uiv;
static void GL_APIENTRY _impl_glVertexP4ui (GLenum type, GLuint value) {
_glptr_glVertexP4ui = (PFN_glVertexP4ui)GalogenGetProcAddress("glVertexP4ui");
_glptr_glVertexP4ui(type, value);
}
PFN_glVertexP4ui _glptr_glVertexP4ui = _impl_glVertexP4ui;
static void GL_APIENTRY _impl_glVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
_glptr_glVertexAttribP4ui = (PFN_glVertexAttribP4ui)GalogenGetProcAddress("glVertexAttribP4ui");
_glptr_glVertexAttribP4ui(index, type, normalized, value);
}
PFN_glVertexAttribP4ui _glptr_glVertexAttribP4ui = _impl_glVertexAttribP4ui;
static void GL_APIENTRY _impl_glVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
_glptr_glVertexAttribP3uiv = (PFN_glVertexAttribP3uiv)GalogenGetProcAddress("glVertexAttribP3uiv");
_glptr_glVertexAttribP3uiv(index, type, normalized, value);
}
PFN_glVertexAttribP3uiv _glptr_glVertexAttribP3uiv = _impl_glVertexAttribP3uiv;
static void GL_APIENTRY _impl_glVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
_glptr_glVertexAttribP3ui = (PFN_glVertexAttribP3ui)GalogenGetProcAddress("glVertexAttribP3ui");
_glptr_glVertexAttribP3ui(index, type, normalized, value);
}
PFN_glVertexAttribP3ui _glptr_glVertexAttribP3ui = _impl_glVertexAttribP3ui;
static void GL_APIENTRY _impl_glVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
_glptr_glVertexAttribP2ui = (PFN_glVertexAttribP2ui)GalogenGetProcAddress("glVertexAttribP2ui");
_glptr_glVertexAttribP2ui(index, type, normalized, value);
}
PFN_glVertexAttribP2ui _glptr_glVertexAttribP2ui = _impl_glVertexAttribP2ui;
static void GL_APIENTRY _impl_glGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 * params) {
_glptr_glGetQueryObjectui64v = (PFN_glGetQueryObjectui64v)GalogenGetProcAddress("glGetQueryObjectui64v");
_glptr_glGetQueryObjectui64v(id, pname, params);
}
PFN_glGetQueryObjectui64v _glptr_glGetQueryObjectui64v = _impl_glGetQueryObjectui64v;
static void GL_APIENTRY _impl_glQueryCounter (GLuint id, GLenum target) {
_glptr_glQueryCounter = (PFN_glQueryCounter)GalogenGetProcAddress("glQueryCounter");
_glptr_glQueryCounter(id, target);
}
PFN_glQueryCounter _glptr_glQueryCounter = _impl_glQueryCounter;
static void GL_APIENTRY _impl_glGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint * params) {
_glptr_glGetSamplerParameterIuiv = (PFN_glGetSamplerParameterIuiv)GalogenGetProcAddress("glGetSamplerParameterIuiv");
_glptr_glGetSamplerParameterIuiv(sampler, pname, params);
}
PFN_glGetSamplerParameterIuiv _glptr_glGetSamplerParameterIuiv = _impl_glGetSamplerParameterIuiv;
static void GL_APIENTRY _impl_glVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
_glptr_glVertexAttribP2uiv = (PFN_glVertexAttribP2uiv)GalogenGetProcAddress("glVertexAttribP2uiv");
_glptr_glVertexAttribP2uiv(index, type, normalized, value);
}
PFN_glVertexAttribP2uiv _glptr_glVertexAttribP2uiv = _impl_glVertexAttribP2uiv;
static void GL_APIENTRY _impl_glGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat * params) {
_glptr_glGetSamplerParameterfv = (PFN_glGetSamplerParameterfv)GalogenGetProcAddress("glGetSamplerParameterfv");
_glptr_glGetSamplerParameterfv(sampler, pname, params);
}
PFN_glGetSamplerParameterfv _glptr_glGetSamplerParameterfv = _impl_glGetSamplerParameterfv;
static void GL_APIENTRY _impl_glGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint * params) {
_glptr_glGetSamplerParameterIiv = (PFN_glGetSamplerParameterIiv)GalogenGetProcAddress("glGetSamplerParameterIiv");
_glptr_glGetSamplerParameterIiv(sampler, pname, params);
}
PFN_glGetSamplerParameterIiv _glptr_glGetSamplerParameterIiv = _impl_glGetSamplerParameterIiv;
static void GL_APIENTRY _impl_glGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint * params) {
_glptr_glGetSamplerParameteriv = (PFN_glGetSamplerParameteriv)GalogenGetProcAddress("glGetSamplerParameteriv");
_glptr_glGetSamplerParameteriv(sampler, pname, params);
}
PFN_glGetSamplerParameteriv _glptr_glGetSamplerParameteriv = _impl_glGetSamplerParameteriv;
static void GL_APIENTRY _impl_glDeleteSamplers (GLsizei count, const GLuint * samplers) {
_glptr_glDeleteSamplers = (PFN_glDeleteSamplers)GalogenGetProcAddress("glDeleteSamplers");
_glptr_glDeleteSamplers(count, samplers);
}
PFN_glDeleteSamplers _glptr_glDeleteSamplers = _impl_glDeleteSamplers;
static void GL_APIENTRY _impl_glGenSamplers (GLsizei count, GLuint * samplers) {
_glptr_glGenSamplers = (PFN_glGenSamplers)GalogenGetProcAddress("glGenSamplers");
_glptr_glGenSamplers(count, samplers);
}
PFN_glGenSamplers _glptr_glGenSamplers = _impl_glGenSamplers;
static void GL_APIENTRY _impl_glSampleMaski (GLuint maskNumber, GLbitfield mask) {
_glptr_glSampleMaski = (PFN_glSampleMaski)GalogenGetProcAddress("glSampleMaski");
_glptr_glSampleMaski(maskNumber, mask);
}
PFN_glSampleMaski _glptr_glSampleMaski = _impl_glSampleMaski;
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_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_glSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint * param) {
_glptr_glSamplerParameterIiv = (PFN_glSamplerParameterIiv)GalogenGetProcAddress("glSamplerParameterIiv");
_glptr_glSamplerParameterIiv(sampler, pname, param);
}
PFN_glSamplerParameterIiv _glptr_glSamplerParameterIiv = _impl_glSamplerParameterIiv;
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_glGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values) {
_glptr_glGetSynciv = (PFN_glGetSynciv)GalogenGetProcAddress("glGetSynciv");
_glptr_glGetSynciv(sync, pname, bufSize, length, values);
}
PFN_glGetSynciv _glptr_glGetSynciv = _impl_glGetSynciv;
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 void GL_APIENTRY _impl_glDrawElementsIndirect (GLenum mode, GLenum type, const void * indirect) {
_glptr_glDrawElementsIndirect = (PFN_glDrawElementsIndirect)GalogenGetProcAddress("glDrawElementsIndirect");
_glptr_glDrawElementsIndirect(mode, type, indirect);
}
PFN_glDrawElementsIndirect _glptr_glDrawElementsIndirect = _impl_glDrawElementsIndirect;
static GLint GL_APIENTRY _impl_glGetFragDataIndex (GLuint program, const GLchar * name) {
_glptr_glGetFragDataIndex = (PFN_glGetFragDataIndex)GalogenGetProcAddress("glGetFragDataIndex");
return _glptr_glGetFragDataIndex(program, name);
}
PFN_glGetFragDataIndex _glptr_glGetFragDataIndex = _impl_glGetFragDataIndex;
static GLenum GL_APIENTRY _impl_glClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) {
_glptr_glClientWaitSync = (PFN_glClientWaitSync)GalogenGetProcAddress("glClientWaitSync");
return _glptr_glClientWaitSync(sync, flags, timeout);
}
PFN_glClientWaitSync _glptr_glClientWaitSync = _impl_glClientWaitSync;
static void GL_APIENTRY _impl_glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex) {
_glptr_glDrawElementsBaseVertex = (PFN_glDrawElementsBaseVertex)GalogenGetProcAddress("glDrawElementsBaseVertex");
_glptr_glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
}
PFN_glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex = _impl_glDrawElementsBaseVertex;
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_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 void GL_APIENTRY _impl_glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
_glptr_glDrawArraysInstanced = (PFN_glDrawArraysInstanced)GalogenGetProcAddress("glDrawArraysInstanced");
_glptr_glDrawArraysInstanced(mode, first, count, instancecount);
}
PFN_glDrawArraysInstanced _glptr_glDrawArraysInstanced = _impl_glDrawArraysInstanced;
static void GL_APIENTRY _impl_glDeleteVertexArrays (GLsizei n, const GLuint * arrays) {
_glptr_glDeleteVertexArrays = (PFN_glDeleteVertexArrays)GalogenGetProcAddress("glDeleteVertexArrays");
_glptr_glDeleteVertexArrays(n, arrays);
}
PFN_glDeleteVertexArrays _glptr_glDeleteVertexArrays = _impl_glDeleteVertexArrays;
static void GL_APIENTRY _impl_glBeginQueryIndexed (GLenum target, GLuint index, GLuint id) {
_glptr_glBeginQueryIndexed = (PFN_glBeginQueryIndexed)GalogenGetProcAddress("glBeginQueryIndexed");
_glptr_glBeginQueryIndexed(target, index, id);
}
PFN_glBeginQueryIndexed _glptr_glBeginQueryIndexed = _impl_glBeginQueryIndexed;
static void GL_APIENTRY _impl_glTexCoordP2uiv (GLenum type, const GLuint * coords) {
_glptr_glTexCoordP2uiv = (PFN_glTexCoordP2uiv)GalogenGetProcAddress("glTexCoordP2uiv");
_glptr_glTexCoordP2uiv(type, coords);
}
PFN_glTexCoordP2uiv _glptr_glTexCoordP2uiv = _impl_glTexCoordP2uiv;
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_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_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_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_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_glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
_glptr_glBlitFramebuffer = (PFN_glBlitFramebuffer)GalogenGetProcAddress("glBlitFramebuffer");
_glptr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
PFN_glBlitFramebuffer _glptr_glBlitFramebuffer = _impl_glBlitFramebuffer;
static void GL_APIENTRY _impl_glColorP4uiv (GLenum type, const GLuint * color) {
_glptr_glColorP4uiv = (PFN_glColorP4uiv)GalogenGetProcAddress("glColorP4uiv");
_glptr_glColorP4uiv(type, color);
}
PFN_glColorP4uiv _glptr_glColorP4uiv = _impl_glColorP4uiv;
static void GL_APIENTRY _impl_glGenerateMipmap (GLenum target) {
_glptr_glGenerateMipmap = (PFN_glGenerateMipmap)GalogenGetProcAddress("glGenerateMipmap");
_glptr_glGenerateMipmap(target);
}
PFN_glGenerateMipmap _glptr_glGenerateMipmap = _impl_glGenerateMipmap;
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_glMinSampleShading (GLfloat value) {
_glptr_glMinSampleShading = (PFN_glMinSampleShading)GalogenGetProcAddress("glMinSampleShading");
_glptr_glMinSampleShading(value);
}
PFN_glMinSampleShading _glptr_glMinSampleShading = _impl_glMinSampleShading;
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_glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
_glptr_glCopyBufferSubData = (PFN_glCopyBufferSubData)GalogenGetProcAddress("glCopyBufferSubData");
_glptr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}
PFN_glCopyBufferSubData _glptr_glCopyBufferSubData = _impl_glCopyBufferSubData;
static void GL_APIENTRY _impl_glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
_glptr_glFramebufferTexture2D = (PFN_glFramebufferTexture2D)GalogenGetProcAddress("glFramebufferTexture2D");
_glptr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
PFN_glFramebufferTexture2D _glptr_glFramebufferTexture2D = _impl_glFramebufferTexture2D;
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_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 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_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
_glptr_glRenderbufferStorage = (PFN_glRenderbufferStorage)GalogenGetProcAddress("glRenderbufferStorage");
_glptr_glRenderbufferStorage(target, internalformat, width, height);
}
PFN_glRenderbufferStorage _glptr_glRenderbufferStorage = _impl_glRenderbufferStorage;
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_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 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_glVertexP3ui (GLenum type, GLuint value) {
_glptr_glVertexP3ui = (PFN_glVertexP3ui)GalogenGetProcAddress("glVertexP3ui");
_glptr_glVertexP3ui(type, value);
}
PFN_glVertexP3ui _glptr_glVertexP3ui = _impl_glVertexP3ui;
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_glColorP4ui (GLenum type, GLuint color) {
_glptr_glColorP4ui = (PFN_glColorP4ui)GalogenGetProcAddress("glColorP4ui");
_glptr_glColorP4ui(type, color);
}
PFN_glColorP4ui _glptr_glColorP4ui = _impl_glColorP4ui;
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_glGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint * params) {
_glptr_glGetUniformSubroutineuiv = (PFN_glGetUniformSubroutineuiv)GalogenGetProcAddress("glGetUniformSubroutineuiv");
_glptr_glGetUniformSubroutineuiv(shadertype, location, params);
}
PFN_glGetUniformSubroutineuiv _glptr_glGetUniformSubroutineuiv = _impl_glGetUniformSubroutineuiv;
static void GL_APIENTRY _impl_glUniform3uiv (GLint location, GLsizei count, const GLuint * value) {
_glptr_glUniform3uiv = (PFN_glUniform3uiv)GalogenGetProcAddress("glUniform3uiv");
_glptr_glUniform3uiv(location, count, value);
}
PFN_glUniform3uiv _glptr_glUniform3uiv = _impl_glUniform3uiv;
static void GL_APIENTRY _impl_glUniform2uiv (GLint location, GLsizei count, const GLuint * value) {
_glptr_glUniform2uiv = (PFN_glUniform2uiv)GalogenGetProcAddress("glUniform2uiv");
_glptr_glUniform2uiv(location, count, value);
}
PFN_glUniform2uiv _glptr_glUniform2uiv = _impl_glUniform2uiv;
static void GL_APIENTRY _impl_glGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params) {
_glptr_glGetActiveUniformBlockiv = (PFN_glGetActiveUniformBlockiv)GalogenGetProcAddress("glGetActiveUniformBlockiv");
_glptr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}
PFN_glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv = _impl_glGetActiveUniformBlockiv;
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_glUniform2ui (GLint location, GLuint v0, GLuint v1) {
_glptr_glUniform2ui = (PFN_glUniform2ui)GalogenGetProcAddress("glUniform2ui");
_glptr_glUniform2ui(location, v0, v1);
}
PFN_glUniform2ui _glptr_glUniform2ui = _impl_glUniform2ui;
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 void GL_APIENTRY _impl_glVertexAttribI4ubv (GLuint index, const GLubyte * v) {
_glptr_glVertexAttribI4ubv = (PFN_glVertexAttribI4ubv)GalogenGetProcAddress("glVertexAttribI4ubv");
_glptr_glVertexAttribI4ubv(index, v);
}
PFN_glVertexAttribI4ubv _glptr_glVertexAttribI4ubv = _impl_glVertexAttribI4ubv;
static void GL_APIENTRY _impl_glVertexAttribI4sv (GLuint index, const GLshort * v) {
_glptr_glVertexAttribI4sv = (PFN_glVertexAttribI4sv)GalogenGetProcAddress("glVertexAttribI4sv");
_glptr_glVertexAttribI4sv(index, v);
}
PFN_glVertexAttribI4sv _glptr_glVertexAttribI4sv = _impl_glVertexAttribI4sv;
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_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_glVertexAttribI3iv (GLuint index, const GLint * v) {
_glptr_glVertexAttribI3iv = (PFN_glVertexAttribI3iv)GalogenGetProcAddress("glVertexAttribI3iv");
_glptr_glVertexAttribI3iv(index, v);
}
PFN_glVertexAttribI3iv _glptr_glVertexAttribI3iv = _impl_glVertexAttribI3iv;
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_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_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_glBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
_glptr_glBlendFuncSeparatei = (PFN_glBlendFuncSeparatei)GalogenGetProcAddress("glBlendFuncSeparatei");
_glptr_glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
PFN_glBlendFuncSeparatei _glptr_glBlendFuncSeparatei = _impl_glBlendFuncSeparatei;
static void GL_APIENTRY _impl_glVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z) {
_glptr_glVertexAttribI3i = (PFN_glVertexAttribI3i)GalogenGetProcAddress("glVertexAttribI3i");
_glptr_glVertexAttribI3i(index, x, y, z);
}
PFN_glVertexAttribI3i _glptr_glVertexAttribI3i = _impl_glVertexAttribI3i;
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_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_glGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint * params) {
_glptr_glGetVertexAttribIuiv = (PFN_glGetVertexAttribIuiv)GalogenGetProcAddress("glGetVertexAttribIuiv");
_glptr_glGetVertexAttribIuiv(index, pname, params);
}
PFN_glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv = _impl_glGetVertexAttribIuiv;
static void GL_APIENTRY _impl_glDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream) {
_glptr_glDrawTransformFeedbackStream = (PFN_glDrawTransformFeedbackStream)GalogenGetProcAddress("glDrawTransformFeedbackStream");
_glptr_glDrawTransformFeedbackStream(mode, id, stream);
}
PFN_glDrawTransformFeedbackStream _glptr_glDrawTransformFeedbackStream = _impl_glDrawTransformFeedbackStream;
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_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_glGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) {
_glptr_glGetTransformFeedbackVarying = (PFN_glGetTransformFeedbackVarying)GalogenGetProcAddress("glGetTransformFeedbackVarying");
_glptr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
}
PFN_glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying = _impl_glGetTransformFeedbackVarying;
static void GL_APIENTRY _impl_glTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode) {
_glptr_glTransformFeedbackVaryings = (PFN_glTransformFeedbackVaryings)GalogenGetProcAddress("glTransformFeedbackVaryings");
_glptr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
}
PFN_glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings = _impl_glTransformFeedbackVaryings;
static void GL_APIENTRY _impl_glBeginTransformFeedback (GLenum primitiveMode) {
_glptr_glBeginTransformFeedback = (PFN_glBeginTransformFeedback)GalogenGetProcAddress("glBeginTransformFeedback");
_glptr_glBeginTransformFeedback(primitiveMode);
}
PFN_glBeginTransformFeedback _glptr_glBeginTransformFeedback = _impl_glBeginTransformFeedback;
static void GL_APIENTRY _impl_glDisablei (GLenum target, GLuint index) {
_glptr_glDisablei = (PFN_glDisablei)GalogenGetProcAddress("glDisablei");
_glptr_glDisablei(target, index);
}
PFN_glDisablei _glptr_glDisablei = _impl_glDisablei;
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_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_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_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_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_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_glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
_glptr_glVertexAttrib4s = (PFN_glVertexAttrib4s)GalogenGetProcAddress("glVertexAttrib4s");
_glptr_glVertexAttrib4s(index, x, y, z, w);
}
PFN_glVertexAttrib4s _glptr_glVertexAttrib4s = _impl_glVertexAttrib4s;
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_glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
_glptr_glVertexAttrib4f = (PFN_glVertexAttrib4f)GalogenGetProcAddress("glVertexAttrib4f");
_glptr_glVertexAttrib4f(index, x, y, z, w);
}
PFN_glVertexAttrib4f _glptr_glVertexAttrib4f = _impl_glVertexAttrib4f;
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_glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
_glptr_glVertexAttrib4d = (PFN_glVertexAttrib4d)GalogenGetProcAddress("glVertexAttrib4d");
_glptr_glVertexAttrib4d(index, x, y, z, w);
}
PFN_glVertexAttrib4d _glptr_glVertexAttrib4d = _impl_glVertexAttrib4d;
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_glVertexAttrib4bv (GLuint index, const GLbyte * v) {
_glptr_glVertexAttrib4bv = (PFN_glVertexAttrib4bv)GalogenGetProcAddress("glVertexAttrib4bv");
_glptr_glVertexAttrib4bv(index, v);
}
PFN_glVertexAttrib4bv _glptr_glVertexAttrib4bv = _impl_glVertexAttrib4bv;
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_glMultiTexCoordP1ui (GLenum texture, GLenum type, GLuint coords) {
_glptr_glMultiTexCoordP1ui = (PFN_glMultiTexCoordP1ui)GalogenGetProcAddress("glMultiTexCoordP1ui");
_glptr_glMultiTexCoordP1ui(texture, type, coords);
}
PFN_glMultiTexCoordP1ui _glptr_glMultiTexCoordP1ui = _impl_glMultiTexCoordP1ui;
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_glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {
_glptr_glVertexAttrib4Nub = (PFN_glVertexAttrib4Nub)GalogenGetProcAddress("glVertexAttrib4Nub");
_glptr_glVertexAttrib4Nub(index, x, y, z, w);
}
PFN_glVertexAttrib4Nub _glptr_glVertexAttrib4Nub = _impl_glVertexAttrib4Nub;
static void GL_APIENTRY _impl_glVertexAttrib4Niv (GLuint index, const GLint * v) {
_glptr_glVertexAttrib4Niv = (PFN_glVertexAttrib4Niv)GalogenGetProcAddress("glVertexAttrib4Niv");
_glptr_glVertexAttrib4Niv(index, v);
}
PFN_glVertexAttrib4Niv _glptr_glVertexAttrib4Niv = _impl_glVertexAttrib4Niv;
static void GL_APIENTRY _impl_glVertexAttrib4Nbv (GLuint index, const GLbyte * v) {
_glptr_glVertexAttrib4Nbv = (PFN_glVertexAttrib4Nbv)GalogenGetProcAddress("glVertexAttrib4Nbv");
_glptr_glVertexAttrib4Nbv(index, v);
}
PFN_glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv = _impl_glVertexAttrib4Nbv;
static void GL_APIENTRY _impl_glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z) {
_glptr_glVertexAttrib3s = (PFN_glVertexAttrib3s)GalogenGetProcAddress("glVertexAttrib3s");
_glptr_glVertexAttrib3s(index, x, y, z);
}
PFN_glVertexAttrib3s _glptr_glVertexAttrib3s = _impl_glVertexAttrib3s;
static void GL_APIENTRY _impl_glVertexAttrib3fv (GLuint index, const GLfloat * v) {
_glptr_glVertexAttrib3fv = (PFN_glVertexAttrib3fv)GalogenGetProcAddress("glVertexAttrib3fv");
_glptr_glVertexAttrib3fv(index, v);
}
PFN_glVertexAttrib3fv _glptr_glVertexAttrib3fv = _impl_glVertexAttrib3fv;
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_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_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_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 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_glVertexAttrib1sv (GLuint index, const GLshort * v) {
_glptr_glVertexAttrib1sv = (PFN_glVertexAttrib1sv)GalogenGetProcAddress("glVertexAttrib1sv");
_glptr_glVertexAttrib1sv(index, v);
}
PFN_glVertexAttrib1sv _glptr_glVertexAttrib1sv = _impl_glVertexAttrib1sv;
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_glVertexAttrib1d (GLuint index, GLdouble x) {
_glptr_glVertexAttrib1d = (PFN_glVertexAttrib1d)GalogenGetProcAddress("glVertexAttrib1d");
_glptr_glVertexAttrib1d(index, x);
}
PFN_glVertexAttrib1d _glptr_glVertexAttrib1d = _impl_glVertexAttrib1d;
static void GL_APIENTRY _impl_glValidateProgram (GLuint program) {
_glptr_glValidateProgram = (PFN_glValidateProgram)GalogenGetProcAddress("glValidateProgram");
_glptr_glValidateProgram(program);
}
PFN_glValidateProgram _glptr_glValidateProgram = _impl_glValidateProgram;
static void GL_APIENTRY _impl_glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
_glptr_glUniformMatrix4fv = (PFN_glUniformMatrix4fv)GalogenGetProcAddress("glUniformMatrix4fv");
_glptr_glUniformMatrix4fv(location, count, transpose, value);
}
PFN_glUniformMatrix4fv _glptr_glUniformMatrix4fv = _impl_glUniformMatrix4fv;
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_glUniform3iv (GLint location, GLsizei count, const GLint * value) {
_glptr_glUniform3iv = (PFN_glUniform3iv)GalogenGetProcAddress("glUniform3iv");
_glptr_glUniform3iv(location, count, value);