1
2 // Copyright 2018 - 2021 Michael D. Parker
3 // Distributed under the Boost Software License, Version 1.0.
4 // (See accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6
7 module bindbc.opengl.bind.arb.core_40;
8
9 import bindbc.loader;
10 import bindbc.opengl.config,
11 bindbc.opengl.context;
12 import bindbc.opengl.bind.types;
13
14 static if(glSupport >= GLSupport.gl40) {
15 enum has40 = true;
16 }
17 else enum has40 = false;
18 /+
19 // ARB_occlusion_query2
20 version(GL_ARB) enum useARBOcclusionQuery2 = true;
21 else version(GL_ARB_occlusion_query2) enum useARBOcclusionQuery2 = true;
22 else enum useARBOcclusionQuery2 = has33;
23
24 static if(useARBOcclusionQuery2) {
25 private bool _hasARBOcclusionQuery2;
26 @nogc nothrow bool hasARBOcclusionQuery2() { return _hasARBOcclusionQuery2; }
27 }
28 else enum hasARBOcclusionQuery2 = false;
29
30 +/
31 // ARB_gpu_shader5
32 version(GL_ARB) enum useARBGPUShader5 = true;
33 else version(GL_ARB_gpu_shader5) enum useARBGPUShader5 = true;
34 else enum useARBGPUShader5 = has40;
35
36 static if(useARBGPUShader5) {
37 private bool _hasARBGPUShader5;
38 @nogc nothrow bool hasARBGPUShader5() { return _hasARBGPUShader5; }
39
40 enum : uint {
41 GL_GEOMETRY_SHADER_INVOCATIONS = 0x887F,
42 GL_MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A,
43 GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B,
44 GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C,
45 GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D,
46 }
47 }
48 else enum hasARBGPUShader5 = false;
49
50 // ARB_draw_indirect
51 version(GL_ARB) enum useARBDrawIndirect = true;
52 else version(GL_ARB_draw_indirect) enum useARBDrawIndirect = true;
53 else enum useARBDrawIndirect = has40;
54
55 static if(useARBDrawIndirect) {
56 private bool _hasARBDrawIndirect;
57 @nogc nothrow bool hasARBDrawIndirect() { return _hasARBDrawIndirect; }
58
59 enum : uint {
60 GL_DRAW_INDIRECT_BUFFER = 0x8F3F,
61 GL_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43,
62 }
63
64 extern(System) @nogc nothrow {
65 alias pglDrawArraysIndirect = void function(GLenum, const(GLvoid)*);
66 alias pglDrawElementsIndirect = void function(GLenum, GLenum, const(GLvoid)*);
67 }
68
69 __gshared {
70 pglDrawArraysIndirect glDrawArraysIndirect;
71 pglDrawElementsIndirect glDrawElementsIndirect;
72 }
73
74 private @nogc nothrow
75 bool loadARBDrawIndirect(SharedLib lib, GLSupport contextVersion)
76 {
77 lib.bindGLSymbol(cast(void**)&glDrawArraysIndirect, "glDrawArraysIndirect");
78 lib.bindGLSymbol(cast(void**)&glDrawElementsIndirect, "glDrawElementsIndirect");
79 return resetErrorCountGL();
80 }
81 }
82 else enum hasARBDrawIndirect = false;
83
84 // ARB_gpu_shader_fp64
85 version(GL_ARB) enum useARBGPUShaderFP64 = true;
86 else version(GL_ARB_gpu_shader_fp64) enum useARBGPUShaderFP64 = true;
87 else enum useARBGPUShaderFP64 = has40;
88
89 static if(useARBGPUShaderFP64) {
90 private bool _hasARBGPUShaderFP64;
91 @nogc nothrow bool hasARBGPUShaderFP64() { return _hasARBGPUShaderFP64; }
92
93 enum : uint {
94 GL_DOUBLE_VEC2 = 0x8FFC,
95 GL_DOUBLE_VEC3 = 0x8FFD,
96 GL_DOUBLE_VEC4 = 0x8FFE,
97 GL_DOUBLE_MAT2 = 0x8F46,
98 GL_DOUBLE_MAT3 = 0x8F47,
99 GL_DOUBLE_MAT4 = 0x8F48,
100 GL_DOUBLE_MAT2x3 = 0x8F49,
101 GL_DOUBLE_MAT2x4 = 0x8F4A,
102 GL_DOUBLE_MAT3x2 = 0x8F4B,
103 GL_DOUBLE_MAT3x4 = 0x8F4C,
104 GL_DOUBLE_MAT4x2 = 0x8F4D,
105 GL_DOUBLE_MAT4x3 = 0x8F4E,
106 }
107
108 extern(System) @nogc nothrow {
109 alias pglUniform1d = void function(GLint,GLdouble);
110 alias pglUniform2d = void function(GLint,GLdouble,GLdouble);
111 alias pglUniform3d = void function(GLint,GLdouble,GLdouble,GLdouble);
112 alias pglUniform4d = void function(GLint,GLdouble,GLdouble,GLdouble,GLdouble);
113 alias pglUniform1dv = void function(GLint,GLsizei,const(GLdouble)*);
114 alias pglUniform2dv = void function(GLint,GLsizei,const(GLdouble)*);
115 alias pglUniform3dv = void function(GLint,GLsizei,const(GLdouble)*);
116 alias pglUniform4dv = void function(GLint,GLsizei,const(GLdouble)*);
117 alias pglUniformMatrix2dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
118 alias pglUniformMatrix3dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
119 alias pglUniformMatrix4dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
120 alias pglUniformMatrix2x3dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
121 alias pglUniformMatrix2x4dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
122 alias pglUniformMatrix3x2dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
123 alias pglUniformMatrix3x4dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
124 alias pglUniformMatrix4x2dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
125 alias pglUniformMatrix4x3dv = void function(GLint,GLsizei,GLboolean,const(GLdouble)*);
126 alias pglGetUniformdv = void function(GLuint,GLint,GLdouble*);
127 }
128
129 __gshared {
130 pglUniform1d glUniform1d;
131 pglUniform2d glUniform2d;
132 pglUniform3d glUniform3d;
133 pglUniform4d glUniform4d;
134 pglUniform1dv glUniform1dv;
135 pglUniform2dv glUniform2dv;
136 pglUniform3dv glUniform3dv;
137 pglUniform4dv glUniform4dv;
138 pglUniformMatrix2dv glUniformMatrix2dv;
139 pglUniformMatrix3dv glUniformMatrix3dv;
140 pglUniformMatrix4dv glUniformMatrix4dv;
141 pglUniformMatrix2x3dv glUniformMatrix2x3dv;
142 pglUniformMatrix2x4dv glUniformMatrix2x4dv;
143 pglUniformMatrix3x2dv glUniformMatrix3x2dv;
144 pglUniformMatrix3x4dv glUniformMatrix3x4dv;
145 pglUniformMatrix4x2dv glUniformMatrix4x2dv;
146 pglUniformMatrix4x3dv glUniformMatrix4x3dv;
147 pglGetUniformdv glGetUniformdv;
148 }
149
150 private @nogc nothrow
151 bool loadARBGPUShaderFP64(SharedLib lib, GLSupport contextVersion)
152 {
153 lib.bindGLSymbol(cast(void**)&glUniform1d,"glUniform1d");
154 lib.bindGLSymbol(cast(void**)&glUniform2d,"glUniform2d");
155 lib.bindGLSymbol(cast(void**)&glUniform3d,"glUniform3d");
156 lib.bindGLSymbol(cast(void**)&glUniform4d,"glUniform4d");
157 lib.bindGLSymbol(cast(void**)&glUniform1dv,"glUniform1dv");
158 lib.bindGLSymbol(cast(void**)&glUniform2dv,"glUniform2dv");
159 lib.bindGLSymbol(cast(void**)&glUniform3dv,"glUniform3dv");
160 lib.bindGLSymbol(cast(void**)&glUniform4dv,"glUniform4dv");
161 lib.bindGLSymbol(cast(void**)&glUniformMatrix2dv,"glUniformMatrix2dv");
162 lib.bindGLSymbol(cast(void**)&glUniformMatrix3dv,"glUniformMatrix3dv");
163 lib.bindGLSymbol(cast(void**)&glUniformMatrix4dv,"glUniformMatrix4dv");
164 lib.bindGLSymbol(cast(void**)&glUniformMatrix2x3dv,"glUniformMatrix2x3dv");
165 lib.bindGLSymbol(cast(void**)&glUniformMatrix2x4dv,"glUniformMatrix2x4dv");
166 lib.bindGLSymbol(cast(void**)&glUniformMatrix3x2dv,"glUniformMatrix3x2dv");
167 lib.bindGLSymbol(cast(void**)&glUniformMatrix3x4dv,"glUniformMatrix3x4dv");
168 lib.bindGLSymbol(cast(void**)&glUniformMatrix4x2dv,"glUniformMatrix4x2dv");
169 lib.bindGLSymbol(cast(void**)&glUniformMatrix4x3dv,"glUniformMatrix4x3dv");
170 lib.bindGLSymbol(cast(void**)&glGetUniformdv,"glGetUniformdv");
171 return resetErrorCountGL();
172 }
173 }
174 else enum hasARBGPUShaderFP64 = false;
175
176 // ARB_shader_subroutine
177 version(GL_ARB) enum useARBShaderSubroutine = true;
178 else version(GL_ARB_shader_subroutine) enum useARBShaderSubroutine = true;
179 else enum useARBShaderSubroutine = has40;
180
181 static if(useARBShaderSubroutine) {
182 private bool _hasARBShaderSubroutine;
183 @nogc nothrow bool hasARBShaderSubroutine() { return _hasARBShaderSubroutine; }
184
185 enum : uint {
186 GL_ACTIVE_SUBROUTINES = 0x8DE5,
187 GL_ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6,
188 GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47,
189 GL_ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48,
190 GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49,
191 GL_MAX_SUBROUTINES = 0x8DE7,
192 GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8,
193 GL_NUM_COMPATIBLE_SUBROUTINES = 0x8E4A,
194 GL_COMPATIBLE_SUBROUTINES = 0x8E4B,
195 }
196
197 extern(System) @nogc nothrow {
198 alias pglGetSubroutineUniformLocation = GLint function(GLuint, GLenum, const(GLchar)*);
199 alias pglGetSubroutineIndex = GLuint function(GLuint, GLenum, const(GLchar)*);
200 alias pglGetActiveSubroutineUniformiv = void function(GLuint, GLenum, GLuint, GLenum, GLint*);
201 alias pglGetActiveSubroutineUniformName = void function(GLuint, GLenum, GLuint, GLsizei, GLsizei*, GLchar*);
202 alias pglGetActiveSubroutineName = void function(GLuint, GLenum, GLuint, GLsizei, GLsizei*, GLchar*);
203 alias pglUniformSubroutinesuiv = void function(GLenum, GLsizei, const(GLuint)*);
204 alias pglGetUniformSubroutineuiv = void function(GLenum, GLint, GLuint*);
205 alias pglGetProgramStageiv = void function(GLuint, GLenum, GLenum, GLint*);
206 }
207
208 __gshared {
209 pglGetSubroutineUniformLocation glGetSubroutineUniformLocation;
210 pglGetSubroutineIndex glGetSubroutineIndex;
211 pglGetActiveSubroutineUniformiv glGetActiveSubroutineUniformiv;
212 pglGetActiveSubroutineUniformName glGetActiveSubroutineUniformName;
213 pglGetActiveSubroutineName glGetActiveSubroutineName;
214 pglUniformSubroutinesuiv glUniformSubroutinesuiv;
215 pglGetUniformSubroutineuiv glGetUniformSubroutineuiv;
216 pglGetProgramStageiv glGetProgramStageiv;
217 }
218
219 private @nogc nothrow
220 bool loadARBShaderSubroutine(SharedLib lib, GLSupport contextVersion)
221 {
222 lib.bindGLSymbol(cast(void**)&glGetSubroutineUniformLocation, "glGetSubroutineUniformLocation");
223 lib.bindGLSymbol(cast(void**)&glGetSubroutineIndex, "glGetSubroutineIndex");
224 lib.bindGLSymbol(cast(void**)&glGetActiveSubroutineUniformiv, "glGetActiveSubroutineUniformiv");
225 lib.bindGLSymbol(cast(void**)&glGetActiveSubroutineUniformName, "glGetActiveSubroutineUniformName");
226 lib.bindGLSymbol(cast(void**)&glGetActiveSubroutineName, "glGetActiveSubroutineName");
227 lib.bindGLSymbol(cast(void**)&glUniformSubroutinesuiv, "glUniformSubroutinesuiv");
228 lib.bindGLSymbol(cast(void**)&glGetUniformSubroutineuiv, "glGetUniformSubroutineuiv");
229 lib.bindGLSymbol(cast(void**)&glGetProgramStageiv, "glGetProgramStageiv");
230 return resetErrorCountGL();
231 }
232 }
233 else enum hasARBShaderSubroutine = false;
234
235 // ARB_tessellation_shader
236 version(GL_ARB) enum useARBTesselationShader = true;
237 else version(GL_ARB_tessellation_shader) enum useARBTesselationShader = true;
238 else enum useARBTesselationShader = has40;
239
240 static if(useARBTesselationShader) {
241 private bool _hasARBTesselationShader;
242 @nogc nothrow bool hasARBTesselationShader() { return _hasARBTesselationShader; }
243
244 enum : uint {
245 GL_PATCHES = 0x000E,
246 GL_PATCH_VERTICES = 0x8E72,
247 GL_PATCH_DEFAULT_INNER_LEVEL = 0x8E73,
248 GL_PATCH_DEFAULT_OUTER_LEVEL = 0x8E74,
249 GL_TESS_CONTROL_OUTPUT_VERTICES = 0x8E75,
250 GL_TESS_GEN_MODE = 0x8E76,
251 GL_TESS_GEN_SPACING = 0x8E77,
252 GL_TESS_GEN_VERTEX_ORDER = 0x8E78,
253 GL_TESS_GEN_POINT_MODE = 0x8E79,
254 GL_ISOLINES = 0x8E7A,
255 GL_FRACTIONAL_ODD = 0x8E7B,
256 GL_FRACTIONAL_EVEN = 0x8E7C,
257 GL_MAX_PATCH_VERTICES = 0x8E7D,
258 GL_MAX_TESS_GEN_LEVEL = 0x8E7E,
259 GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F,
260 GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80,
261 GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81,
262 GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82,
263 GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83,
264 GL_MAX_TESS_PATCH_COMPONENTS = 0x8E84,
265 GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85,
266 GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86,
267 GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89,
268 GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A,
269 GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C,
270 GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D,
271 GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E,
272 GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F,
273 GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0,
274 GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1,
275 GL_TESS_EVALUATION_SHADER = 0x8E87,
276 GL_TESS_CONTROL_SHADER = 0x8E88,
277 }
278
279 extern(System) @nogc nothrow {
280 alias pglPatchParameteri = void function(GLenum, GLint);
281 alias pglPatchParameterfv = void function(GLenum, const(GLfloat)*);
282 }
283
284 __gshared {
285 pglPatchParameteri glPatchParameteri;
286 pglPatchParameterfv glPatchParameterfv;
287 }
288
289 private @nogc nothrow
290 bool loadARBTesselationShader(SharedLib lib, GLSupport contextVersion)
291 {
292 lib.bindGLSymbol(cast(void**)&glPatchParameteri, "glPatchParameteri");
293 lib.bindGLSymbol(cast(void**)&glPatchParameterfv, "glPatchParameterfv");
294 return resetErrorCountGL();
295 }
296 }
297 else enum hasARBTesselationShader = false;
298
299 // ARB_transform_feedback2
300 version(GL_ARB) enum useARBTransformFeedback2 = true;
301 else version(GL_ARB_transform_feedback2) enum useARBTransformFeedback2 = true;
302 else enum useARBTransformFeedback2 = has40;
303
304 static if(useARBTransformFeedback2) {
305 private bool _hasARBTransformFeedback2;
306 @nogc nothrow bool hasARBTransformFeedback2() { return _hasARBTransformFeedback2; }
307
308 enum : uint {
309 GL_TRANSFORM_FEEDBACK = 0x8E22,
310 GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23,
311 GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24,
312 GL_TRANSFORM_FEEDBACK_BINDING = 0x8E25,
313 }
314
315 extern(System) @nogc nothrow {
316 alias pglBindTransformFeedback = void function(GLenum, GLuint);
317 alias pglDeleteTransformFeedbacks = void function(GLsizei, const(GLuint)*);
318 alias pglGenTransformFeedbacks = void function(GLsizei, GLuint*);
319 alias pglIsTransformFeedback = GLboolean function(GLuint);
320 alias pglPauseTransformFeedback = void function();
321 alias pglResumeTransformFeedback = void function();
322 alias pglDrawTransformFeedback = void function(GLenum, GLuint);
323 }
324
325 __gshared {
326 pglBindTransformFeedback glBindTransformFeedback;
327 pglDeleteTransformFeedbacks glDeleteTransformFeedbacks;
328 pglGenTransformFeedbacks glGenTransformFeedbacks;
329 pglIsTransformFeedback glIsTransformFeedback;
330 pglPauseTransformFeedback glPauseTransformFeedback;
331 pglResumeTransformFeedback glResumeTransformFeedback;
332 pglDrawTransformFeedback glDrawTransformFeedback;
333 }
334
335 private @nogc nothrow
336 bool loadARBTransformFeedback2(SharedLib lib, GLSupport contextVersion)
337 {
338 lib.bindGLSymbol(cast(void**)&glBindTransformFeedback, "glBindTransformFeedback");
339 lib.bindGLSymbol(cast(void**)&glDeleteTransformFeedbacks, "glDeleteTransformFeedbacks");
340 lib.bindGLSymbol(cast(void**)&glGenTransformFeedbacks, "glGenTransformFeedbacks");
341 lib.bindGLSymbol(cast(void**)&glIsTransformFeedback, "glIsTransformFeedback");
342 lib.bindGLSymbol(cast(void**)&glPauseTransformFeedback, "glPauseTransformFeedback");
343 lib.bindGLSymbol(cast(void**)&glResumeTransformFeedback, "glResumeTransformFeedback");
344 lib.bindGLSymbol(cast(void**)&glDrawTransformFeedback, "glDrawTransformFeedback");
345 return resetErrorCountGL();
346 }
347 }
348 else enum hasARBTransformFeedback2 = false;
349
350 // ARB_transform_feedback3
351 version(GL_ARB) enum useARBTransformFeedback3 = true;
352 else version(GL_ARB_transform_feedback3) enum useARBTransformFeedback3 = true;
353 else enum useARBTransformFeedback3 = has40;
354
355 static if(useARBTransformFeedback3) {
356 private bool _hasARBTransformFeedback3;
357 @nogc nothrow bool hasARBTransformFeedback3() { return _hasARBTransformFeedback3; }
358
359 enum : uint {
360 GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70,
361 GL_MAX_VERTEX_STREAMS = 0x8E71,
362 }
363
364 extern(System) @nogc nothrow {
365 alias pglDrawTransformFeedbackStream = void function(GLenum, GLuint, GLuint);
366 alias pglBeginQueryIndexed = void function(GLenum, GLuint, GLuint);
367 alias pglEndQueryIndexed = void function(GLenum, GLuint);
368 alias pglGetQueryIndexediv = void function(GLenum, GLuint, GLenum, GLint*);
369 }
370
371 __gshared {
372 pglDrawTransformFeedbackStream glDrawTransformFeedbackStream;
373 pglBeginQueryIndexed glBeginQueryIndexed;
374 pglEndQueryIndexed glEndQueryIndexed;
375 pglGetQueryIndexediv glGetQueryIndexediv;
376 }
377
378 private @nogc nothrow
379 bool loadARBTransformFeedback3(SharedLib lib, GLSupport contextVersion)
380 {
381 lib.bindGLSymbol(cast(void**)&glDrawTransformFeedbackStream, "glDrawTransformFeedbackStream");
382 lib.bindGLSymbol(cast(void**)&glBeginQueryIndexed, "glBeginQueryIndexed");
383 lib.bindGLSymbol(cast(void**)&glEndQueryIndexed, "glEndQueryIndexed");
384 lib.bindGLSymbol(cast(void**)&glGetQueryIndexediv, "glGetQueryIndexediv");
385 return resetErrorCountGL();
386 }
387 }
388 else enum hasARBTransformFeedback3 = false;
389
390 package(bindbc.opengl) @nogc nothrow
391 bool loadARB40(SharedLib lib, GLSupport contextVersion)
392 {
393 static if(has40) {
394 if(contextVersion >= GLSupport.gl40) {
395 _hasARBGPUShader5 = true;
396
397 bool ret = true;
398 ret = _hasARBDrawIndirect = lib.loadARBDrawIndirect(contextVersion);
399 ret = _hasARBGPUShaderFP64 = lib.loadARBGPUShaderFP64(contextVersion);
400 ret = _hasARBShaderSubroutine = lib.loadARBShaderSubroutine(contextVersion);
401 ret = _hasARBTesselationShader = lib.loadARBTesselationShader(contextVersion);
402 ret = _hasARBTransformFeedback2 = lib.loadARBTransformFeedback2(contextVersion);
403 ret = _hasARBTransformFeedback3 = lib.loadARBTransformFeedback3(contextVersion);
404 return ret;
405 }
406 }
407
408 static if(useARBGPUShader5) _hasARBGPUShader5 =
409 hasExtension(contextVersion, "GL_ARB_gpu_shader5");
410
411 static if(useARBDrawIndirect) _hasARBDrawIndirect =
412 hasExtension(contextVersion, "GL_ARB_draw_indirect") &&
413 lib.loadARBDrawIndirect(contextVersion);
414
415 static if(useARBGPUShaderFP64) _hasARBGPUShaderFP64 =
416 hasExtension(contextVersion, "GL_ARB_gpu_shader_fp64") &&
417 lib.loadARBGPUShaderFP64(contextVersion);
418
419 static if(useARBShaderSubroutine) _hasARBShaderSubroutine =
420 hasExtension(contextVersion, "GL_ARB_shader_subroutine") &&
421 lib.loadARBShaderSubroutine(contextVersion);
422
423 static if(useARBTesselationShader) _hasARBTesselationShader =
424 hasExtension(contextVersion, "GL_ARB_tessellation_shader") &&
425 lib.loadARBTesselationShader(contextVersion);
426
427 static if(useARBTransformFeedback2) _hasARBTransformFeedback2 =
428 hasExtension(contextVersion, "GL_ARB_transform_feedback2") &&
429 lib.loadARBTransformFeedback2(contextVersion);
430
431 static if(useARBTransformFeedback3) _hasARBTransformFeedback3 =
432 hasExtension(contextVersion, "GL_ARB_transform_feedback3") &&
433 lib.loadARBTransformFeedback3(contextVersion);
434
435 return true;
436 }