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_33; 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.gl33) { 15 enum has33 = true; 16 } 17 else enum has33 = 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 bool hasARBOcclusionQuery2() { return _hasARBOcclusionQuery2; } 27 28 enum uint GL_ANY_SAMPLES_PASSED = 0x8C2F; 29 } 30 else enum hasARBOcclusionQuery2 = false; 31 32 // ARB_texture_swizzle 33 version(GL_ARB) enum useARBTextureSwizzle = true; 34 else version(GL_ARB_texture_swizzle) enum useARBTextureSwizzle = true; 35 else enum useARBTextureSwizzle = has33; 36 37 static if(useARBTextureSwizzle) { 38 private bool _hasARBTextureSwizzle; 39 bool hasARBTextureSwizzle() { return _hasARBTextureSwizzle; } 40 41 enum : uint { 42 GL_TEXTURE_SWIZZLE_R = 0x8E42, 43 GL_TEXTURE_SWIZZLE_G = 0x8E43, 44 GL_TEXTURE_SWIZZLE_B = 0x8E44, 45 GL_TEXTURE_SWIZZLE_A = 0x8E45, 46 GL_TEXTURE_SWIZZLE_RGBA = 0x8E46, 47 } 48 } 49 else enum hasARBTextureSwizzle = false; 50 51 // ARB_blend_func_extended 52 version(GL_ARB) enum useARBBlendFuncExtended = true; 53 else version(GL_ARB_blend_func_extended) enum useARBBlendFuncExtended = true; 54 else enum useARBBlendFuncExtended = has33; 55 56 static if(useARBBlendFuncExtended) { 57 private bool _hasARBBlendFuncExtended; 58 bool hasARBBlendFuncExtended() { return _hasARBBlendFuncExtended; } 59 60 enum : uint { 61 GL_SRC1_COLOR = 0x88F9, 62 GL_ONE_MINUS_SRC1_COLOR = 0x88FA, 63 GL_ONE_MINUS_SRC1_ALPHA = 0x88FB, 64 GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC, 65 } 66 67 extern(System) @nogc nothrow { 68 alias pglBindFragDataLocationIndexed = void function(GLuint, GLuint, GLuint, const(GLchar)*); 69 alias pglGetFragDataIndex = GLint function(GLuint, const(GLchar)*); 70 } 71 72 __gshared { 73 pglBindFragDataLocationIndexed glBindFragDataLocationIndexed; 74 pglGetFragDataIndex glGetFragDataIndex; 75 } 76 77 private @nogc nothrow 78 bool loadARBBlendFuncExtended(SharedLib lib, GLSupport contextVersion) 79 { 80 lib.bindGLSymbol(cast(void**)&glBindFragDataLocationIndexed, "glBindFragDataLocationIndexed"); 81 lib.bindGLSymbol(cast(void**)&glGetFragDataIndex, "glGetFragDataIndex"); 82 return resetErrorCountGL(); 83 } 84 } 85 else enum hasARBBlendFuncExtended = false; 86 87 // ARB_sampler_objects 88 version(GL_ARB) enum useARBSamplerObjects = true; 89 else version(GL_ARB_sampler_objects) enum useARBSamplerObjects = true; 90 else enum useARBSamplerObjects = has33; 91 92 static if(useARBSamplerObjects) { 93 private bool _hasARBSamplerObjects; 94 bool hasARBSamplerObjects() { return _hasARBSamplerObjects; } 95 96 enum uint GL_SAMPLER_BINDING = 0x8919; 97 98 extern(System) @nogc nothrow { 99 alias pglGenSamplers = void function(GLsizei, GLuint*); 100 alias pglDeleteSamplers = void function(GLsizei, const(GLuint)*); 101 alias pglIsSampler = GLboolean function(GLuint); 102 alias pglBindSampler = void function(GLuint, GLuint); 103 alias pglSamplerParameteri = void function(GLuint, GLenum, GLint); 104 alias pglSamplerParameteriv = void function(GLuint, GLenum, const(GLint)*); 105 alias pglSamplerParameterf = void function(GLuint, GLenum, GLfloat); 106 alias pglSamplerParameterfv = void function(GLuint, GLenum, const(GLfloat)*); 107 alias pglSamplerParameterIiv = void function(GLuint, GLenum, const(GLint)*); 108 alias pglSamplerParameterIuiv = void function(GLuint, GLenum, const(GLuint)*); 109 alias pglGetSamplerParameteriv = void function(GLuint, GLenum, GLint*); 110 alias pglGetSamplerParameterIiv = void function(GLuint, GLenum, GLint*); 111 alias pglGetSamplerParameterfv = void function(GLuint, GLenum, GLfloat*); 112 alias pglGetSamplerParameterIuiv = void function(GLuint, GLenum, GLuint*); 113 } 114 115 __gshared { 116 pglGenSamplers glGenSamplers; 117 pglDeleteSamplers glDeleteSamplers; 118 pglIsSampler glIsSampler; 119 pglBindSampler glBindSampler; 120 pglSamplerParameteri glSamplerParameteri; 121 pglSamplerParameteriv glSamplerParameteriv; 122 pglSamplerParameterf glSamplerParameterf; 123 pglSamplerParameterfv glSamplerParameterfv; 124 pglSamplerParameterIiv glSamplerParameterIiv; 125 pglSamplerParameterIuiv glSamplerParameterIuiv; 126 pglGetSamplerParameteriv glGetSamplerParameteriv; 127 pglGetSamplerParameterIiv glGetSamplerParameterIiv; 128 pglGetSamplerParameterfv glGetSamplerParameterfv; 129 pglGetSamplerParameterIuiv glGetSamplerParameterIuiv; 130 } 131 132 private @nogc nothrow 133 bool loadARBSamplerObjects(SharedLib lib, GLSupport contextVersion) 134 { 135 lib.bindGLSymbol(cast(void**)&glGenSamplers, "glGenSamplers"); 136 lib.bindGLSymbol(cast(void**)&glDeleteSamplers, "glDeleteSamplers"); 137 lib.bindGLSymbol(cast(void**)&glIsSampler, "glIsSampler"); 138 lib.bindGLSymbol(cast(void**)&glBindSampler, "glBindSampler"); 139 lib.bindGLSymbol(cast(void**)&glSamplerParameteri, "glSamplerParameteri"); 140 lib.bindGLSymbol(cast(void**)&glSamplerParameteriv, "glSamplerParameteriv"); 141 lib.bindGLSymbol(cast(void**)&glSamplerParameterf, "glSamplerParameterf"); 142 lib.bindGLSymbol(cast(void**)&glSamplerParameterfv, "glSamplerParameterfv"); 143 lib.bindGLSymbol(cast(void**)&glSamplerParameterIiv, "glSamplerParameterIiv"); 144 lib.bindGLSymbol(cast(void**)&glSamplerParameterIuiv, "glSamplerParameterIuiv"); 145 lib.bindGLSymbol(cast(void**)&glGetSamplerParameteriv, "glGetSamplerParameteriv"); 146 lib.bindGLSymbol(cast(void**)&glGetSamplerParameterIiv, "glGetSamplerParameterIiv"); 147 lib.bindGLSymbol(cast(void**)&glGetSamplerParameterfv, "glGetSamplerParameterfv"); 148 lib.bindGLSymbol(cast(void**)&glGetSamplerParameterIuiv, "glGetSamplerParameterIuiv"); 149 return resetErrorCountGL(); 150 } 151 } 152 else enum hasARBSamplerObjects = false; 153 154 // ARB_timer_query 155 version(GL_ARB) enum useARBTimerQuery = true; 156 else version(GL_ARB_timer_query) enum useARBTimerQuery = true; 157 else enum useARBTimerQuery = has33; 158 159 static if(useARBTimerQuery) { 160 private bool _hasARBTimerQuery; 161 bool hasARBTimerQuery() { return _hasARBTimerQuery; } 162 163 enum : uint { 164 GL_TIME_ELAPSED = 0x88BF, 165 GL_TIMESTAMP = 0x8E28, 166 } 167 168 extern(System) @nogc nothrow { 169 alias pglQueryCounter = void function(GLuint, GLenum); 170 alias pglGetQueryObjecti64v = void function(GLuint, GLenum, GLint64*); 171 alias pglGetQueryObjectui64v = void function(GLuint, GLenum, GLuint64*); 172 } 173 174 __gshared { 175 pglQueryCounter glQueryCounter; 176 pglGetQueryObjecti64v glGetQueryObjecti64v; 177 pglGetQueryObjectui64v glGetQueryObjectui64v; 178 } 179 180 private @nogc nothrow 181 bool loadARBTimerQuery(SharedLib lib, GLSupport contextVersion) 182 { 183 lib.bindGLSymbol(cast(void**)&glQueryCounter, "glQueryCounter"); 184 lib.bindGLSymbol(cast(void**)&glGetQueryObjecti64v, "glGetQueryObjecti64v"); 185 lib.bindGLSymbol(cast(void**)&glGetQueryObjectui64v, "glGetQueryObjectui64v"); 186 return resetErrorCountGL(); 187 } 188 } 189 else enum hasARBTimerQuery = false; 190 191 // ARB_vertex_type_2_10_10_10_rev 192 version(GL_ARB) enum useARBVertexType2101010Rev = true; 193 else version(GL_ARB_vertex_type_2_10_10_10_rev) enum useARBVertexType2101010Rev = true; 194 else enum useARBVertexType2101010Rev = has33; 195 196 static if(useARBVertexType2101010Rev) { 197 private bool _hasARBVertexType2101010Rev; 198 bool hasARBVertexType2101010Rev() { return _hasARBVertexType2101010Rev; } 199 200 enum uint GL_INT_2_10_10_10_REV = 0x8D9F; 201 202 extern(System) @nogc nothrow { 203 // A note in derelict says these aren't actually part of the core and doesn't 204 // load them on Mac. Don't remember why I wrote that, so I need to dig into it. 205 /* 206 alias pglVertexP2ui = void function(GLenum, GLuint); 207 alias pglVertexP2uiv = void function(GLenum, const(GLuint)*); 208 alias pglVertexP3ui = void function(GLenum, GLuint); 209 alias pglVertexP3uiv = void function(GLenum, const(GLuint)*); 210 alias pglVertexP4ui = void function(GLenum, GLuint); 211 alias pglVertexP4uiv = void function(GLenum, const(GLuint)*); 212 alias pglTexCoordP1ui = void function(GLenum, GLuint); 213 alias pglTexCoordP1uiv = void function(GLenum, const(GLuint)*); 214 alias pglTexCoordP2ui = void function(GLenum, GLuint); 215 alias pglTexCoordP2uiv = void function(GLenum, const(GLuint)*); 216 alias pglTexCoordP3ui = void function(GLenum, GLuint); 217 alias pglTexCoordP3uiv = void function(GLenum, const(GLuint)*); 218 alias pglTexCoordP4ui = void function(GLenum, GLuint); 219 alias pglTexCoordP4uiv = void function(GLenum, const(GLuint)*); 220 alias pglMultiTexCoordP1ui = void function(GLenum, GLenum, GLuint); 221 alias pglMultiTexCoordP1uiv = void function(GLenum, GLenum, const(GLuint)*); 222 alias pglMultiTexCoordP2ui = void function(GLenum, GLenum, GLuint); 223 alias pglMultiTexCoordP2uiv = void function(GLenum, GLenum, const(GLuint)*); 224 alias pglMultiTexCoordP3ui = void function(GLenum, GLenum, GLuint); 225 alias pglMultiTexCoordP3uiv = void function(GLenum, GLenum, const(GLuint)*); 226 alias pglMultiTexCoordP4ui = void function(GLenum, GLenum, GLuint); 227 alias pglMultiTexCoordP4uiv = void function(GLenum, GLenum, const(GLuint)*); 228 alias pglNormalP3ui = void function(GLenum, GLuint); 229 alias pglNormalP3uiv = void function(GLenum, const(GLuint)*); 230 alias pglColorP3ui = void function(GLenum, GLuint); 231 alias pglColorP3uiv = void function(GLenum, const(GLuint)*); 232 alias pglColorP4ui = void function(GLenum, GLuint); 233 alias pglColorP4uiv = void function(GLenum, const(GLuint)*); 234 alias pglSecondaryColorP3ui = void function(GLenum, GLuint); 235 alias pglSecondaryColorP3uiv = void function(GLenum, const(GLuint)*); 236 */ 237 alias pglVertexAttribP1ui = void function(GLuint, GLenum, GLboolean, GLuint); 238 alias pglVertexAttribP1uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); 239 alias pglVertexAttribP2ui = void function(GLuint, GLenum, GLboolean, GLuint); 240 alias pglVertexAttribP2uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); 241 alias pglVertexAttribP3ui = void function(GLuint, GLenum, GLboolean, GLuint); 242 alias pglVertexAttribP3uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); 243 alias pglVertexAttribP4ui = void function(GLuint, GLenum, GLboolean, GLuint); 244 alias pglVertexAttribP4uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); 245 } 246 247 __gshared { 248 /* 249 pglVertexP2ui glVertexP2ui; 250 pglVertexP2uiv glVertexP2uiv; 251 pglVertexP3ui glVertexP3ui; 252 pglVertexP3uiv glVertexP3uiv; 253 pglVertexP4ui glVertexP4ui; 254 pglVertexP4uiv glVertexP4uiv; 255 pglTexCoordP1ui glTexCoordP1ui; 256 pglTexCoordP1uiv glTexCoordP1uiv; 257 pglTexCoordP2ui glTexCoordP2ui; 258 pglTexCoordP2uiv glTexCoordP2uiv; 259 pglTexCoordP3ui glTexCoordP3ui; 260 pglTexCoordP3uiv glTexCoordP3uiv; 261 pglTexCoordP4ui glTexCoordP4ui; 262 pglTexCoordP4uiv glTexCoordP4uiv; 263 pglMultiTexCoordP1ui glMultiTexCoordP1ui; 264 pglMultiTexCoordP1uiv glMultiTexCoordP1uiv; 265 pglMultiTexCoordP2ui glMultiTexCoordP2ui; 266 pglMultiTexCoordP2uiv glMultiTexCoordP2uiv; 267 pglMultiTexCoordP3ui glMultiTexCoordP3ui; 268 pglMultiTexCoordP3uiv glMultiTexCoordP3uiv; 269 pglMultiTexCoordP4ui glMultiTexCoordP4ui; 270 pglMultiTexCoordP4uiv glMultiTexCoordP4uiv; 271 pglNormalP3ui glNormalP3ui; 272 pglNormalP3uiv glNormalP3uiv; 273 pglColorP3ui glColorP3ui; 274 pglColorP3uiv glColorP3uiv; 275 pglColorP4ui glColorP4ui; 276 pglColorP4uiv glColorP4uiv; 277 pglSecondaryColorP3ui glSecondaryColorP3ui; 278 pglSecondaryColorP3uiv glSecondaryColorP3uiv; 279 */ 280 pglVertexAttribP1ui glVertexAttribP1ui; 281 pglVertexAttribP1uiv glVertexAttribP1uiv; 282 pglVertexAttribP2ui glVertexAttribP2ui; 283 pglVertexAttribP2uiv glVertexAttribP2uiv; 284 pglVertexAttribP3ui glVertexAttribP3ui; 285 pglVertexAttribP3uiv glVertexAttribP3uiv; 286 pglVertexAttribP4ui glVertexAttribP4ui; 287 pglVertexAttribP4uiv glVertexAttribP4uiv; 288 } 289 290 private @nogc nothrow 291 bool loadARBVertexType2101010Rev(SharedLib lib, GLSupport contextVersion) 292 { 293 lib.bindGLSymbol(cast(void**)&glVertexAttribP1ui, "glVertexAttribP1ui"); 294 lib.bindGLSymbol(cast(void**)&glVertexAttribP1uiv, "glVertexAttribP1uiv"); 295 lib.bindGLSymbol(cast(void**)&glVertexAttribP2ui, "glVertexAttribP2ui"); 296 lib.bindGLSymbol(cast(void**)&glVertexAttribP2uiv, "glVertexAttribP2uiv"); 297 lib.bindGLSymbol(cast(void**)&glVertexAttribP3ui, "glVertexAttribP3ui"); 298 lib.bindGLSymbol(cast(void**)&glVertexAttribP3uiv, "glVertexAttribP3uiv"); 299 lib.bindGLSymbol(cast(void**)&glVertexAttribP4ui, "glVertexAttribP4ui"); 300 lib.bindGLSymbol(cast(void**)&glVertexAttribP4uiv, "glVertexAttribP4uiv"); 301 return resetErrorCountGL(); 302 } 303 } 304 else enum hasARBVertexType2101010Rev = false; 305 306 package(bindbc.opengl) @nogc nothrow 307 bool loadARB33(SharedLib lib, GLSupport contextVersion) 308 { 309 static if(has33) { 310 if(contextVersion >= GLSupport.gl33) { 311 _hasARBOcclusionQuery2 = true; 312 _hasARBTextureSwizzle = true; 313 314 bool ret = true; 315 ret = _hasARBBlendFuncExtended = lib.loadARBBlendFuncExtended(contextVersion); 316 ret = _hasARBSamplerObjects = lib.loadARBSamplerObjects(contextVersion); 317 ret = _hasARBTimerQuery = lib.loadARBTimerQuery(contextVersion); 318 ret = _hasARBVertexType2101010Rev = lib.loadARBVertexType2101010Rev(contextVersion); 319 return ret; 320 } 321 } 322 323 static if(useARBOcclusionQuery2) _hasARBOcclusionQuery2 = 324 hasExtension(contextVersion, "GL_ARB_occlusion_query2"); 325 326 static if(useARBTextureSwizzle) _hasARBTextureSwizzle = 327 hasExtension(contextVersion, "GL_ARB_texture_swizzle"); 328 329 static if(useARBBlendFuncExtended) _hasARBBlendFuncExtended = 330 hasExtension(contextVersion, "GL_ARB_blend_func_extended") && 331 lib.loadARBBlendFuncExtended(contextVersion); 332 333 static if(useARBSamplerObjects) _hasARBSamplerObjects = 334 hasExtension(contextVersion, "GL_ARB_sampler_objects") && 335 lib.loadARBSamplerObjects(contextVersion); 336 337 static if(useARBTimerQuery) _hasARBTimerQuery = 338 hasExtension(contextVersion, "GL_ARB_timer_query") && 339 lib.loadARBTimerQuery(contextVersion); 340 341 static if(useARBVertexType2101010Rev) _hasARBVertexType2101010Rev = 342 hasExtension(contextVersion, "GL_ARB_vertex_type_2_10_10_10_rev") && 343 lib.loadARBVertexType2101010Rev(contextVersion); 344 345 return true; 346 }