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_mir_surface; 16 enum KHR_android_surface; 17 enum KHR_win32_surface; 18 enum KHR_external_memory_win32; 19 enum KHR_win32_keyed_mutex; 20 enum KHR_external_semaphore_win32; 21 enum KHR_external_fence_win32; 22 enum NV_external_memory_win32; 23 enum NV_win32_keyed_mutex; 24 enum NN_vi_surface; 25 enum EXT_acquire_xlib_display; 26 enum MVK_ios_surface; 27 enum MVK_macos_surface; 28 enum ANDROID_external_memory_android_hardware_buffer; 29 30 31 /// extensions to a specific platform are grouped in these enum sequences 32 import std.meta : AliasSeq; 33 alias USE_PLATFORM_XLIB_KHR = AliasSeq!( KHR_xlib_surface ); 34 alias USE_PLATFORM_XCB_KHR = AliasSeq!( KHR_xcb_surface ); 35 alias USE_PLATFORM_WAYLAND_KHR = AliasSeq!( KHR_wayland_surface ); 36 alias USE_PLATFORM_MIR_KHR = AliasSeq!( KHR_mir_surface ); 37 alias USE_PLATFORM_ANDROID_KHR = AliasSeq!( KHR_android_surface, ANDROID_external_memory_android_hardware_buffer ); 38 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 ); 39 alias USE_PLATFORM_VI_NN = AliasSeq!( NN_vi_surface ); 40 alias USE_PLATFORM_XLIB_XRANDR_EXT = AliasSeq!( EXT_acquire_xlib_display ); 41 alias USE_PLATFORM_IOS_MVK = AliasSeq!( MVK_ios_surface ); 42 alias USE_PLATFORM_MACOS_MVK = AliasSeq!( MVK_macos_surface ); 43 44 45 46 /// instantiate platform and extension specific code with this mixin template 47 /// required types and data structures must be imported into the module where 48 /// this template is instantiated 49 mixin template Platform_Extensions( extensions... ) { 50 51 // publicly import erupted package modules 52 public import erupted.types; 53 public import erupted.functions; 54 import erupted.dispatch_device; 55 56 // mixin function linkage, nothrow and @nogc attributes for subsecuent functions 57 extern(System) nothrow @nogc: 58 59 // remove duplicates from alias sequence 60 // this might happen if a platform extension collection AND a single extension, which is included in the collection, was specified 61 // e.g.: mixin Platform_Extensions!( VK_USE_PLATFORM_WIN32_KHR, VK_KHR_external_memory_win32 ); 62 import std.meta : NoDuplicates; 63 alias noDuplicateExtensions = NoDuplicates!extensions; 64 65 // 1. loop through alias sequence and mixin corresponding 66 // extension types, aliased function pointer type definitions and __gshared function pointer declarations 67 static foreach( extension; noDuplicateExtensions ) { 68 69 // VK_KHR_xlib_surface : types and function pointer type aliases 70 static if( __traits( isSame, extension, KHR_xlib_surface )) { 71 enum VK_KHR_xlib_surface = 1; 72 73 enum VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; 74 enum VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; 75 76 alias VkXlibSurfaceCreateFlagsKHR = VkFlags; 77 78 struct VkXlibSurfaceCreateInfoKHR { 79 VkStructureType sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 80 const( void )* pNext; 81 VkXlibSurfaceCreateFlagsKHR flags; 82 Display* dpy; 83 Window window; 84 } 85 86 alias PFN_vkCreateXlibSurfaceKHR = VkResult function( VkInstance instance, const( VkXlibSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 87 alias PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ); 88 } 89 90 // VK_KHR_xcb_surface : types and function pointer type aliases 91 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 92 enum VK_KHR_xcb_surface = 1; 93 94 enum VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; 95 enum VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; 96 97 alias VkXcbSurfaceCreateFlagsKHR = VkFlags; 98 99 struct VkXcbSurfaceCreateInfoKHR { 100 VkStructureType sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 101 const( void )* pNext; 102 VkXcbSurfaceCreateFlagsKHR flags; 103 xcb_connection_t* connection; 104 xcb_window_t window; 105 } 106 107 alias PFN_vkCreateXcbSurfaceKHR = VkResult function( VkInstance instance, const( VkXcbSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 108 alias PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ); 109 } 110 111 // VK_KHR_wayland_surface : types and function pointer type aliases 112 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 113 enum VK_KHR_wayland_surface = 1; 114 115 enum VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6; 116 enum VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; 117 118 alias VkWaylandSurfaceCreateFlagsKHR = VkFlags; 119 120 struct VkWaylandSurfaceCreateInfoKHR { 121 VkStructureType sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 122 const( void )* pNext; 123 VkWaylandSurfaceCreateFlagsKHR flags; 124 const( wl_display )* display; 125 const( wl_surface )* surface; 126 } 127 128 alias PFN_vkCreateWaylandSurfaceKHR = VkResult function( VkInstance instance, const( VkWaylandSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 129 alias PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const( wl_display )* display ); 130 } 131 132 // VK_KHR_mir_surface : types and function pointer type aliases 133 else static if( __traits( isSame, extension, KHR_mir_surface )) { 134 enum VK_KHR_mir_surface = 1; 135 136 enum VK_KHR_MIR_SURFACE_SPEC_VERSION = 4; 137 enum VK_KHR_MIR_SURFACE_EXTENSION_NAME = "VK_KHR_mir_surface"; 138 139 alias VkMirSurfaceCreateFlagsKHR = VkFlags; 140 141 struct VkMirSurfaceCreateInfoKHR { 142 VkStructureType sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; 143 const( void )* pNext; 144 VkMirSurfaceCreateFlagsKHR flags; 145 MirConnection* connection; 146 MirSurface* mirSurface; 147 } 148 149 alias PFN_vkCreateMirSurfaceKHR = VkResult function( VkInstance instance, const( VkMirSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 150 alias PFN_vkGetPhysicalDeviceMirPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection ); 151 } 152 153 // VK_KHR_android_surface : types and function pointer type aliases 154 else static if( __traits( isSame, extension, KHR_android_surface )) { 155 enum VK_KHR_android_surface = 1; 156 157 enum VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; 158 enum VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; 159 160 alias VkAndroidSurfaceCreateFlagsKHR = VkFlags; 161 162 struct VkAndroidSurfaceCreateInfoKHR { 163 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 164 const( void )* pNext; 165 VkAndroidSurfaceCreateFlagsKHR flags; 166 const( ANativeWindow )* window; 167 } 168 169 alias PFN_vkCreateAndroidSurfaceKHR = VkResult function( VkInstance instance, const( VkAndroidSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 170 } 171 172 // VK_KHR_win32_surface : types and function pointer type aliases 173 else static if( __traits( isSame, extension, KHR_win32_surface )) { 174 enum VK_KHR_win32_surface = 1; 175 176 enum VK_KHR_WIN32_SURFACE_SPEC_VERSION = 6; 177 enum VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; 178 179 alias VkWin32SurfaceCreateFlagsKHR = VkFlags; 180 181 struct VkWin32SurfaceCreateInfoKHR { 182 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 183 const( void )* pNext; 184 VkWin32SurfaceCreateFlagsKHR flags; 185 HINSTANCE hinstance; 186 HWND hwnd; 187 } 188 189 alias PFN_vkCreateWin32SurfaceKHR = VkResult function( VkInstance instance, const( VkWin32SurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 190 alias PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ); 191 } 192 193 // VK_KHR_external_memory_win32 : types and function pointer type aliases 194 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 195 enum VK_KHR_external_memory_win32 = 1; 196 197 enum VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 198 enum VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_KHR_external_memory_win32"; 199 200 struct VkImportMemoryWin32HandleInfoKHR { 201 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; 202 const( void )* pNext; 203 VkExternalMemoryHandleTypeFlagBits handleType; 204 HANDLE handle; 205 LPCWSTR name; 206 } 207 208 struct VkExportMemoryWin32HandleInfoKHR { 209 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; 210 const( void )* pNext; 211 const( SECURITY_ATTRIBUTES )* pAttributes; 212 DWORD dwAccess; 213 LPCWSTR name; 214 } 215 216 struct VkMemoryWin32HandlePropertiesKHR { 217 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; 218 void* pNext; 219 uint32_t memoryTypeBits; 220 } 221 222 struct VkMemoryGetWin32HandleInfoKHR { 223 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; 224 const( void )* pNext; 225 VkDeviceMemory memory; 226 VkExternalMemoryHandleTypeFlagBits handleType; 227 } 228 229 alias PFN_vkGetMemoryWin32HandleKHR = VkResult function( VkDevice device, const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 230 alias PFN_vkGetMemoryWin32HandlePropertiesKHR = VkResult function( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ); 231 } 232 233 // VK_KHR_win32_keyed_mutex : types and function pointer type aliases 234 else static if( __traits( isSame, extension, KHR_win32_keyed_mutex )) { 235 enum VK_KHR_win32_keyed_mutex = 1; 236 237 enum VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 238 enum VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_KHR_win32_keyed_mutex"; 239 240 struct VkWin32KeyedMutexAcquireReleaseInfoKHR { 241 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; 242 const( void )* pNext; 243 uint32_t acquireCount; 244 const( VkDeviceMemory )* pAcquireSyncs; 245 const( uint64_t )* pAcquireKeys; 246 const( uint32_t )* pAcquireTimeouts; 247 uint32_t releaseCount; 248 const( VkDeviceMemory )* pReleaseSyncs; 249 const( uint64_t )* pReleaseKeys; 250 } 251 252 } 253 254 // VK_KHR_external_semaphore_win32 : types and function pointer type aliases 255 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 256 enum VK_KHR_external_semaphore_win32 = 1; 257 258 enum VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1; 259 enum VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = "VK_KHR_external_semaphore_win32"; 260 261 struct VkImportSemaphoreWin32HandleInfoKHR { 262 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; 263 const( void )* pNext; 264 VkSemaphore semaphore; 265 VkSemaphoreImportFlags flags; 266 VkExternalSemaphoreHandleTypeFlagBits handleType; 267 HANDLE handle; 268 LPCWSTR name; 269 } 270 271 struct VkExportSemaphoreWin32HandleInfoKHR { 272 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; 273 const( void )* pNext; 274 const( SECURITY_ATTRIBUTES )* pAttributes; 275 DWORD dwAccess; 276 LPCWSTR name; 277 } 278 279 struct VkD3D12FenceSubmitInfoKHR { 280 VkStructureType sType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; 281 const( void )* pNext; 282 uint32_t waitSemaphoreValuesCount; 283 const( uint64_t )* pWaitSemaphoreValues; 284 uint32_t signalSemaphoreValuesCount; 285 const( uint64_t )* pSignalSemaphoreValues; 286 } 287 288 struct VkSemaphoreGetWin32HandleInfoKHR { 289 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; 290 const( void )* pNext; 291 VkSemaphore semaphore; 292 VkExternalSemaphoreHandleTypeFlagBits handleType; 293 } 294 295 alias PFN_vkImportSemaphoreWin32HandleKHR = VkResult function( VkDevice device, const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ); 296 alias PFN_vkGetSemaphoreWin32HandleKHR = VkResult function( VkDevice device, const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 297 } 298 299 // VK_KHR_external_fence_win32 : types and function pointer type aliases 300 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 301 enum VK_KHR_external_fence_win32 = 1; 302 303 enum VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1; 304 enum VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME = "VK_KHR_external_fence_win32"; 305 306 struct VkImportFenceWin32HandleInfoKHR { 307 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; 308 const( void )* pNext; 309 VkFence fence; 310 VkFenceImportFlags flags; 311 VkExternalFenceHandleTypeFlagBits handleType; 312 HANDLE handle; 313 LPCWSTR name; 314 } 315 316 struct VkExportFenceWin32HandleInfoKHR { 317 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; 318 const( void )* pNext; 319 const( SECURITY_ATTRIBUTES )* pAttributes; 320 DWORD dwAccess; 321 LPCWSTR name; 322 } 323 324 struct VkFenceGetWin32HandleInfoKHR { 325 VkStructureType sType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; 326 const( void )* pNext; 327 VkFence fence; 328 VkExternalFenceHandleTypeFlagBits handleType; 329 } 330 331 alias PFN_vkImportFenceWin32HandleKHR = VkResult function( VkDevice device, const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ); 332 alias PFN_vkGetFenceWin32HandleKHR = VkResult function( VkDevice device, const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 333 } 334 335 // VK_NV_external_memory_win32 : types and function pointer type aliases 336 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 337 enum VK_NV_external_memory_win32 = 1; 338 339 enum VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 340 enum VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; 341 342 struct VkImportMemoryWin32HandleInfoNV { 343 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 344 const( void )* pNext; 345 VkExternalMemoryHandleTypeFlagsNV handleType; 346 HANDLE handle; 347 } 348 349 struct VkExportMemoryWin32HandleInfoNV { 350 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 351 const( void )* pNext; 352 const( SECURITY_ATTRIBUTES )* pAttributes; 353 DWORD dwAccess; 354 } 355 356 alias PFN_vkGetMemoryWin32HandleNV = VkResult function( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ); 357 } 358 359 // VK_NV_win32_keyed_mutex : types and function pointer type aliases 360 else static if( __traits( isSame, extension, NV_win32_keyed_mutex )) { 361 enum VK_NV_win32_keyed_mutex = 1; 362 363 enum VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 364 enum VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; 365 366 struct VkWin32KeyedMutexAcquireReleaseInfoNV { 367 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 368 const( void )* pNext; 369 uint32_t acquireCount; 370 const( VkDeviceMemory )* pAcquireSyncs; 371 const( uint64_t )* pAcquireKeys; 372 const( uint32_t )* pAcquireTimeoutMilliseconds; 373 uint32_t releaseCount; 374 const( VkDeviceMemory )* pReleaseSyncs; 375 const( uint64_t )* pReleaseKeys; 376 } 377 378 } 379 380 // VK_NN_vi_surface : types and function pointer type aliases 381 else static if( __traits( isSame, extension, NN_vi_surface )) { 382 enum VK_NN_vi_surface = 1; 383 384 enum VK_NN_VI_SURFACE_SPEC_VERSION = 1; 385 enum VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface"; 386 387 alias VkViSurfaceCreateFlagsNN = VkFlags; 388 389 struct VkViSurfaceCreateInfoNN { 390 VkStructureType sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; 391 const( void )* pNext; 392 VkViSurfaceCreateFlagsNN flags; 393 void* window; 394 } 395 396 alias PFN_vkCreateViSurfaceNN = VkResult function( VkInstance instance, const( VkViSurfaceCreateInfoNN )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 397 } 398 399 // VK_EXT_acquire_xlib_display : types and function pointer type aliases 400 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 401 enum VK_EXT_acquire_xlib_display = 1; 402 403 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1; 404 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_xlib_display"; 405 406 alias PFN_vkAcquireXlibDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ); 407 alias PFN_vkGetRandROutputDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ); 408 } 409 410 // VK_MVK_ios_surface : types and function pointer type aliases 411 else static if( __traits( isSame, extension, MVK_ios_surface )) { 412 enum VK_MVK_ios_surface = 1; 413 414 enum VK_MVK_IOS_SURFACE_SPEC_VERSION = 2; 415 enum VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface"; 416 417 alias VkIOSSurfaceCreateFlagsMVK = VkFlags; 418 419 struct VkIOSSurfaceCreateInfoMVK { 420 VkStructureType sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; 421 const( void )* pNext; 422 VkIOSSurfaceCreateFlagsMVK flags; 423 const( void )* pView; 424 } 425 426 alias PFN_vkCreateIOSSurfaceMVK = VkResult function( VkInstance instance, const( VkIOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 427 } 428 429 // VK_MVK_macos_surface : types and function pointer type aliases 430 else static if( __traits( isSame, extension, MVK_macos_surface )) { 431 enum VK_MVK_macos_surface = 1; 432 433 enum VK_MVK_MACOS_SURFACE_SPEC_VERSION = 2; 434 enum VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface"; 435 436 alias VkMacOSSurfaceCreateFlagsMVK = VkFlags; 437 438 struct VkMacOSSurfaceCreateInfoMVK { 439 VkStructureType sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; 440 const( void )* pNext; 441 VkMacOSSurfaceCreateFlagsMVK flags; 442 const( void )* pView; 443 } 444 445 alias PFN_vkCreateMacOSSurfaceMVK = VkResult function( VkInstance instance, const( VkMacOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 446 } 447 448 // VK_ANDROID_external_memory_android_hardware_buffer : types and function pointer type aliases 449 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 450 enum VK_ANDROID_external_memory_android_hardware_buffer = 1; 451 452 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION = 3; 453 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME = "VK_ANDROID_external_memory_android_hardware_buffer"; 454 455 struct VkAndroidHardwareBufferUsageANDROID { 456 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; 457 void* pNext; 458 uint64_t androidHardwareBufferUsage; 459 } 460 461 struct VkAndroidHardwareBufferPropertiesANDROID { 462 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; 463 void* pNext; 464 VkDeviceSize allocationSize; 465 uint32_t memoryTypeBits; 466 } 467 468 struct VkAndroidHardwareBufferFormatPropertiesANDROID { 469 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; 470 void* pNext; 471 VkFormat format; 472 uint64_t externalFormat; 473 VkFormatFeatureFlags formatFeatures; 474 VkComponentMapping samplerYcbcrConversionComponents; 475 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 476 VkSamplerYcbcrRange suggestedYcbcrRange; 477 VkChromaLocation suggestedXChromaOffset; 478 VkChromaLocation suggestedYChromaOffset; 479 } 480 481 struct VkImportAndroidHardwareBufferInfoANDROID { 482 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 483 const( void )* pNext; 484 const( AHardwareBuffer )* buffer; 485 } 486 487 struct VkMemoryGetAndroidHardwareBufferInfoANDROID { 488 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 489 const( void )* pNext; 490 VkDeviceMemory memory; 491 } 492 493 struct VkExternalFormatANDROID { 494 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; 495 void* pNext; 496 uint64_t externalFormat; 497 } 498 499 alias PFN_vkGetAndroidHardwareBufferPropertiesANDROID = VkResult function( VkDevice device, const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ); 500 alias PFN_vkGetMemoryAndroidHardwareBufferANDROID = VkResult function( VkDevice device, const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ); 501 } 502 503 __gshared { 504 505 // VK_KHR_xlib_surface : function pointer decelerations 506 static if( __traits( isSame, extension, KHR_xlib_surface )) { 507 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 508 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 509 } 510 511 // VK_KHR_xcb_surface : function pointer decelerations 512 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 513 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 514 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 515 } 516 517 // VK_KHR_wayland_surface : function pointer decelerations 518 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 519 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 520 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 521 } 522 523 // VK_KHR_mir_surface : function pointer decelerations 524 else static if( __traits( isSame, extension, KHR_mir_surface )) { 525 PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR; 526 PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR; 527 } 528 529 // VK_KHR_android_surface : function pointer decelerations 530 else static if( __traits( isSame, extension, KHR_android_surface )) { 531 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 532 } 533 534 // VK_KHR_win32_surface : function pointer decelerations 535 else static if( __traits( isSame, extension, KHR_win32_surface )) { 536 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 537 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 538 } 539 540 // VK_KHR_external_memory_win32 : function pointer decelerations 541 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 542 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 543 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 544 } 545 546 // VK_KHR_external_semaphore_win32 : function pointer decelerations 547 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 548 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 549 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 550 } 551 552 // VK_KHR_external_fence_win32 : function pointer decelerations 553 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 554 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 555 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 556 } 557 558 // VK_NV_external_memory_win32 : function pointer decelerations 559 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 560 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 561 } 562 563 // VK_NN_vi_surface : function pointer decelerations 564 else static if( __traits( isSame, extension, NN_vi_surface )) { 565 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 566 } 567 568 // VK_EXT_acquire_xlib_display : function pointer decelerations 569 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 570 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 571 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 572 } 573 574 // VK_MVK_ios_surface : function pointer decelerations 575 else static if( __traits( isSame, extension, MVK_ios_surface )) { 576 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 577 } 578 579 // VK_MVK_macos_surface : function pointer decelerations 580 else static if( __traits( isSame, extension, MVK_macos_surface )) { 581 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 582 } 583 584 // VK_ANDROID_external_memory_android_hardware_buffer : function pointer decelerations 585 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 586 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 587 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 588 } 589 } 590 } 591 592 // compose a new loadInstanceLevelFunctions function out of 593 // unextended original function and additional function pointers from extensions 594 void loadInstanceLevelFunctions( VkInstance instance ) { 595 596 // first load all non platform related function pointers from implementation 597 erupted.functions.loadInstanceLevelFunctions( instance ); 598 599 // 2. loop through alias sequence and mixin corresponding 600 // instance level function pointer definitions 601 static foreach( extension; noDuplicateExtensions ) { 602 603 // VK_KHR_xlib_surface : load instance level function definitions 604 static if( __traits( isSame, extension, KHR_xlib_surface )) { 605 vkCreateXlibSurfaceKHR = cast( PFN_vkCreateXlibSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ); 606 vkGetPhysicalDeviceXlibPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ); 607 } 608 609 // VK_KHR_xcb_surface : load instance level function definitions 610 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 611 vkCreateXcbSurfaceKHR = cast( PFN_vkCreateXcbSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ); 612 vkGetPhysicalDeviceXcbPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ); 613 } 614 615 // VK_KHR_wayland_surface : load instance level function definitions 616 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 617 vkCreateWaylandSurfaceKHR = cast( PFN_vkCreateWaylandSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ); 618 vkGetPhysicalDeviceWaylandPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ); 619 } 620 621 // VK_KHR_mir_surface : load instance level function definitions 622 else static if( __traits( isSame, extension, KHR_mir_surface )) { 623 vkCreateMirSurfaceKHR = cast( PFN_vkCreateMirSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateMirSurfaceKHR" ); 624 vkGetPhysicalDeviceMirPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceMirPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMirPresentationSupportKHR" ); 625 } 626 627 // VK_KHR_android_surface : load instance level function definitions 628 else static if( __traits( isSame, extension, KHR_android_surface )) { 629 vkCreateAndroidSurfaceKHR = cast( PFN_vkCreateAndroidSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ); 630 } 631 632 // VK_KHR_win32_surface : load instance level function definitions 633 else static if( __traits( isSame, extension, KHR_win32_surface )) { 634 vkCreateWin32SurfaceKHR = cast( PFN_vkCreateWin32SurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ); 635 vkGetPhysicalDeviceWin32PresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ); 636 } 637 638 // VK_NN_vi_surface : load instance level function definitions 639 else static if( __traits( isSame, extension, NN_vi_surface )) { 640 vkCreateViSurfaceNN = cast( PFN_vkCreateViSurfaceNN ) vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ); 641 } 642 643 // VK_EXT_acquire_xlib_display : load instance level function definitions 644 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 645 vkAcquireXlibDisplayEXT = cast( PFN_vkAcquireXlibDisplayEXT ) vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ); 646 vkGetRandROutputDisplayEXT = cast( PFN_vkGetRandROutputDisplayEXT ) vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ); 647 } 648 649 // VK_MVK_ios_surface : load instance level function definitions 650 else static if( __traits( isSame, extension, MVK_ios_surface )) { 651 vkCreateIOSSurfaceMVK = cast( PFN_vkCreateIOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ); 652 } 653 654 // VK_MVK_macos_surface : load instance level function definitions 655 else static if( __traits( isSame, extension, MVK_macos_surface )) { 656 vkCreateMacOSSurfaceMVK = cast( PFN_vkCreateMacOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ); 657 } 658 } 659 } 660 661 // compose a new loadDeviceLevelFunctions function out of 662 // unextended original function and additional function pointers from extensions 663 void loadDeviceLevelFunctions( VkInstance instance ) { 664 665 // first load all non platform related function pointers from implementation 666 erupted.functions.loadDeviceLevelFunctions( instance ); 667 668 // 3. loop through alias sequence and mixin corresponding 669 // instance based device level function pointer definitions 670 static foreach( extension; noDuplicateExtensions ) { 671 672 // VK_KHR_external_memory_win32 : load instance based device level function definitions 673 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 674 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ); 675 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ); 676 } 677 678 // VK_KHR_external_semaphore_win32 : load instance based device level function definitions 679 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 680 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ); 681 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ); 682 } 683 684 // VK_KHR_external_fence_win32 : load instance based device level function definitions 685 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 686 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ); 687 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ); 688 } 689 690 // VK_NV_external_memory_win32 : load instance based device level function definitions 691 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 692 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ); 693 } 694 695 // VK_ANDROID_external_memory_android_hardware_buffer : load instance based device level function definitions 696 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 697 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 698 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ); 699 } 700 } 701 } 702 703 // compose a new device based loadDeviceLevelFunctions function 704 // out of unextended original and additional function pointers from extensions 705 void loadDeviceLevelFunctions( VkDevice device ) { 706 707 // first load all non platform related function pointers from implementation 708 erupted.functions.loadDeviceLevelFunctions( device ); 709 710 // 4. loop through alias sequence and mixin corresponding 711 // device based device level function pointer definitions 712 static foreach( extension; noDuplicateExtensions ) { 713 714 // VK_KHR_external_memory_win32 : load device based device level function definitions 715 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 716 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 717 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 718 } 719 720 // VK_KHR_external_semaphore_win32 : load device based device level function definitions 721 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 722 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 723 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 724 } 725 726 // VK_KHR_external_fence_win32 : load device based device level function definitions 727 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 728 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 729 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 730 } 731 732 // VK_NV_external_memory_win32 : load device based device level function definitions 733 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 734 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 735 } 736 737 // VK_ANDROID_external_memory_android_hardware_buffer : load device based device level function definitions 738 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 739 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 740 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 741 } 742 } 743 } 744 745 // compose a new dispatch device out of unextended original dispatch device with 746 // extended device based loadDeviceLevelFunctions member function, 747 // device and command buffer based function pointer decelerations 748 struct DispatchDevice { 749 750 // use unextended dispatch device from module erupted.functions as member and alias this 751 erupted.dispatch_device.DispatchDevice commonDispatchDevice; 752 alias commonDispatchDevice this; 753 754 // Constructor forwards parameter 'device' to 'this.loadDeviceLevelFunctions' 755 this( VkDevice device ) { 756 this.loadDeviceLevelFunctions( device ); 757 } 758 759 // compose a new device based loadDeviceLevelFunctions member function 760 // out of unextended original and additional member function pointers from extensions 761 void loadDeviceLevelFunctions( VkDevice device ) { 762 763 // first load all non platform related member function pointers of wrapped commonDispatchDevice 764 commonDispatchDevice.loadDeviceLevelFunctions( device ); 765 766 // 5. loop through alias sequence and mixin corresponding 767 // device level member function pointer definitions of this wrapping DispatchDevice 768 static foreach( extension; noDuplicateExtensions ) { 769 770 // VK_KHR_external_memory_win32 : load dispatch device member function definitions 771 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 772 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 773 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 774 } 775 776 // VK_KHR_external_semaphore_win32 : load dispatch device member function definitions 777 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 778 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 779 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 780 } 781 782 // VK_KHR_external_fence_win32 : load dispatch device member function definitions 783 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 784 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 785 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 786 } 787 788 // VK_NV_external_memory_win32 : load dispatch device member function definitions 789 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 790 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 791 } 792 793 // VK_ANDROID_external_memory_android_hardware_buffer : load dispatch device member function definitions 794 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 795 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 796 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 797 } 798 } 799 } 800 801 // 6. loop through alias sequence and mixin corresponding convenience member functions 802 // omitting device parameter of this wrapping DispatchDevice. Member vkDevice of commonDispatchDevice is used instead 803 static foreach( extension; noDuplicateExtensions ) { 804 805 // VK_KHR_external_memory_win32 : dispatch device convenience member functions 806 static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 807 VkResult GetMemoryWin32HandleKHR( const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetMemoryWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 808 VkResult GetMemoryWin32HandlePropertiesKHR( VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) { return vkGetMemoryWin32HandlePropertiesKHR( vkDevice, handleType, handle, pMemoryWin32HandleProperties ); } 809 } 810 811 // VK_KHR_external_semaphore_win32 : dispatch device convenience member functions 812 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 813 VkResult ImportSemaphoreWin32HandleKHR( const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ) { return vkImportSemaphoreWin32HandleKHR( vkDevice, pImportSemaphoreWin32HandleInfo ); } 814 VkResult GetSemaphoreWin32HandleKHR( const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetSemaphoreWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 815 } 816 817 // VK_KHR_external_fence_win32 : dispatch device convenience member functions 818 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 819 VkResult ImportFenceWin32HandleKHR( const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ) { return vkImportFenceWin32HandleKHR( vkDevice, pImportFenceWin32HandleInfo ); } 820 VkResult GetFenceWin32HandleKHR( const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetFenceWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 821 } 822 823 // VK_NV_external_memory_win32 : dispatch device convenience member functions 824 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 825 VkResult GetMemoryWin32HandleNV( VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) { return vkGetMemoryWin32HandleNV( vkDevice, memory, handleType, pHandle ); } 826 } 827 828 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device convenience member functions 829 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 830 VkResult GetAndroidHardwareBufferPropertiesANDROID( const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) { return vkGetAndroidHardwareBufferPropertiesANDROID( vkDevice, buffer, pProperties ); } 831 VkResult GetMemoryAndroidHardwareBufferANDROID( const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ) { return vkGetMemoryAndroidHardwareBufferANDROID( vkDevice, pInfo, pBuffer ); } 832 } 833 } 834 835 // 7. loop last time through alias sequence and mixin corresponding function pointer declarations 836 static foreach( extension; noDuplicateExtensions ) { 837 838 // VK_KHR_xlib_surface : dispatch device member function pointer decelerations 839 static if( __traits( isSame, extension, KHR_xlib_surface )) { 840 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 841 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 842 } 843 844 // VK_KHR_xcb_surface : dispatch device member function pointer decelerations 845 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 846 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 847 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 848 } 849 850 // VK_KHR_wayland_surface : dispatch device member function pointer decelerations 851 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 852 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 853 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 854 } 855 856 // VK_KHR_mir_surface : dispatch device member function pointer decelerations 857 else static if( __traits( isSame, extension, KHR_mir_surface )) { 858 PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR; 859 PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR; 860 } 861 862 // VK_KHR_android_surface : dispatch device member function pointer decelerations 863 else static if( __traits( isSame, extension, KHR_android_surface )) { 864 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 865 } 866 867 // VK_KHR_win32_surface : dispatch device member function pointer decelerations 868 else static if( __traits( isSame, extension, KHR_win32_surface )) { 869 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 870 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 871 } 872 873 // VK_KHR_external_memory_win32 : dispatch device member function pointer decelerations 874 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 875 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 876 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 877 } 878 879 // VK_KHR_external_semaphore_win32 : dispatch device member function pointer decelerations 880 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 881 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 882 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 883 } 884 885 // VK_KHR_external_fence_win32 : dispatch device member function pointer decelerations 886 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 887 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 888 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 889 } 890 891 // VK_NV_external_memory_win32 : dispatch device member function pointer decelerations 892 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 893 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 894 } 895 896 // VK_NN_vi_surface : dispatch device member function pointer decelerations 897 else static if( __traits( isSame, extension, NN_vi_surface )) { 898 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 899 } 900 901 // VK_EXT_acquire_xlib_display : dispatch device member function pointer decelerations 902 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 903 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 904 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 905 } 906 907 // VK_MVK_ios_surface : dispatch device member function pointer decelerations 908 else static if( __traits( isSame, extension, MVK_ios_surface )) { 909 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 910 } 911 912 // VK_MVK_macos_surface : dispatch device member function pointer decelerations 913 else static if( __traits( isSame, extension, MVK_macos_surface )) { 914 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 915 } 916 917 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device member function pointer decelerations 918 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 919 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 920 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 921 } 922 } 923 } 924 }