1 2 // Copyright Michael D. Parker 2018. 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_32; 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.gl32) { 15 enum has32 = true; 16 } 17 else enum has32 = false; 18 19 // ARB_depth_clamp 20 version(GL_ARB) enum useARBDepthClamp = true; 21 else version(GL_ARB_depth_clamp) enum useARBDepthClamp = true; 22 else enum useARBDepthClamp = has32; 23 24 static if(useARBDepthClamp) { 25 private bool _hasARBDepthClamp; 26 bool hasARBDepthClamp() { return _hasARBDepthClamp; } 27 28 enum uint GL_DEPTH_CLAMP = 0x864F; 29 } 30 else enum hasARBDepthClamp = false; 31 32 // ARB_provoking_vertex 33 version(GL_ARB) enum useARBProvokingVertex = true; 34 else version(GL_ARB_provoking_vertex) enum useARBProvokingVertex = true; 35 else enum useARBProvokingVertex = has32; 36 37 static if(useARBProvokingVertex) { 38 private bool _hasARBProvokingVertex; 39 bool hasARBProvokingVertex() { return _hasARBProvokingVertex; } 40 41 enum : uint { 42 GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C, 43 GL_FIRST_VERTEX_CONVENTION = 0x8E4D, 44 GL_LAST_VERTEX_CONVENTION = 0x8E4E, 45 GL_PROVOKING_VERTEX = 0x8E4F, 46 } 47 } 48 else enum hasARBProvokingVertex = false; 49 50 // ARB_seamless_cube_map 51 version(GL_ARB) enum useARBSeamlessCubeMap = true; 52 else version(GL_ARB_seamless_cube_map) enum useARBSeamlessCubeMap = true; 53 else enum useARBSeamlessCubeMap = has32; 54 55 static if(useARBSeamlessCubeMap) { 56 private bool _hasARBSeamlessCubeMap; 57 bool hasARBSeamlessCubeMap() { return _hasARBSeamlessCubeMap; } 58 59 enum uint GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; 60 } 61 else enum hasARBSeamlessCubeMap = false; 62 63 // ARB_draw_elements_base_vertex 64 version(GL_ARB) enum useARBDrawElementsBaseVertex = true; 65 else version(GL_ARB_draw_elements_base_vertex) enum useARBDrawElementsBaseVertex = true; 66 else enum useARBDrawElementsBaseVertex = has32; 67 68 static if(useARBDrawElementsBaseVertex) { 69 private bool _hasARBDrawElementsBaseVertex; 70 bool hasARBDrawElementsBaseVertex() { return _hasARBDrawElementsBaseVertex; } 71 72 extern(System) @nogc nothrow { 73 alias pglDrawElementsBaseVertex = void function(GLenum, GLsizei, GLenum, const(GLvoid)*, GLint); 74 alias pglDrawRangeElementsBaseVertex = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(GLvoid)*, GLint); 75 alias pglDrawElementsInstancedBaseVertex = void function(GLenum, GLsizei, GLenum, const(GLvoid)*, GLsizei, GLint); 76 alias pglMultiDrawElementsBaseVertex = void function(GLenum, const(GLsizei)*, GLenum, const(GLvoid*)*, GLsizei, const(GLint)*); 77 } 78 79 __gshared { 80 pglDrawElementsBaseVertex glDrawElementsBaseVertex; 81 pglDrawRangeElementsBaseVertex glDrawRangeElementsBaseVertex; 82 pglDrawElementsInstancedBaseVertex glDrawElementsInstancedBaseVertex; 83 pglMultiDrawElementsBaseVertex glMultiDrawElementsBaseVertex; 84 } 85 86 private @nogc nothrow 87 bool loadARBDrawElementsBaseVertex(SharedLib lib, GLSupport contextVersion) 88 { 89 lib.bindGLSymbol(cast(void**)&glDrawElementsBaseVertex, "glDrawElementsBaseVertex"); 90 lib.bindGLSymbol(cast(void**)&glDrawRangeElementsBaseVertex, "glDrawRangeElementsBaseVertex"); 91 lib.bindGLSymbol(cast(void**)&glDrawElementsInstancedBaseVertex, "glDrawElementsInstancedBaseVertex"); 92 lib.bindGLSymbol(cast(void**)&glMultiDrawElementsBaseVertex, "glMultiDrawElementsBaseVertex"); 93 return resetErrorCountGL(); 94 } 95 } 96 else enum hasARBDrawElementsBaseVertex = false; 97 98 // ARB_geometry_shader4 99 version(GL_ARB) enum useARBGeometryShader4 = true; 100 else version(GL_ARB_geometry_shader4) enum useARBGeometryShader4 = true; 101 else enum useARBGeometryShader4 = has32; 102 103 static if(useARBGeometryShader4) { 104 private bool _hasARBGeometryShader4; 105 bool hasARBGeometryShader4() { return _hasARBGeometryShader4; } 106 107 enum : uint { 108 GL_LINES_ADJACENCY_ARB = 0x000A, 109 GL_LINE_STRIP_ADJACENCY_ARB = 0x000B, 110 GL_TRIANGLES_ADJACENCY_ARB = 0x000C, 111 GL_TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D, 112 GL_PROGRAM_POINT_SIZE_ARB = 0x8642, 113 GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29, 114 GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7, 115 GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8, 116 GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9, 117 GL_GEOMETRY_SHADER_ARB = 0x8DD9, 118 GL_GEOMETRY_VERTICES_OUT_ARB = 0x8DDA, 119 GL_GEOMETRY_INPUT_TYPE_ARB = 0x8DDB, 120 GL_GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC, 121 GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD, 122 GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE, 123 GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF, 124 GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0, 125 GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1, 126 } 127 128 extern(System) @nogc nothrow { 129 alias pglProgramParameteriARB = void function(GLuint,GLenum,GLint); 130 alias pglFramebufferTextureARB = void function(GLuint,GLenum,GLuint,GLint); 131 alias pglFramebufferTextureLayerARB = void function(GLuint,GLenum,GLuint,GLint,GLint); 132 alias pglFramebufferTextureFaceARB = void function(GLuint,GLenum,GLuint,GLint,GLenum); 133 } 134 135 __gshared { 136 pglProgramParameteriARB glProgramParameteriARB; 137 pglFramebufferTextureARB glFramebufferTextureARB; 138 pglFramebufferTextureLayerARB glFramebufferTextureLayerARB; 139 pglFramebufferTextureFaceARB glFramebufferTextureFaceARB; 140 } 141 142 private @nogc nothrow 143 bool loadARBGeometryShader4(SharedLib lib, GLSupport contextVersion) 144 { 145 lib.bindGLSymbol(cast(void**)&glProgramParameteriARB,"glProgramParameteriARB"); 146 lib.bindGLSymbol(cast(void**)&glFramebufferTextureARB,"glFramebufferTextureARB"); 147 lib.bindGLSymbol(cast(void**)&glFramebufferTextureLayerARB,"glFramebufferTextureLayerARB"); 148 lib.bindGLSymbol(cast(void**)&glFramebufferTextureFaceARB,"glFramebufferTextureFaceARB"); 149 return resetErrorCountGL(); 150 } 151 } 152 else enum hasARBGeometryShader4 = false; 153 154 // ARB_sync 155 version(GL_ARB) enum useARBSync = true; 156 else version(GL_ARB_sync) enum useARBSync = true; 157 else enum useARBSync = has32; 158 159 alias GLint64 = long; 160 alias GLuint64 = ulong; 161 struct __GLsync; 162 alias __GLsync* GLsync; 163 164 static if(useARBSync) { 165 private bool _hasARBSync; 166 bool hasARBSync() { return _hasARBSync; } 167 168 enum : uint { 169 GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111, 170 GL_OBJECT_TYPE = 0x9112, 171 GL_SYNC_CONDITION = 0x9113, 172 GL_SYNC_STATUS = 0x9114, 173 GL_SYNC_FLAGS = 0x9115, 174 GL_SYNC_FENCE = 0x9116, 175 GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117, 176 GL_UNSIGNALED = 0x9118, 177 GL_SIGNALED = 0x9119, 178 GL_ALREADY_SIGNALED = 0x911A, 179 GL_TIMEOUT_EXPIRED = 0x911B, 180 GL_CONDITION_SATISFIED = 0x911C, 181 GL_WAIT_FAILED = 0x911D, 182 GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001, 183 } 184 185 extern(System) @nogc nothrow { 186 alias pglFenceSync = GLsync function(GLenum, GLbitfield); 187 alias pglIsSync = GLboolean function(GLsync); 188 alias pglDeleteSync = void function(GLsync); 189 alias pglClientWaitSync = GLenum function(GLsync, GLbitfield, GLuint64); 190 alias pglWaitSync = void function(GLsync, GLbitfield, GLuint64); 191 alias pglGetInteger64v = void function(GLsync, GLint64*); 192 alias pglGetSynciv = void function(GLsync, GLenum, GLsizei, GLsizei*, GLint*); 193 } 194 195 __gshared { 196 pglFenceSync glFenceSync; 197 pglIsSync glIsSync; 198 pglDeleteSync glDeleteSync; 199 pglClientWaitSync glClientWaitSync; 200 pglWaitSync glWaitSync; 201 pglGetInteger64v glGetInteger64v; 202 pglGetSynciv glGetSynciv; 203 } 204 205 private @nogc nothrow 206 bool loadARBSync(SharedLib lib, GLSupport contextVersion) 207 { 208 lib.bindGLSymbol(cast(void**)&glFenceSync, "glFenceSync"); 209 lib.bindGLSymbol(cast(void**)&glIsSync, "glIsSync"); 210 lib.bindGLSymbol(cast(void**)&glDeleteSync, "glDeleteSync"); 211 lib.bindGLSymbol(cast(void**)&glClientWaitSync, "glClientWaitSync"); 212 lib.bindGLSymbol(cast(void**)&glWaitSync, "glWaitSync"); 213 lib.bindGLSymbol(cast(void**)&glGetInteger64v, "glGetInteger64v"); 214 lib.bindGLSymbol(cast(void**)&glGetSynciv, "glGetSynciv"); 215 return resetErrorCountGL(); 216 } 217 } 218 else enum hasARBSync = false; 219 220 // ARB_texture_multisample 221 version(GL_ARB) enum useARBTextureMultiSample = true; 222 else version(GL_ARB_texture_multisample) enum useARBTextureMultiSample = true; 223 else enum useARBTextureMultiSample = has32; 224 225 static if(useARBTextureMultiSample) { 226 private bool _hasARBTextureMultiSample; 227 bool hasARBTextureMultiSample() { return _hasARBTextureMultiSample; } 228 229 enum : uint { 230 GL_SAMPLE_POSITION = 0x8E50, 231 GL_SAMPLE_MASK = 0x8E51, 232 GL_SAMPLE_MASK_VALUE = 0x8E52, 233 GL_MAX_SAMPLE_MASK_WORDS = 0x8E59, 234 GL_TEXTURE_2D_MULTISAMPLE = 0x9100, 235 GL_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101, 236 GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102, 237 GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103, 238 GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104, 239 GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105, 240 GL_TEXTURE_SAMPLES = 0x9106, 241 GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107, 242 GL_SAMPLER_2D_MULTISAMPLE = 0x9108, 243 GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109, 244 GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A, 245 GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B, 246 GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C, 247 GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D, 248 GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E, 249 GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F, 250 GL_MAX_INTEGER_SAMPLES = 0x9110, 251 } 252 253 extern(System) @nogc nothrow { 254 alias pglTexImage2DMultisample = void function(GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean); 255 alias pglTexImage3DMultisample = void function(GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean); 256 alias pglGetMultisamplefv = void function(GLenum, GLuint, GLfloat*); 257 alias pglSampleMaski = void function(GLuint, GLbitfield); 258 } 259 260 __gshared { 261 pglTexImage2DMultisample glTexImage2DMultisample; 262 pglTexImage3DMultisample glTexImage3DMultisample; 263 pglGetMultisamplefv glGetMultisamplefv; 264 pglSampleMaski glSampleMaski; 265 } 266 267 private @nogc nothrow 268 bool loadTextureMultiSample(SharedLib lib, GLSupport contextVersion) 269 { 270 lib.bindGLSymbol(cast(void**)&glTexImage2DMultisample, "glTexImage2DMultisample"); 271 lib.bindGLSymbol(cast(void**)&glTexImage3DMultisample, "glTexImage3DMultisample"); 272 lib.bindGLSymbol(cast(void**)&glGetMultisamplefv, "glGetMultisamplefv"); 273 lib.bindGLSymbol(cast(void**)&glSampleMaski, "glSampleMaski"); 274 return resetErrorCountGL(); 275 } 276 } 277 else enum hasARBTextureMultiSample = false; 278 279 package(bindbc.opengl) @nogc nothrow 280 bool loadARB32(SharedLib lib, GLSupport contextVersion) 281 { 282 static if(has32) { 283 if(contextVersion >= GLSupport.gl32) { 284 _hasARBDepthClamp = true; 285 _hasARBProvokingVertex = true; 286 _hasARBSeamlessCubeMap = true; 287 288 bool ret = true; 289 ret = _hasARBDrawElementsBaseVertex = lib.loadARBDrawElementsBaseVertex(contextVersion); 290 ret = _hasARBGeometryShader4 = lib.loadARBGeometryShader4(contextVersion); 291 ret = _hasARBSync = lib.loadARBSync(contextVersion); 292 ret = _hasARBTextureMultiSample = lib.loadTextureMultiSample(contextVersion); 293 return ret; 294 } 295 } 296 297 static if(useARBDepthClamp) _hasARBDepthClamp = 298 hasExtension(contextVersion, "GL_ARB_depth_clamp"); 299 300 static if(useARBProvokingVertex) _hasARBProvokingVertex = 301 hasExtension(contextVersion, "GL_ARB_provoking_vertex"); 302 303 static if(useARBSeamlessCubeMap) _hasARBSeamlessCubeMap = 304 hasExtension(contextVersion, "GL_ARB_seamless_cube_map"); 305 306 static if(useARBDrawElementsBaseVertex) _hasARBDrawElementsBaseVertex = 307 hasExtension(contextVersion, "GL_ARB_draw_elements_base_vertex") && 308 lib.loadARBDrawElementsBaseVertex(contextVersion); 309 310 static if(useARBGeometryShader4) _hasARBGeometryShader4 = 311 hasExtension(contextVersion, "GL_ARB_geometry_shader4") && 312 lib.loadARBGeometryShader4(contextVersion); 313 314 static if(useARBSync) _hasARBSync = 315 hasExtension(contextVersion, "GL_ARB_sync") && 316 lib.loadARBSync(contextVersion); 317 318 static if(useARBTextureMultiSample) _hasARBTextureMultiSample = 319 hasExtension(contextVersion, "GL_ARB_texture_multisample") && 320 lib.loadTextureMultiSample(contextVersion); 321 322 return true; 323 }