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 }