1 /** 2 * Dlang vulkan platform specific types and functions as mixin template 3 * 4 * Copyright: Copyright 2015-2016 The Khronos Group Inc.; Copyright 2016 Alex Parrill, Peter Particle. 5 * License: $(https://opensource.org/licenses/MIT, MIT License). 6 * Authors: Copyright 2016 Alex Parrill, Peter Particle 7 */ 8 module erupted.platform_extensions; 9 10 /// define platform extension names as enums 11 /// these enums can be used directly in Platform_Extensions mixin template 12 enum KHR_xlib_surface; 13 enum KHR_xcb_surface; 14 enum KHR_wayland_surface; 15 enum KHR_android_surface; 16 enum KHR_win32_surface; 17 enum KHR_external_memory_win32; 18 enum KHR_win32_keyed_mutex; 19 enum KHR_external_semaphore_win32; 20 enum KHR_external_fence_win32; 21 enum KHR_portability_subset; 22 enum GGP_stream_descriptor_surface; 23 enum NV_external_memory_win32; 24 enum NV_win32_keyed_mutex; 25 enum NN_vi_surface; 26 enum EXT_acquire_xlib_display; 27 enum MVK_ios_surface; 28 enum MVK_macos_surface; 29 enum ANDROID_external_memory_android_hardware_buffer; 30 enum GGP_frame_token; 31 enum FUCHSIA_imagepipe_surface; 32 enum EXT_metal_surface; 33 enum EXT_full_screen_exclusive; 34 enum NV_acquire_winrt_display; 35 enum EXT_directfb_surface; 36 37 38 /// extensions to a specific platform are grouped in these enum sequences 39 import std.meta : AliasSeq; 40 alias USE_PLATFORM_XLIB_KHR = AliasSeq!( KHR_xlib_surface ); 41 alias USE_PLATFORM_XCB_KHR = AliasSeq!( KHR_xcb_surface ); 42 alias USE_PLATFORM_WAYLAND_KHR = AliasSeq!( KHR_wayland_surface ); 43 alias USE_PLATFORM_ANDROID_KHR = AliasSeq!( KHR_android_surface, ANDROID_external_memory_android_hardware_buffer ); 44 alias USE_PLATFORM_WIN32_KHR = AliasSeq!( KHR_win32_surface, KHR_external_memory_win32, KHR_win32_keyed_mutex, KHR_external_semaphore_win32, KHR_external_fence_win32, NV_external_memory_win32, NV_win32_keyed_mutex, EXT_full_screen_exclusive, NV_acquire_winrt_display ); 45 alias ENABLE_BETA_EXTENSIONS = AliasSeq!( KHR_portability_subset ); 46 alias USE_PLATFORM_GGP = AliasSeq!( GGP_stream_descriptor_surface, GGP_frame_token ); 47 alias USE_PLATFORM_VI_NN = AliasSeq!( NN_vi_surface ); 48 alias USE_PLATFORM_XLIB_XRANDR_EXT = AliasSeq!( EXT_acquire_xlib_display ); 49 alias USE_PLATFORM_IOS_MVK = AliasSeq!( MVK_ios_surface ); 50 alias USE_PLATFORM_MACOS_MVK = AliasSeq!( MVK_macos_surface ); 51 alias USE_PLATFORM_FUCHSIA = AliasSeq!( FUCHSIA_imagepipe_surface ); 52 alias USE_PLATFORM_METAL_EXT = AliasSeq!( EXT_metal_surface ); 53 alias USE_PLATFORM_DIRECTFB_EXT = AliasSeq!( EXT_directfb_surface ); 54 55 56 57 /// instantiate platform and extension specific code with this mixin template 58 /// required types and data structures must be imported into the module where 59 /// this template is instantiated 60 mixin template Platform_Extensions( extensions... ) { 61 62 // publicly import erupted package modules 63 public import erupted.types; 64 public import erupted.functions; 65 import erupted.dispatch_device; 66 67 // mixin function linkage, nothrow and @nogc attributes for subsecuent functions 68 extern(System) nothrow @nogc: 69 70 // remove duplicates from alias sequence 71 // this might happen if a platform extension collection AND a single extension, which is included in the collection, was specified 72 // e.g.: mixin Platform_Extensions!( VK_USE_PLATFORM_WIN32_KHR, VK_KHR_external_memory_win32 ); 73 import std.meta : NoDuplicates; 74 alias noDuplicateExtensions = NoDuplicates!extensions; 75 76 // 1. loop through alias sequence and mixin corresponding 77 // extension types, aliased function pointer type definitions and __gshared function pointer declarations 78 static foreach( extension; noDuplicateExtensions ) { 79 80 // VK_KHR_xlib_surface : types and function pointer type aliases 81 static if( __traits( isSame, extension, KHR_xlib_surface )) { 82 enum VK_KHR_xlib_surface = 1; 83 84 enum VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; 85 enum VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; 86 87 alias VkXlibSurfaceCreateFlagsKHR = VkFlags; 88 89 struct VkXlibSurfaceCreateInfoKHR { 90 VkStructureType sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 91 const( void )* pNext; 92 VkXlibSurfaceCreateFlagsKHR flags; 93 Display* dpy; 94 Window window; 95 } 96 97 alias PFN_vkCreateXlibSurfaceKHR = VkResult function( VkInstance instance, const( VkXlibSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 98 alias PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ); 99 } 100 101 // VK_KHR_xcb_surface : types and function pointer type aliases 102 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 103 enum VK_KHR_xcb_surface = 1; 104 105 enum VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; 106 enum VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; 107 108 alias VkXcbSurfaceCreateFlagsKHR = VkFlags; 109 110 struct VkXcbSurfaceCreateInfoKHR { 111 VkStructureType sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 112 const( void )* pNext; 113 VkXcbSurfaceCreateFlagsKHR flags; 114 xcb_connection_t* connection; 115 xcb_window_t window; 116 } 117 118 alias PFN_vkCreateXcbSurfaceKHR = VkResult function( VkInstance instance, const( VkXcbSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 119 alias PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ); 120 } 121 122 // VK_KHR_wayland_surface : types and function pointer type aliases 123 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 124 enum VK_KHR_wayland_surface = 1; 125 126 enum VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6; 127 enum VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; 128 129 alias VkWaylandSurfaceCreateFlagsKHR = VkFlags; 130 131 struct VkWaylandSurfaceCreateInfoKHR { 132 VkStructureType sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 133 const( void )* pNext; 134 VkWaylandSurfaceCreateFlagsKHR flags; 135 const( wl_display )* display; 136 const( wl_surface )* surface; 137 } 138 139 alias PFN_vkCreateWaylandSurfaceKHR = VkResult function( VkInstance instance, const( VkWaylandSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 140 alias PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const( wl_display )* display ); 141 } 142 143 // VK_KHR_android_surface : types and function pointer type aliases 144 else static if( __traits( isSame, extension, KHR_android_surface )) { 145 enum VK_KHR_android_surface = 1; 146 147 alias ANativeWindow = ANativeWindow; 148 149 enum VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; 150 enum VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; 151 152 alias VkAndroidSurfaceCreateFlagsKHR = VkFlags; 153 154 struct VkAndroidSurfaceCreateInfoKHR { 155 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 156 const( void )* pNext; 157 VkAndroidSurfaceCreateFlagsKHR flags; 158 const( ANativeWindow )* window; 159 } 160 161 alias PFN_vkCreateAndroidSurfaceKHR = VkResult function( VkInstance instance, const( VkAndroidSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 162 } 163 164 // VK_KHR_win32_surface : types and function pointer type aliases 165 else static if( __traits( isSame, extension, KHR_win32_surface )) { 166 enum VK_KHR_win32_surface = 1; 167 168 enum VK_KHR_WIN32_SURFACE_SPEC_VERSION = 6; 169 enum VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; 170 171 alias VkWin32SurfaceCreateFlagsKHR = VkFlags; 172 173 struct VkWin32SurfaceCreateInfoKHR { 174 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 175 const( void )* pNext; 176 VkWin32SurfaceCreateFlagsKHR flags; 177 HINSTANCE hinstance; 178 HWND hwnd; 179 } 180 181 alias PFN_vkCreateWin32SurfaceKHR = VkResult function( VkInstance instance, const( VkWin32SurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 182 alias PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ); 183 } 184 185 // VK_KHR_external_memory_win32 : types and function pointer type aliases 186 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 187 enum VK_KHR_external_memory_win32 = 1; 188 189 enum VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 190 enum VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_KHR_external_memory_win32"; 191 192 struct VkImportMemoryWin32HandleInfoKHR { 193 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; 194 const( void )* pNext; 195 VkExternalMemoryHandleTypeFlagBits handleType; 196 HANDLE handle; 197 LPCWSTR name; 198 } 199 200 struct VkExportMemoryWin32HandleInfoKHR { 201 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; 202 const( void )* pNext; 203 const( SECURITY_ATTRIBUTES )* pAttributes; 204 DWORD dwAccess; 205 LPCWSTR name; 206 } 207 208 struct VkMemoryWin32HandlePropertiesKHR { 209 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; 210 void* pNext; 211 uint32_t memoryTypeBits; 212 } 213 214 struct VkMemoryGetWin32HandleInfoKHR { 215 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; 216 const( void )* pNext; 217 VkDeviceMemory memory; 218 VkExternalMemoryHandleTypeFlagBits handleType; 219 } 220 221 alias PFN_vkGetMemoryWin32HandleKHR = VkResult function( VkDevice device, const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 222 alias PFN_vkGetMemoryWin32HandlePropertiesKHR = VkResult function( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ); 223 } 224 225 // VK_KHR_win32_keyed_mutex : types and function pointer type aliases 226 else static if( __traits( isSame, extension, KHR_win32_keyed_mutex )) { 227 enum VK_KHR_win32_keyed_mutex = 1; 228 229 enum VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 230 enum VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_KHR_win32_keyed_mutex"; 231 232 struct VkWin32KeyedMutexAcquireReleaseInfoKHR { 233 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; 234 const( void )* pNext; 235 uint32_t acquireCount; 236 const( VkDeviceMemory )* pAcquireSyncs; 237 const( uint64_t )* pAcquireKeys; 238 const( uint32_t )* pAcquireTimeouts; 239 uint32_t releaseCount; 240 const( VkDeviceMemory )* pReleaseSyncs; 241 const( uint64_t )* pReleaseKeys; 242 } 243 244 } 245 246 // VK_KHR_external_semaphore_win32 : types and function pointer type aliases 247 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 248 enum VK_KHR_external_semaphore_win32 = 1; 249 250 enum VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1; 251 enum VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = "VK_KHR_external_semaphore_win32"; 252 253 struct VkImportSemaphoreWin32HandleInfoKHR { 254 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; 255 const( void )* pNext; 256 VkSemaphore semaphore; 257 VkSemaphoreImportFlags flags; 258 VkExternalSemaphoreHandleTypeFlagBits handleType; 259 HANDLE handle; 260 LPCWSTR name; 261 } 262 263 struct VkExportSemaphoreWin32HandleInfoKHR { 264 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; 265 const( void )* pNext; 266 const( SECURITY_ATTRIBUTES )* pAttributes; 267 DWORD dwAccess; 268 LPCWSTR name; 269 } 270 271 struct VkD3D12FenceSubmitInfoKHR { 272 VkStructureType sType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; 273 const( void )* pNext; 274 uint32_t waitSemaphoreValuesCount; 275 const( uint64_t )* pWaitSemaphoreValues; 276 uint32_t signalSemaphoreValuesCount; 277 const( uint64_t )* pSignalSemaphoreValues; 278 } 279 280 struct VkSemaphoreGetWin32HandleInfoKHR { 281 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; 282 const( void )* pNext; 283 VkSemaphore semaphore; 284 VkExternalSemaphoreHandleTypeFlagBits handleType; 285 } 286 287 alias PFN_vkImportSemaphoreWin32HandleKHR = VkResult function( VkDevice device, const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ); 288 alias PFN_vkGetSemaphoreWin32HandleKHR = VkResult function( VkDevice device, const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 289 } 290 291 // VK_KHR_external_fence_win32 : types and function pointer type aliases 292 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 293 enum VK_KHR_external_fence_win32 = 1; 294 295 enum VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1; 296 enum VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME = "VK_KHR_external_fence_win32"; 297 298 struct VkImportFenceWin32HandleInfoKHR { 299 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; 300 const( void )* pNext; 301 VkFence fence; 302 VkFenceImportFlags flags; 303 VkExternalFenceHandleTypeFlagBits handleType; 304 HANDLE handle; 305 LPCWSTR name; 306 } 307 308 struct VkExportFenceWin32HandleInfoKHR { 309 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; 310 const( void )* pNext; 311 const( SECURITY_ATTRIBUTES )* pAttributes; 312 DWORD dwAccess; 313 LPCWSTR name; 314 } 315 316 struct VkFenceGetWin32HandleInfoKHR { 317 VkStructureType sType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; 318 const( void )* pNext; 319 VkFence fence; 320 VkExternalFenceHandleTypeFlagBits handleType; 321 } 322 323 alias PFN_vkImportFenceWin32HandleKHR = VkResult function( VkDevice device, const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ); 324 alias PFN_vkGetFenceWin32HandleKHR = VkResult function( VkDevice device, const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 325 } 326 327 // VK_KHR_portability_subset : types and function pointer type aliases 328 else static if( __traits( isSame, extension, KHR_portability_subset )) { 329 enum VK_KHR_portability_subset = 1; 330 331 enum VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION = 1; 332 enum VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME = "VK_KHR_portability_subset"; 333 334 struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { 335 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; 336 void* pNext; 337 VkBool32 constantAlphaColorBlendFactors; 338 VkBool32 events; 339 VkBool32 imageViewFormatReinterpretation; 340 VkBool32 imageViewFormatSwizzle; 341 VkBool32 imageView2DOn3DImage; 342 VkBool32 multisampleArrayImage; 343 VkBool32 mutableComparisonSamplers; 344 VkBool32 pointPolygons; 345 VkBool32 samplerMipLodBias; 346 VkBool32 separateStencilMaskRef; 347 VkBool32 shaderSampleRateInterpolationFunctions; 348 VkBool32 tessellationIsolines; 349 VkBool32 tessellationPointMode; 350 VkBool32 triangleFans; 351 VkBool32 vertexAttributeAccessBeyondStride; 352 } 353 354 struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { 355 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; 356 void* pNext; 357 uint32_t minVertexInputBindingStrideAlignment; 358 } 359 360 } 361 362 // VK_GGP_stream_descriptor_surface : types and function pointer type aliases 363 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 364 enum VK_GGP_stream_descriptor_surface = 1; 365 366 enum VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION = 1; 367 enum VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME = "VK_GGP_stream_descriptor_surface"; 368 369 alias VkStreamDescriptorSurfaceCreateFlagsGGP = VkFlags; 370 371 struct VkStreamDescriptorSurfaceCreateInfoGGP { 372 VkStructureType sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; 373 const( void )* pNext; 374 VkStreamDescriptorSurfaceCreateFlagsGGP flags; 375 GgpStreamDescriptor streamDescriptor; 376 } 377 378 alias PFN_vkCreateStreamDescriptorSurfaceGGP = VkResult function( VkInstance instance, const( VkStreamDescriptorSurfaceCreateInfoGGP )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 379 } 380 381 // VK_NV_external_memory_win32 : types and function pointer type aliases 382 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 383 enum VK_NV_external_memory_win32 = 1; 384 385 enum VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 386 enum VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; 387 388 struct VkImportMemoryWin32HandleInfoNV { 389 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 390 const( void )* pNext; 391 VkExternalMemoryHandleTypeFlagsNV handleType; 392 HANDLE handle; 393 } 394 395 struct VkExportMemoryWin32HandleInfoNV { 396 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 397 const( void )* pNext; 398 const( SECURITY_ATTRIBUTES )* pAttributes; 399 DWORD dwAccess; 400 } 401 402 alias PFN_vkGetMemoryWin32HandleNV = VkResult function( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ); 403 } 404 405 // VK_NV_win32_keyed_mutex : types and function pointer type aliases 406 else static if( __traits( isSame, extension, NV_win32_keyed_mutex )) { 407 enum VK_NV_win32_keyed_mutex = 1; 408 409 enum VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 2; 410 enum VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; 411 412 struct VkWin32KeyedMutexAcquireReleaseInfoNV { 413 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 414 const( void )* pNext; 415 uint32_t acquireCount; 416 const( VkDeviceMemory )* pAcquireSyncs; 417 const( uint64_t )* pAcquireKeys; 418 const( uint32_t )* pAcquireTimeoutMilliseconds; 419 uint32_t releaseCount; 420 const( VkDeviceMemory )* pReleaseSyncs; 421 const( uint64_t )* pReleaseKeys; 422 } 423 424 } 425 426 // VK_NN_vi_surface : types and function pointer type aliases 427 else static if( __traits( isSame, extension, NN_vi_surface )) { 428 enum VK_NN_vi_surface = 1; 429 430 enum VK_NN_VI_SURFACE_SPEC_VERSION = 1; 431 enum VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface"; 432 433 alias VkViSurfaceCreateFlagsNN = VkFlags; 434 435 struct VkViSurfaceCreateInfoNN { 436 VkStructureType sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; 437 const( void )* pNext; 438 VkViSurfaceCreateFlagsNN flags; 439 void* window; 440 } 441 442 alias PFN_vkCreateViSurfaceNN = VkResult function( VkInstance instance, const( VkViSurfaceCreateInfoNN )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 443 } 444 445 // VK_EXT_acquire_xlib_display : types and function pointer type aliases 446 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 447 enum VK_EXT_acquire_xlib_display = 1; 448 449 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1; 450 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_xlib_display"; 451 452 alias PFN_vkAcquireXlibDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ); 453 alias PFN_vkGetRandROutputDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ); 454 } 455 456 // VK_MVK_ios_surface : types and function pointer type aliases 457 else static if( __traits( isSame, extension, MVK_ios_surface )) { 458 enum VK_MVK_ios_surface = 1; 459 460 enum VK_MVK_IOS_SURFACE_SPEC_VERSION = 3; 461 enum VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface"; 462 463 alias VkIOSSurfaceCreateFlagsMVK = VkFlags; 464 465 struct VkIOSSurfaceCreateInfoMVK { 466 VkStructureType sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; 467 const( void )* pNext; 468 VkIOSSurfaceCreateFlagsMVK flags; 469 const( void )* pView; 470 } 471 472 alias PFN_vkCreateIOSSurfaceMVK = VkResult function( VkInstance instance, const( VkIOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 473 } 474 475 // VK_MVK_macos_surface : types and function pointer type aliases 476 else static if( __traits( isSame, extension, MVK_macos_surface )) { 477 enum VK_MVK_macos_surface = 1; 478 479 enum VK_MVK_MACOS_SURFACE_SPEC_VERSION = 3; 480 enum VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface"; 481 482 alias VkMacOSSurfaceCreateFlagsMVK = VkFlags; 483 484 struct VkMacOSSurfaceCreateInfoMVK { 485 VkStructureType sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; 486 const( void )* pNext; 487 VkMacOSSurfaceCreateFlagsMVK flags; 488 const( void )* pView; 489 } 490 491 alias PFN_vkCreateMacOSSurfaceMVK = VkResult function( VkInstance instance, const( VkMacOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 492 } 493 494 // VK_ANDROID_external_memory_android_hardware_buffer : types and function pointer type aliases 495 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 496 enum VK_ANDROID_external_memory_android_hardware_buffer = 1; 497 498 alias AHardwareBuffer = AHardwareBuffer; 499 500 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION = 3; 501 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME = "VK_ANDROID_external_memory_android_hardware_buffer"; 502 503 struct VkAndroidHardwareBufferUsageANDROID { 504 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; 505 void* pNext; 506 uint64_t androidHardwareBufferUsage; 507 } 508 509 struct VkAndroidHardwareBufferPropertiesANDROID { 510 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; 511 void* pNext; 512 VkDeviceSize allocationSize; 513 uint32_t memoryTypeBits; 514 } 515 516 struct VkAndroidHardwareBufferFormatPropertiesANDROID { 517 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; 518 void* pNext; 519 VkFormat format; 520 uint64_t externalFormat; 521 VkFormatFeatureFlags formatFeatures; 522 VkComponentMapping samplerYcbcrConversionComponents; 523 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 524 VkSamplerYcbcrRange suggestedYcbcrRange; 525 VkChromaLocation suggestedXChromaOffset; 526 VkChromaLocation suggestedYChromaOffset; 527 } 528 529 struct VkImportAndroidHardwareBufferInfoANDROID { 530 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 531 const( void )* pNext; 532 const( AHardwareBuffer )* buffer; 533 } 534 535 struct VkMemoryGetAndroidHardwareBufferInfoANDROID { 536 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 537 const( void )* pNext; 538 VkDeviceMemory memory; 539 } 540 541 struct VkExternalFormatANDROID { 542 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; 543 void* pNext; 544 uint64_t externalFormat; 545 } 546 547 alias PFN_vkGetAndroidHardwareBufferPropertiesANDROID = VkResult function( VkDevice device, const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ); 548 alias PFN_vkGetMemoryAndroidHardwareBufferANDROID = VkResult function( VkDevice device, const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ); 549 } 550 551 // VK_GGP_frame_token : types and function pointer type aliases 552 else static if( __traits( isSame, extension, GGP_frame_token )) { 553 enum VK_GGP_frame_token = 1; 554 555 enum VK_GGP_FRAME_TOKEN_SPEC_VERSION = 1; 556 enum VK_GGP_FRAME_TOKEN_EXTENSION_NAME = "VK_GGP_frame_token"; 557 558 struct VkPresentFrameTokenGGP { 559 VkStructureType sType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; 560 const( void )* pNext; 561 GgpFrameToken frameToken; 562 } 563 564 } 565 566 // VK_FUCHSIA_imagepipe_surface : types and function pointer type aliases 567 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 568 enum VK_FUCHSIA_imagepipe_surface = 1; 569 570 enum VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION = 1; 571 enum VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME = "VK_FUCHSIA_imagepipe_surface"; 572 573 alias VkImagePipeSurfaceCreateFlagsFUCHSIA = VkFlags; 574 575 struct VkImagePipeSurfaceCreateInfoFUCHSIA { 576 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; 577 const( void )* pNext; 578 VkImagePipeSurfaceCreateFlagsFUCHSIA flags; 579 zx_handle_t imagePipeHandle; 580 } 581 582 alias PFN_vkCreateImagePipeSurfaceFUCHSIA = VkResult function( VkInstance instance, const( VkImagePipeSurfaceCreateInfoFUCHSIA )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 583 } 584 585 // VK_EXT_metal_surface : types and function pointer type aliases 586 else static if( __traits( isSame, extension, EXT_metal_surface )) { 587 enum VK_EXT_metal_surface = 1; 588 589 alias CAMetalLayer = CAMetalLayer; 590 591 enum VK_EXT_METAL_SURFACE_SPEC_VERSION = 1; 592 enum VK_EXT_METAL_SURFACE_EXTENSION_NAME = "VK_EXT_metal_surface"; 593 594 alias VkMetalSurfaceCreateFlagsEXT = VkFlags; 595 596 struct VkMetalSurfaceCreateInfoEXT { 597 VkStructureType sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; 598 const( void )* pNext; 599 VkMetalSurfaceCreateFlagsEXT flags; 600 const( CAMetalLayer )* pLayer; 601 } 602 603 alias PFN_vkCreateMetalSurfaceEXT = VkResult function( VkInstance instance, const( VkMetalSurfaceCreateInfoEXT )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 604 } 605 606 // VK_EXT_full_screen_exclusive : types and function pointer type aliases 607 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 608 enum VK_EXT_full_screen_exclusive = 1; 609 610 enum VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION = 4; 611 enum VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME = "VK_EXT_full_screen_exclusive"; 612 613 enum VkFullScreenExclusiveEXT { 614 VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, 615 VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, 616 VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, 617 VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, 618 VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, 619 VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, 620 VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1, 621 VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF 622 } 623 624 enum VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT; 625 enum VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT; 626 enum VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT; 627 enum VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT; 628 enum VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT; 629 enum VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT; 630 enum VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT; 631 enum VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT; 632 633 struct VkSurfaceFullScreenExclusiveInfoEXT { 634 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; 635 void* pNext; 636 VkFullScreenExclusiveEXT fullScreenExclusive; 637 } 638 639 struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { 640 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; 641 void* pNext; 642 VkBool32 fullScreenExclusiveSupported; 643 } 644 645 struct VkSurfaceFullScreenExclusiveWin32InfoEXT { 646 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; 647 const( void )* pNext; 648 HMONITOR hmonitor; 649 } 650 651 alias PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = VkResult function( VkPhysicalDevice physicalDevice, const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ); 652 alias PFN_vkAcquireFullScreenExclusiveModeEXT = VkResult function( VkDevice device, VkSwapchainKHR swapchain ); 653 alias PFN_vkReleaseFullScreenExclusiveModeEXT = VkResult function( VkDevice device, VkSwapchainKHR swapchain ); 654 alias PFN_vkGetDeviceGroupSurfacePresentModes2EXT = VkResult function( VkDevice device, const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ); 655 } 656 657 // VK_NV_acquire_winrt_display : types and function pointer type aliases 658 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 659 enum VK_NV_acquire_winrt_display = 1; 660 661 enum VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION = 1; 662 enum VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME = "VK_NV_acquire_winrt_display"; 663 664 alias PFN_vkAcquireWinrtDisplayNV = VkResult function( VkPhysicalDevice physicalDevice, VkDisplayKHR display ); 665 alias PFN_vkGetWinrtDisplayNV = VkResult function( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay ); 666 } 667 668 // VK_EXT_directfb_surface : types and function pointer type aliases 669 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 670 enum VK_EXT_directfb_surface = 1; 671 672 enum VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION = 1; 673 enum VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME = "VK_EXT_directfb_surface"; 674 675 alias VkDirectFBSurfaceCreateFlagsEXT = VkFlags; 676 677 struct VkDirectFBSurfaceCreateInfoEXT { 678 VkStructureType sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; 679 const( void )* pNext; 680 VkDirectFBSurfaceCreateFlagsEXT flags; 681 IDirectFB* dfb; 682 IDirectFBSurface* surface; 683 } 684 685 alias PFN_vkCreateDirectFBSurfaceEXT = VkResult function( VkInstance instance, const( VkDirectFBSurfaceCreateInfoEXT )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 686 alias PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb ); 687 } 688 689 __gshared { 690 691 // VK_KHR_xlib_surface : function pointer decelerations 692 static if( __traits( isSame, extension, KHR_xlib_surface )) { 693 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 694 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 695 } 696 697 // VK_KHR_xcb_surface : function pointer decelerations 698 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 699 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 700 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 701 } 702 703 // VK_KHR_wayland_surface : function pointer decelerations 704 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 705 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 706 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 707 } 708 709 // VK_KHR_android_surface : function pointer decelerations 710 else static if( __traits( isSame, extension, KHR_android_surface )) { 711 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 712 } 713 714 // VK_KHR_win32_surface : function pointer decelerations 715 else static if( __traits( isSame, extension, KHR_win32_surface )) { 716 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 717 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 718 } 719 720 // VK_KHR_external_memory_win32 : function pointer decelerations 721 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 722 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 723 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 724 } 725 726 // VK_KHR_external_semaphore_win32 : function pointer decelerations 727 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 728 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 729 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 730 } 731 732 // VK_KHR_external_fence_win32 : function pointer decelerations 733 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 734 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 735 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 736 } 737 738 // VK_GGP_stream_descriptor_surface : function pointer decelerations 739 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 740 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; 741 } 742 743 // VK_NV_external_memory_win32 : function pointer decelerations 744 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 745 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 746 } 747 748 // VK_NN_vi_surface : function pointer decelerations 749 else static if( __traits( isSame, extension, NN_vi_surface )) { 750 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 751 } 752 753 // VK_EXT_acquire_xlib_display : function pointer decelerations 754 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 755 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 756 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 757 } 758 759 // VK_MVK_ios_surface : function pointer decelerations 760 else static if( __traits( isSame, extension, MVK_ios_surface )) { 761 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 762 } 763 764 // VK_MVK_macos_surface : function pointer decelerations 765 else static if( __traits( isSame, extension, MVK_macos_surface )) { 766 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 767 } 768 769 // VK_ANDROID_external_memory_android_hardware_buffer : function pointer decelerations 770 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 771 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 772 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 773 } 774 775 // VK_FUCHSIA_imagepipe_surface : function pointer decelerations 776 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 777 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; 778 } 779 780 // VK_EXT_metal_surface : function pointer decelerations 781 else static if( __traits( isSame, extension, EXT_metal_surface )) { 782 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; 783 } 784 785 // VK_EXT_full_screen_exclusive : function pointer decelerations 786 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 787 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; 788 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; 789 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; 790 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; 791 } 792 793 // VK_NV_acquire_winrt_display : function pointer decelerations 794 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 795 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; 796 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; 797 } 798 799 // VK_EXT_directfb_surface : function pointer decelerations 800 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 801 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; 802 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; 803 } 804 } 805 } 806 807 // workaround for not being able to mixin two overloads with the same symbol name 808 alias loadDeviceLevelFunctionsExt = loadDeviceLevelFunctionsExtI; 809 alias loadDeviceLevelFunctionsExt = loadDeviceLevelFunctionsExtD; 810 811 // backwards compatibility aliases 812 alias loadInstanceLevelFunctions = loadInstanceLevelFunctionsExt; 813 alias loadDeviceLevelFunctions = loadDeviceLevelFunctionsExt; 814 alias DispatchDevice = DispatchDeviceExt; 815 816 // compose loadInstanceLevelFunctionsExt function out of unextended 817 // loadInstanceLevelFunctions and additional function pointers from extensions 818 void loadInstanceLevelFunctionsExt( VkInstance instance ) { 819 820 // first load all non platform related function pointers from implementation 821 erupted.functions.loadInstanceLevelFunctions( instance ); 822 823 // 2. loop through alias sequence and mixin corresponding 824 // instance level function pointer definitions 825 static foreach( extension; noDuplicateExtensions ) { 826 827 // VK_KHR_xlib_surface : load instance level function definitions 828 static if( __traits( isSame, extension, KHR_xlib_surface )) { 829 vkCreateXlibSurfaceKHR = cast( PFN_vkCreateXlibSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ); 830 vkGetPhysicalDeviceXlibPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ); 831 } 832 833 // VK_KHR_xcb_surface : load instance level function definitions 834 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 835 vkCreateXcbSurfaceKHR = cast( PFN_vkCreateXcbSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ); 836 vkGetPhysicalDeviceXcbPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ); 837 } 838 839 // VK_KHR_wayland_surface : load instance level function definitions 840 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 841 vkCreateWaylandSurfaceKHR = cast( PFN_vkCreateWaylandSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ); 842 vkGetPhysicalDeviceWaylandPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ); 843 } 844 845 // VK_KHR_android_surface : load instance level function definitions 846 else static if( __traits( isSame, extension, KHR_android_surface )) { 847 vkCreateAndroidSurfaceKHR = cast( PFN_vkCreateAndroidSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ); 848 } 849 850 // VK_KHR_win32_surface : load instance level function definitions 851 else static if( __traits( isSame, extension, KHR_win32_surface )) { 852 vkCreateWin32SurfaceKHR = cast( PFN_vkCreateWin32SurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ); 853 vkGetPhysicalDeviceWin32PresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ); 854 } 855 856 // VK_GGP_stream_descriptor_surface : load instance level function definitions 857 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 858 vkCreateStreamDescriptorSurfaceGGP = cast( PFN_vkCreateStreamDescriptorSurfaceGGP ) vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ); 859 } 860 861 // VK_NN_vi_surface : load instance level function definitions 862 else static if( __traits( isSame, extension, NN_vi_surface )) { 863 vkCreateViSurfaceNN = cast( PFN_vkCreateViSurfaceNN ) vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ); 864 } 865 866 // VK_EXT_acquire_xlib_display : load instance level function definitions 867 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 868 vkAcquireXlibDisplayEXT = cast( PFN_vkAcquireXlibDisplayEXT ) vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ); 869 vkGetRandROutputDisplayEXT = cast( PFN_vkGetRandROutputDisplayEXT ) vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ); 870 } 871 872 // VK_MVK_ios_surface : load instance level function definitions 873 else static if( __traits( isSame, extension, MVK_ios_surface )) { 874 vkCreateIOSSurfaceMVK = cast( PFN_vkCreateIOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ); 875 } 876 877 // VK_MVK_macos_surface : load instance level function definitions 878 else static if( __traits( isSame, extension, MVK_macos_surface )) { 879 vkCreateMacOSSurfaceMVK = cast( PFN_vkCreateMacOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ); 880 } 881 882 // VK_FUCHSIA_imagepipe_surface : load instance level function definitions 883 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 884 vkCreateImagePipeSurfaceFUCHSIA = cast( PFN_vkCreateImagePipeSurfaceFUCHSIA ) vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ); 885 } 886 887 // VK_EXT_metal_surface : load instance level function definitions 888 else static if( __traits( isSame, extension, EXT_metal_surface )) { 889 vkCreateMetalSurfaceEXT = cast( PFN_vkCreateMetalSurfaceEXT ) vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ); 890 } 891 892 // VK_EXT_full_screen_exclusive : load instance level function definitions 893 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 894 vkGetPhysicalDeviceSurfacePresentModes2EXT = cast( PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ); 895 } 896 897 // VK_NV_acquire_winrt_display : load instance level function definitions 898 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 899 vkAcquireWinrtDisplayNV = cast( PFN_vkAcquireWinrtDisplayNV ) vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ); 900 vkGetWinrtDisplayNV = cast( PFN_vkGetWinrtDisplayNV ) vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ); 901 } 902 903 // VK_EXT_directfb_surface : load instance level function definitions 904 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 905 vkCreateDirectFBSurfaceEXT = cast( PFN_vkCreateDirectFBSurfaceEXT ) vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ); 906 vkGetPhysicalDeviceDirectFBPresentationSupportEXT = cast( PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ); 907 } 908 } 909 } 910 911 // compose instance based loadDeviceLevelFunctionsExtI function out of unextended 912 // loadDeviceLevelFunctions and additional function pointers from extensions 913 // suffix I is required, as we cannot mixin mixin two overloads with the same symbol name (any more!) 914 void loadDeviceLevelFunctionsExtI( VkInstance instance ) { 915 916 // first load all non platform related function pointers from implementation 917 erupted.functions.loadDeviceLevelFunctions( instance ); 918 919 // 3. loop through alias sequence and mixin corresponding 920 // instance based device level function pointer definitions 921 static foreach( extension; noDuplicateExtensions ) { 922 923 // VK_KHR_external_memory_win32 : load instance based device level function definitions 924 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 925 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ); 926 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ); 927 } 928 929 // VK_KHR_external_semaphore_win32 : load instance based device level function definitions 930 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 931 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ); 932 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ); 933 } 934 935 // VK_KHR_external_fence_win32 : load instance based device level function definitions 936 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 937 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ); 938 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ); 939 } 940 941 // VK_NV_external_memory_win32 : load instance based device level function definitions 942 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 943 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ); 944 } 945 946 // VK_ANDROID_external_memory_android_hardware_buffer : load instance based device level function definitions 947 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 948 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 949 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ); 950 } 951 952 // VK_EXT_full_screen_exclusive : load instance based device level function definitions 953 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 954 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ); 955 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ); 956 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 957 } 958 } 959 } 960 961 // compose device based loadDeviceLevelFunctionsExtD function out of unextended 962 // loadDeviceLevelFunctions and additional function pointers from extensions 963 // suffix D is required as, we cannot mixin mixin two overloads with the same symbol name (any more!) 964 void loadDeviceLevelFunctionsExtD( VkDevice device ) { 965 966 // first load all non platform related function pointers from implementation 967 erupted.functions.loadDeviceLevelFunctions( device ); 968 969 // 4. loop through alias sequence and mixin corresponding 970 // device based device level function pointer definitions 971 static foreach( extension; noDuplicateExtensions ) { 972 973 // VK_KHR_external_memory_win32 : load device based device level function definitions 974 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 975 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 976 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 977 } 978 979 // VK_KHR_external_semaphore_win32 : load device based device level function definitions 980 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 981 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 982 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 983 } 984 985 // VK_KHR_external_fence_win32 : load device based device level function definitions 986 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 987 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 988 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 989 } 990 991 // VK_NV_external_memory_win32 : load device based device level function definitions 992 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 993 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 994 } 995 996 // VK_ANDROID_external_memory_android_hardware_buffer : load device based device level function definitions 997 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 998 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 999 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 1000 } 1001 1002 // VK_EXT_full_screen_exclusive : load device based device level function definitions 1003 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1004 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ); 1005 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ); 1006 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 1007 } 1008 } 1009 } 1010 1011 // compose extended dispatch device out of unextended original dispatch device with 1012 // extended, device based loadDeviceLevelFunctionsExt member function, 1013 // device and command buffer based function pointer decelerations 1014 struct DispatchDeviceExt { 1015 1016 // use unextended dispatch device from module erupted.functions as member and alias this 1017 erupted.dispatch_device.DispatchDevice commonDispatchDevice; 1018 alias commonDispatchDevice this; 1019 1020 // Constructor forwards parameter 'device' to 'loadDeviceLevelFunctionsExt' 1021 this( VkDevice device ) { 1022 loadDeviceLevelFunctionsExt( device ); 1023 } 1024 1025 // backwards compatibility alias 1026 alias loadDeviceLevelFunctions = loadDeviceLevelFunctionsExt; 1027 1028 // compose device based loadDeviceLevelFunctionsExt member function out of unextended 1029 // loadDeviceLevelFunctions and additional member function pointers from extensions 1030 void loadDeviceLevelFunctionsExt( VkDevice device ) { 1031 1032 // first load all non platform related member function pointers of wrapped commonDispatchDevice 1033 commonDispatchDevice.loadDeviceLevelFunctions( device ); 1034 1035 // 5. loop through alias sequence and mixin corresponding 1036 // device level member function pointer definitions of this wrapping DispatchDevice 1037 static foreach( extension; noDuplicateExtensions ) { 1038 1039 // VK_KHR_external_memory_win32 : load dispatch device member function definitions 1040 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 1041 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 1042 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 1043 } 1044 1045 // VK_KHR_external_semaphore_win32 : load dispatch device member function definitions 1046 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 1047 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 1048 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 1049 } 1050 1051 // VK_KHR_external_fence_win32 : load dispatch device member function definitions 1052 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 1053 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 1054 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 1055 } 1056 1057 // VK_NV_external_memory_win32 : load dispatch device member function definitions 1058 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1059 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 1060 } 1061 1062 // VK_ANDROID_external_memory_android_hardware_buffer : load dispatch device member function definitions 1063 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1064 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 1065 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 1066 } 1067 1068 // VK_EXT_full_screen_exclusive : load dispatch device member function definitions 1069 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1070 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ); 1071 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ); 1072 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 1073 } 1074 } 1075 } 1076 1077 // 6. loop through alias sequence and mixin corresponding convenience member functions 1078 // omitting device parameter of this wrapping DispatchDevice. Member vkDevice of commonDispatchDevice is used instead 1079 static foreach( extension; noDuplicateExtensions ) { 1080 1081 // VK_KHR_external_memory_win32 : dispatch device convenience member functions 1082 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 1083 VkResult GetMemoryWin32HandleKHR( const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetMemoryWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 1084 VkResult GetMemoryWin32HandlePropertiesKHR( VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) { return vkGetMemoryWin32HandlePropertiesKHR( vkDevice, handleType, handle, pMemoryWin32HandleProperties ); } 1085 } 1086 1087 // VK_KHR_external_semaphore_win32 : dispatch device convenience member functions 1088 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 1089 VkResult ImportSemaphoreWin32HandleKHR( const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ) { return vkImportSemaphoreWin32HandleKHR( vkDevice, pImportSemaphoreWin32HandleInfo ); } 1090 VkResult GetSemaphoreWin32HandleKHR( const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetSemaphoreWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 1091 } 1092 1093 // VK_KHR_external_fence_win32 : dispatch device convenience member functions 1094 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 1095 VkResult ImportFenceWin32HandleKHR( const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ) { return vkImportFenceWin32HandleKHR( vkDevice, pImportFenceWin32HandleInfo ); } 1096 VkResult GetFenceWin32HandleKHR( const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetFenceWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 1097 } 1098 1099 // VK_NV_external_memory_win32 : dispatch device convenience member functions 1100 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1101 VkResult GetMemoryWin32HandleNV( VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) { return vkGetMemoryWin32HandleNV( vkDevice, memory, handleType, pHandle ); } 1102 } 1103 1104 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device convenience member functions 1105 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1106 VkResult GetAndroidHardwareBufferPropertiesANDROID( const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) { return vkGetAndroidHardwareBufferPropertiesANDROID( vkDevice, buffer, pProperties ); } 1107 VkResult GetMemoryAndroidHardwareBufferANDROID( const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ) { return vkGetMemoryAndroidHardwareBufferANDROID( vkDevice, pInfo, pBuffer ); } 1108 } 1109 1110 // VK_EXT_full_screen_exclusive : dispatch device convenience member functions 1111 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1112 VkResult AcquireFullScreenExclusiveModeEXT( VkSwapchainKHR swapchain ) { return vkAcquireFullScreenExclusiveModeEXT( vkDevice, swapchain ); } 1113 VkResult ReleaseFullScreenExclusiveModeEXT( VkSwapchainKHR swapchain ) { return vkReleaseFullScreenExclusiveModeEXT( vkDevice, swapchain ); } 1114 VkResult GetDeviceGroupSurfacePresentModes2EXT( const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ) { return vkGetDeviceGroupSurfacePresentModes2EXT( vkDevice, pSurfaceInfo, pModes ); } 1115 } 1116 } 1117 1118 // 7. loop last time through alias sequence and mixin corresponding function pointer declarations 1119 static foreach( extension; noDuplicateExtensions ) { 1120 1121 // VK_KHR_xlib_surface : dispatch device member function pointer decelerations 1122 static if( __traits( isSame, extension, KHR_xlib_surface )) { 1123 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 1124 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 1125 } 1126 1127 // VK_KHR_xcb_surface : dispatch device member function pointer decelerations 1128 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 1129 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 1130 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 1131 } 1132 1133 // VK_KHR_wayland_surface : dispatch device member function pointer decelerations 1134 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 1135 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 1136 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 1137 } 1138 1139 // VK_KHR_android_surface : dispatch device member function pointer decelerations 1140 else static if( __traits( isSame, extension, KHR_android_surface )) { 1141 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 1142 } 1143 1144 // VK_KHR_win32_surface : dispatch device member function pointer decelerations 1145 else static if( __traits( isSame, extension, KHR_win32_surface )) { 1146 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 1147 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 1148 } 1149 1150 // VK_KHR_external_memory_win32 : dispatch device member function pointer decelerations 1151 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 1152 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 1153 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 1154 } 1155 1156 // VK_KHR_external_semaphore_win32 : dispatch device member function pointer decelerations 1157 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 1158 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 1159 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 1160 } 1161 1162 // VK_KHR_external_fence_win32 : dispatch device member function pointer decelerations 1163 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 1164 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 1165 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 1166 } 1167 1168 // VK_GGP_stream_descriptor_surface : dispatch device member function pointer decelerations 1169 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 1170 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; 1171 } 1172 1173 // VK_NV_external_memory_win32 : dispatch device member function pointer decelerations 1174 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1175 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 1176 } 1177 1178 // VK_NN_vi_surface : dispatch device member function pointer decelerations 1179 else static if( __traits( isSame, extension, NN_vi_surface )) { 1180 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 1181 } 1182 1183 // VK_EXT_acquire_xlib_display : dispatch device member function pointer decelerations 1184 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 1185 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 1186 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 1187 } 1188 1189 // VK_MVK_ios_surface : dispatch device member function pointer decelerations 1190 else static if( __traits( isSame, extension, MVK_ios_surface )) { 1191 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 1192 } 1193 1194 // VK_MVK_macos_surface : dispatch device member function pointer decelerations 1195 else static if( __traits( isSame, extension, MVK_macos_surface )) { 1196 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 1197 } 1198 1199 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device member function pointer decelerations 1200 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1201 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 1202 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 1203 } 1204 1205 // VK_FUCHSIA_imagepipe_surface : dispatch device member function pointer decelerations 1206 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 1207 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; 1208 } 1209 1210 // VK_EXT_metal_surface : dispatch device member function pointer decelerations 1211 else static if( __traits( isSame, extension, EXT_metal_surface )) { 1212 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; 1213 } 1214 1215 // VK_EXT_full_screen_exclusive : dispatch device member function pointer decelerations 1216 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1217 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; 1218 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; 1219 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; 1220 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; 1221 } 1222 1223 // VK_NV_acquire_winrt_display : dispatch device member function pointer decelerations 1224 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 1225 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; 1226 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; 1227 } 1228 1229 // VK_EXT_directfb_surface : dispatch device member function pointer decelerations 1230 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 1231 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; 1232 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; 1233 } 1234 } 1235 } 1236 }