1 /** 2 * Dlang vulkan platform specific types and functions as mixin template 3 * 4 * Copyright: Copyright 2015-2016 The Khronos Group Inc.; Copyright 2016 Alex Parrill, Peter Particle. 5 * License: $(https://opensource.org/licenses/MIT, MIT License). 6 * Authors: Copyright 2016 Alex Parrill, Peter Particle 7 */ 8 module erupted.platform_extensions; 9 10 /// define platform extension names as enums 11 /// these enums can be used directly in Platform_Extensions mixin template 12 enum KHR_xlib_surface; 13 enum KHR_xcb_surface; 14 enum KHR_wayland_surface; 15 enum KHR_android_surface; 16 enum KHR_win32_surface; 17 enum KHR_video_queue; 18 enum KHR_video_decode_queue; 19 enum KHR_external_memory_win32; 20 enum KHR_win32_keyed_mutex; 21 enum KHR_external_semaphore_win32; 22 enum KHR_external_fence_win32; 23 enum KHR_portability_subset; 24 enum KHR_video_encode_queue; 25 enum EXT_video_encode_h264; 26 enum EXT_video_decode_h264; 27 enum GGP_stream_descriptor_surface; 28 enum NV_external_memory_win32; 29 enum NV_win32_keyed_mutex; 30 enum NN_vi_surface; 31 enum EXT_acquire_xlib_display; 32 enum MVK_ios_surface; 33 enum MVK_macos_surface; 34 enum ANDROID_external_memory_android_hardware_buffer; 35 enum EXT_video_decode_h265; 36 enum GGP_frame_token; 37 enum FUCHSIA_imagepipe_surface; 38 enum EXT_metal_surface; 39 enum EXT_full_screen_exclusive; 40 enum NV_acquire_winrt_display; 41 enum EXT_directfb_surface; 42 enum FUCHSIA_external_memory; 43 enum FUCHSIA_external_semaphore; 44 enum FUCHSIA_buffer_collection; 45 enum QNX_screen_surface; 46 47 48 /// extensions to a specific platform are grouped in these enum sequences 49 import std.meta : AliasSeq; 50 alias USE_PLATFORM_XLIB_KHR = AliasSeq!( KHR_xlib_surface ); 51 alias USE_PLATFORM_XCB_KHR = AliasSeq!( KHR_xcb_surface ); 52 alias USE_PLATFORM_WAYLAND_KHR = AliasSeq!( KHR_wayland_surface ); 53 alias USE_PLATFORM_ANDROID_KHR = AliasSeq!( KHR_android_surface, ANDROID_external_memory_android_hardware_buffer ); 54 alias USE_PLATFORM_WIN32_KHR = AliasSeq!( KHR_win32_surface, KHR_external_memory_win32, KHR_win32_keyed_mutex, KHR_external_semaphore_win32, KHR_external_fence_win32, NV_external_memory_win32, NV_win32_keyed_mutex, EXT_full_screen_exclusive, NV_acquire_winrt_display ); 55 alias ENABLE_BETA_EXTENSIONS = AliasSeq!( KHR_video_queue, KHR_video_decode_queue, KHR_portability_subset, KHR_video_encode_queue, EXT_video_encode_h264, EXT_video_decode_h264, EXT_video_decode_h265 ); 56 alias USE_PLATFORM_GGP = AliasSeq!( GGP_stream_descriptor_surface, GGP_frame_token ); 57 alias USE_PLATFORM_VI_NN = AliasSeq!( NN_vi_surface ); 58 alias USE_PLATFORM_XLIB_XRANDR_EXT = AliasSeq!( EXT_acquire_xlib_display ); 59 alias USE_PLATFORM_IOS_MVK = AliasSeq!( MVK_ios_surface ); 60 alias USE_PLATFORM_MACOS_MVK = AliasSeq!( MVK_macos_surface ); 61 alias USE_PLATFORM_FUCHSIA = AliasSeq!( FUCHSIA_imagepipe_surface, FUCHSIA_external_memory, FUCHSIA_external_semaphore, FUCHSIA_buffer_collection ); 62 alias USE_PLATFORM_METAL_EXT = AliasSeq!( EXT_metal_surface ); 63 alias USE_PLATFORM_DIRECTFB_EXT = AliasSeq!( EXT_directfb_surface ); 64 alias USE_PLATFORM_SCREEN_QNX = AliasSeq!( QNX_screen_surface ); 65 66 67 68 /// instantiate platform and extension specific code with this mixin template 69 /// required types and data structures must be imported into the module where 70 /// this template is instantiated 71 mixin template Platform_Extensions( extensions... ) { 72 73 // publicly import erupted package modules 74 public import erupted.types; 75 public import erupted.functions; 76 import erupted.dispatch_device; 77 78 // mixin function linkage, nothrow and @nogc attributes for subsecuent functions 79 extern(System) nothrow @nogc: 80 81 // remove duplicates from alias sequence 82 // this might happen if a platform extension collection AND a single extension, which is included in the collection, was specified 83 // e.g.: mixin Platform_Extensions!( VK_USE_PLATFORM_WIN32_KHR, VK_KHR_external_memory_win32 ); 84 import std.meta : NoDuplicates; 85 alias noDuplicateExtensions = NoDuplicates!extensions; 86 87 // 1. loop through alias sequence and mixin corresponding 88 // extension types, aliased function pointer type definitions and __gshared function pointer declarations 89 static foreach( extension; noDuplicateExtensions ) { 90 91 // VK_KHR_xlib_surface : types and function pointer type aliases 92 static if( __traits( isSame, extension, KHR_xlib_surface )) { 93 enum VK_KHR_xlib_surface = 1; 94 95 enum VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; 96 enum VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; 97 98 alias VkXlibSurfaceCreateFlagsKHR = VkFlags; 99 100 struct VkXlibSurfaceCreateInfoKHR { 101 VkStructureType sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 102 const( void )* pNext; 103 VkXlibSurfaceCreateFlagsKHR flags; 104 Display* dpy; 105 Window window; 106 } 107 108 alias PFN_vkCreateXlibSurfaceKHR = VkResult function( VkInstance instance, const( VkXlibSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 109 alias PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ); 110 } 111 112 // VK_KHR_xcb_surface : types and function pointer type aliases 113 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 114 enum VK_KHR_xcb_surface = 1; 115 116 enum VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; 117 enum VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; 118 119 alias VkXcbSurfaceCreateFlagsKHR = VkFlags; 120 121 struct VkXcbSurfaceCreateInfoKHR { 122 VkStructureType sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 123 const( void )* pNext; 124 VkXcbSurfaceCreateFlagsKHR flags; 125 xcb_connection_t* connection; 126 xcb_window_t window; 127 } 128 129 alias PFN_vkCreateXcbSurfaceKHR = VkResult function( VkInstance instance, const( VkXcbSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 130 alias PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ); 131 } 132 133 // VK_KHR_wayland_surface : types and function pointer type aliases 134 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 135 enum VK_KHR_wayland_surface = 1; 136 137 enum VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6; 138 enum VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; 139 140 alias VkWaylandSurfaceCreateFlagsKHR = VkFlags; 141 142 struct VkWaylandSurfaceCreateInfoKHR { 143 VkStructureType sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 144 const( void )* pNext; 145 VkWaylandSurfaceCreateFlagsKHR flags; 146 const( wl_display )* display; 147 const( wl_surface )* surface; 148 } 149 150 alias PFN_vkCreateWaylandSurfaceKHR = VkResult function( VkInstance instance, const( VkWaylandSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 151 alias PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const( wl_display )* display ); 152 } 153 154 // VK_KHR_android_surface : types and function pointer type aliases 155 else static if( __traits( isSame, extension, KHR_android_surface )) { 156 enum VK_KHR_android_surface = 1; 157 158 enum VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; 159 enum VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; 160 161 alias VkAndroidSurfaceCreateFlagsKHR = VkFlags; 162 163 struct VkAndroidSurfaceCreateInfoKHR { 164 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 165 const( void )* pNext; 166 VkAndroidSurfaceCreateFlagsKHR flags; 167 const( ANativeWindow )* window; 168 } 169 170 alias PFN_vkCreateAndroidSurfaceKHR = VkResult function( VkInstance instance, const( VkAndroidSurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 171 } 172 173 // VK_KHR_win32_surface : types and function pointer type aliases 174 else static if( __traits( isSame, extension, KHR_win32_surface )) { 175 enum VK_KHR_win32_surface = 1; 176 177 enum VK_KHR_WIN32_SURFACE_SPEC_VERSION = 6; 178 enum VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; 179 180 alias VkWin32SurfaceCreateFlagsKHR = VkFlags; 181 182 struct VkWin32SurfaceCreateInfoKHR { 183 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 184 const( void )* pNext; 185 VkWin32SurfaceCreateFlagsKHR flags; 186 HINSTANCE hinstance; 187 HWND hwnd; 188 } 189 190 alias PFN_vkCreateWin32SurfaceKHR = VkResult function( VkInstance instance, const( VkWin32SurfaceCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 191 alias PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ); 192 } 193 194 // VK_KHR_video_queue : types and function pointer type aliases 195 else static if( __traits( isSame, extension, KHR_video_queue )) { 196 enum VK_KHR_video_queue = 1; 197 198 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkVideoSessionKHR} ); 199 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkVideoSessionParametersKHR} ); 200 201 enum VK_KHR_VIDEO_QUEUE_SPEC_VERSION = 2; 202 enum VK_KHR_VIDEO_QUEUE_EXTENSION_NAME = "VK_KHR_video_queue"; 203 204 enum VkQueryResultStatusKHR { 205 VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, 206 VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, 207 VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, 208 VK_QUERY_RESULT_STATUS_BEGIN_RANGE_KHR = VK_QUERY_RESULT_STATUS_ERROR_KHR, 209 VK_QUERY_RESULT_STATUS_END_RANGE_KHR = VK_QUERY_RESULT_STATUS_COMPLETE_KHR, 210 VK_QUERY_RESULT_STATUS_RANGE_SIZE_KHR = VK_QUERY_RESULT_STATUS_COMPLETE_KHR - VK_QUERY_RESULT_STATUS_ERROR_KHR + 1, 211 VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF 212 } 213 214 enum VK_QUERY_RESULT_STATUS_ERROR_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_ERROR_KHR; 215 enum VK_QUERY_RESULT_STATUS_NOT_READY_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_NOT_READY_KHR; 216 enum VK_QUERY_RESULT_STATUS_COMPLETE_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_COMPLETE_KHR; 217 enum VK_QUERY_RESULT_STATUS_BEGIN_RANGE_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_BEGIN_RANGE_KHR; 218 enum VK_QUERY_RESULT_STATUS_END_RANGE_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_END_RANGE_KHR; 219 enum VK_QUERY_RESULT_STATUS_RANGE_SIZE_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_RANGE_SIZE_KHR; 220 enum VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = VkQueryResultStatusKHR.VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR; 221 222 alias VkVideoCodecOperationFlagsKHR = VkFlags; 223 enum VkVideoCodecOperationFlagBitsKHR : VkVideoCodecOperationFlagsKHR { 224 VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0, 225 VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, 226 VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001, 227 VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002, 228 VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 229 } 230 231 enum VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = VkVideoCodecOperationFlagBitsKHR.VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR; 232 enum VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = VkVideoCodecOperationFlagBitsKHR.VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT; 233 enum VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = VkVideoCodecOperationFlagBitsKHR.VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT; 234 enum VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = VkVideoCodecOperationFlagBitsKHR.VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT; 235 enum VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = VkVideoCodecOperationFlagBitsKHR.VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR; 236 237 alias VkVideoChromaSubsamplingFlagsKHR = VkFlags; 238 enum VkVideoChromaSubsamplingFlagBitsKHR : VkVideoChromaSubsamplingFlagsKHR { 239 VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0, 240 VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, 241 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, 242 VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, 243 VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, 244 VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 245 } 246 247 enum VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = VkVideoChromaSubsamplingFlagBitsKHR.VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR; 248 enum VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = VkVideoChromaSubsamplingFlagBitsKHR.VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR; 249 enum VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = VkVideoChromaSubsamplingFlagBitsKHR.VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR; 250 enum VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = VkVideoChromaSubsamplingFlagBitsKHR.VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR; 251 enum VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = VkVideoChromaSubsamplingFlagBitsKHR.VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR; 252 enum VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = VkVideoChromaSubsamplingFlagBitsKHR.VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR; 253 254 alias VkVideoComponentBitDepthFlagsKHR = VkFlags; 255 enum VkVideoComponentBitDepthFlagBitsKHR : VkVideoComponentBitDepthFlagsKHR { 256 VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, 257 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, 258 VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, 259 VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, 260 VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 261 } 262 263 enum VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = VkVideoComponentBitDepthFlagBitsKHR.VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR; 264 enum VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = VkVideoComponentBitDepthFlagBitsKHR.VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR; 265 enum VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = VkVideoComponentBitDepthFlagBitsKHR.VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR; 266 enum VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = VkVideoComponentBitDepthFlagBitsKHR.VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR; 267 enum VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = VkVideoComponentBitDepthFlagBitsKHR.VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR; 268 269 alias VkVideoCapabilityFlagsKHR = VkFlags; 270 enum VkVideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR { 271 VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, 272 VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, 273 VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 274 } 275 276 enum VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = VkVideoCapabilityFlagBitsKHR.VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; 277 enum VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = VkVideoCapabilityFlagBitsKHR.VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; 278 enum VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = VkVideoCapabilityFlagBitsKHR.VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR; 279 280 alias VkVideoSessionCreateFlagsKHR = VkFlags; 281 enum VkVideoSessionCreateFlagBitsKHR : VkVideoSessionCreateFlagsKHR { 282 VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0, 283 VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, 284 VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 285 } 286 287 enum VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = VkVideoSessionCreateFlagBitsKHR.VK_VIDEO_SESSION_CREATE_DEFAULT_KHR; 288 enum VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = VkVideoSessionCreateFlagBitsKHR.VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR; 289 enum VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = VkVideoSessionCreateFlagBitsKHR.VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR; 290 alias VkVideoBeginCodingFlagsKHR = VkFlags; 291 alias VkVideoEndCodingFlagsKHR = VkFlags; 292 293 alias VkVideoCodingControlFlagsKHR = VkFlags; 294 enum VkVideoCodingControlFlagBitsKHR : VkVideoCodingControlFlagsKHR { 295 VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0, 296 VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, 297 VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 298 } 299 300 enum VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = VkVideoCodingControlFlagBitsKHR.VK_VIDEO_CODING_CONTROL_DEFAULT_KHR; 301 enum VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = VkVideoCodingControlFlagBitsKHR.VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR; 302 enum VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = VkVideoCodingControlFlagBitsKHR.VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR; 303 304 alias VkVideoCodingQualityPresetFlagsKHR = VkFlags; 305 enum VkVideoCodingQualityPresetFlagBitsKHR : VkVideoCodingQualityPresetFlagsKHR { 306 VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001, 307 VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002, 308 VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004, 309 VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 310 } 311 312 enum VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = VkVideoCodingQualityPresetFlagBitsKHR.VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR; 313 enum VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = VkVideoCodingQualityPresetFlagBitsKHR.VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR; 314 enum VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = VkVideoCodingQualityPresetFlagBitsKHR.VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR; 315 enum VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = VkVideoCodingQualityPresetFlagBitsKHR.VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR; 316 317 struct VkVideoQueueFamilyProperties2KHR { 318 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR; 319 void* pNext; 320 VkVideoCodecOperationFlagsKHR videoCodecOperations; 321 } 322 323 struct VkVideoProfileKHR { 324 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR; 325 void* pNext; 326 VkVideoCodecOperationFlagBitsKHR videoCodecOperation; 327 VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; 328 VkVideoComponentBitDepthFlagsKHR lumaBitDepth; 329 VkVideoComponentBitDepthFlagsKHR chromaBitDepth; 330 } 331 332 struct VkVideoProfilesKHR { 333 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR; 334 void* pNext; 335 uint32_t profileCount; 336 const( VkVideoProfileKHR )* pProfiles; 337 } 338 339 struct VkVideoCapabilitiesKHR { 340 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; 341 void* pNext; 342 VkVideoCapabilityFlagsKHR capabilityFlags; 343 VkDeviceSize minBitstreamBufferOffsetAlignment; 344 VkDeviceSize minBitstreamBufferSizeAlignment; 345 VkExtent2D videoPictureExtentGranularity; 346 VkExtent2D minExtent; 347 VkExtent2D maxExtent; 348 uint32_t maxReferencePicturesSlotsCount; 349 uint32_t maxReferencePicturesActiveCount; 350 } 351 352 struct VkPhysicalDeviceVideoFormatInfoKHR { 353 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; 354 void* pNext; 355 VkImageUsageFlags imageUsage; 356 const( VkVideoProfilesKHR )* pVideoProfiles; 357 } 358 359 struct VkVideoFormatPropertiesKHR { 360 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; 361 void* pNext; 362 VkFormat format; 363 } 364 365 struct VkVideoPictureResourceKHR { 366 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR; 367 const( void )* pNext; 368 VkOffset2D codedOffset; 369 VkExtent2D codedExtent; 370 uint32_t baseArrayLayer; 371 VkImageView imageViewBinding; 372 } 373 374 struct VkVideoReferenceSlotKHR { 375 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR; 376 const( void )* pNext; 377 int8_t slotIndex; 378 const( VkVideoPictureResourceKHR )* pPictureResource; 379 } 380 381 struct VkVideoGetMemoryPropertiesKHR { 382 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR; 383 const( void )* pNext; 384 uint32_t memoryBindIndex; 385 VkMemoryRequirements2* pMemoryRequirements; 386 } 387 388 struct VkVideoBindMemoryKHR { 389 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR; 390 const( void )* pNext; 391 uint32_t memoryBindIndex; 392 VkDeviceMemory memory; 393 VkDeviceSize memoryOffset; 394 VkDeviceSize memorySize; 395 } 396 397 struct VkVideoSessionCreateInfoKHR { 398 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR; 399 const( void )* pNext; 400 uint32_t queueFamilyIndex; 401 VkVideoSessionCreateFlagsKHR flags; 402 const( VkVideoProfileKHR )* pVideoProfile; 403 VkFormat pictureFormat; 404 VkExtent2D maxCodedExtent; 405 VkFormat referencePicturesFormat; 406 uint32_t maxReferencePicturesSlotsCount; 407 uint32_t maxReferencePicturesActiveCount; 408 } 409 410 struct VkVideoSessionParametersCreateInfoKHR { 411 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; 412 const( void )* pNext; 413 VkVideoSessionParametersKHR videoSessionParametersTemplate; 414 VkVideoSessionKHR videoSession; 415 } 416 417 struct VkVideoSessionParametersUpdateInfoKHR { 418 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; 419 const( void )* pNext; 420 uint32_t updateSequenceCount; 421 } 422 423 struct VkVideoBeginCodingInfoKHR { 424 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR; 425 const( void )* pNext; 426 VkVideoBeginCodingFlagsKHR flags; 427 VkVideoCodingQualityPresetFlagsKHR codecQualityPreset; 428 VkVideoSessionKHR videoSession; 429 VkVideoSessionParametersKHR videoSessionParameters; 430 uint32_t referenceSlotCount; 431 const( VkVideoReferenceSlotKHR )* pReferenceSlots; 432 } 433 434 struct VkVideoEndCodingInfoKHR { 435 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR; 436 const( void )* pNext; 437 VkVideoEndCodingFlagsKHR flags; 438 } 439 440 struct VkVideoCodingControlInfoKHR { 441 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR; 442 const( void )* pNext; 443 VkVideoCodingControlFlagsKHR flags; 444 } 445 446 alias PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = VkResult function( VkPhysicalDevice physicalDevice, const( VkVideoProfileKHR )* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities ); 447 alias PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = VkResult function( VkPhysicalDevice physicalDevice, const( VkPhysicalDeviceVideoFormatInfoKHR )* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties ); 448 alias PFN_vkCreateVideoSessionKHR = VkResult function( VkDevice device, const( VkVideoSessionCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkVideoSessionKHR* pVideoSession ); 449 alias PFN_vkDestroyVideoSessionKHR = void function( VkDevice device, VkVideoSessionKHR videoSession, const( VkAllocationCallbacks )* pAllocator ); 450 alias PFN_vkGetVideoSessionMemoryRequirementsKHR = VkResult function( VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements ); 451 alias PFN_vkBindVideoSessionMemoryKHR = VkResult function( VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const( VkVideoBindMemoryKHR )* pVideoSessionBindMemories ); 452 alias PFN_vkCreateVideoSessionParametersKHR = VkResult function( VkDevice device, const( VkVideoSessionParametersCreateInfoKHR )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters ); 453 alias PFN_vkUpdateVideoSessionParametersKHR = VkResult function( VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const( VkVideoSessionParametersUpdateInfoKHR )* pUpdateInfo ); 454 alias PFN_vkDestroyVideoSessionParametersKHR = void function( VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const( VkAllocationCallbacks )* pAllocator ); 455 alias PFN_vkCmdBeginVideoCodingKHR = void function( VkCommandBuffer commandBuffer, const( VkVideoBeginCodingInfoKHR )* pBeginInfo ); 456 alias PFN_vkCmdEndVideoCodingKHR = void function( VkCommandBuffer commandBuffer, const( VkVideoEndCodingInfoKHR )* pEndCodingInfo ); 457 alias PFN_vkCmdControlVideoCodingKHR = void function( VkCommandBuffer commandBuffer, const( VkVideoCodingControlInfoKHR )* pCodingControlInfo ); 458 } 459 460 // VK_KHR_video_decode_queue : types and function pointer type aliases 461 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 462 enum VK_KHR_video_decode_queue = 1; 463 464 enum VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION = 2; 465 enum VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME = "VK_KHR_video_decode_queue"; 466 467 alias VkVideoDecodeFlagsKHR = VkFlags; 468 enum VkVideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR { 469 VK_VIDEO_DECODE_DEFAULT_KHR = 0, 470 VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001, 471 VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 472 } 473 474 enum VK_VIDEO_DECODE_DEFAULT_KHR = VkVideoDecodeFlagBitsKHR.VK_VIDEO_DECODE_DEFAULT_KHR; 475 enum VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = VkVideoDecodeFlagBitsKHR.VK_VIDEO_DECODE_RESERVED_0_BIT_KHR; 476 enum VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = VkVideoDecodeFlagBitsKHR.VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR; 477 478 struct VkVideoDecodeInfoKHR { 479 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR; 480 const( void )* pNext; 481 VkVideoDecodeFlagsKHR flags; 482 VkOffset2D codedOffset; 483 VkExtent2D codedExtent; 484 VkBuffer srcBuffer; 485 VkDeviceSize srcBufferOffset; 486 VkDeviceSize srcBufferRange; 487 VkVideoPictureResourceKHR dstPictureResource; 488 const( VkVideoReferenceSlotKHR )* pSetupReferenceSlot; 489 uint32_t referenceSlotCount; 490 const( VkVideoReferenceSlotKHR )* pReferenceSlots; 491 } 492 493 alias PFN_vkCmdDecodeVideoKHR = void function( VkCommandBuffer commandBuffer, const( VkVideoDecodeInfoKHR )* pFrameInfo ); 494 } 495 496 // VK_KHR_external_memory_win32 : types and function pointer type aliases 497 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 498 enum VK_KHR_external_memory_win32 = 1; 499 500 enum VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 501 enum VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_KHR_external_memory_win32"; 502 503 struct VkImportMemoryWin32HandleInfoKHR { 504 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; 505 const( void )* pNext; 506 VkExternalMemoryHandleTypeFlagBits handleType; 507 HANDLE handle; 508 LPCWSTR name; 509 } 510 511 struct VkExportMemoryWin32HandleInfoKHR { 512 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; 513 const( void )* pNext; 514 const( SECURITY_ATTRIBUTES )* pAttributes; 515 DWORD dwAccess; 516 LPCWSTR name; 517 } 518 519 struct VkMemoryWin32HandlePropertiesKHR { 520 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; 521 void* pNext; 522 uint32_t memoryTypeBits; 523 } 524 525 struct VkMemoryGetWin32HandleInfoKHR { 526 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; 527 const( void )* pNext; 528 VkDeviceMemory memory; 529 VkExternalMemoryHandleTypeFlagBits handleType; 530 } 531 532 alias PFN_vkGetMemoryWin32HandleKHR = VkResult function( VkDevice device, const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 533 alias PFN_vkGetMemoryWin32HandlePropertiesKHR = VkResult function( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ); 534 } 535 536 // VK_KHR_win32_keyed_mutex : types and function pointer type aliases 537 else static if( __traits( isSame, extension, KHR_win32_keyed_mutex )) { 538 enum VK_KHR_win32_keyed_mutex = 1; 539 540 enum VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 541 enum VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_KHR_win32_keyed_mutex"; 542 543 struct VkWin32KeyedMutexAcquireReleaseInfoKHR { 544 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; 545 const( void )* pNext; 546 uint32_t acquireCount; 547 const( VkDeviceMemory )* pAcquireSyncs; 548 const( uint64_t )* pAcquireKeys; 549 const( uint32_t )* pAcquireTimeouts; 550 uint32_t releaseCount; 551 const( VkDeviceMemory )* pReleaseSyncs; 552 const( uint64_t )* pReleaseKeys; 553 } 554 555 } 556 557 // VK_KHR_external_semaphore_win32 : types and function pointer type aliases 558 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 559 enum VK_KHR_external_semaphore_win32 = 1; 560 561 enum VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1; 562 enum VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = "VK_KHR_external_semaphore_win32"; 563 564 struct VkImportSemaphoreWin32HandleInfoKHR { 565 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; 566 const( void )* pNext; 567 VkSemaphore semaphore; 568 VkSemaphoreImportFlags flags; 569 VkExternalSemaphoreHandleTypeFlagBits handleType; 570 HANDLE handle; 571 LPCWSTR name; 572 } 573 574 struct VkExportSemaphoreWin32HandleInfoKHR { 575 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; 576 const( void )* pNext; 577 const( SECURITY_ATTRIBUTES )* pAttributes; 578 DWORD dwAccess; 579 LPCWSTR name; 580 } 581 582 struct VkD3D12FenceSubmitInfoKHR { 583 VkStructureType sType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; 584 const( void )* pNext; 585 uint32_t waitSemaphoreValuesCount; 586 const( uint64_t )* pWaitSemaphoreValues; 587 uint32_t signalSemaphoreValuesCount; 588 const( uint64_t )* pSignalSemaphoreValues; 589 } 590 591 struct VkSemaphoreGetWin32HandleInfoKHR { 592 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; 593 const( void )* pNext; 594 VkSemaphore semaphore; 595 VkExternalSemaphoreHandleTypeFlagBits handleType; 596 } 597 598 alias PFN_vkImportSemaphoreWin32HandleKHR = VkResult function( VkDevice device, const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ); 599 alias PFN_vkGetSemaphoreWin32HandleKHR = VkResult function( VkDevice device, const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 600 } 601 602 // VK_KHR_external_fence_win32 : types and function pointer type aliases 603 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 604 enum VK_KHR_external_fence_win32 = 1; 605 606 enum VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1; 607 enum VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME = "VK_KHR_external_fence_win32"; 608 609 struct VkImportFenceWin32HandleInfoKHR { 610 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; 611 const( void )* pNext; 612 VkFence fence; 613 VkFenceImportFlags flags; 614 VkExternalFenceHandleTypeFlagBits handleType; 615 HANDLE handle; 616 LPCWSTR name; 617 } 618 619 struct VkExportFenceWin32HandleInfoKHR { 620 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; 621 const( void )* pNext; 622 const( SECURITY_ATTRIBUTES )* pAttributes; 623 DWORD dwAccess; 624 LPCWSTR name; 625 } 626 627 struct VkFenceGetWin32HandleInfoKHR { 628 VkStructureType sType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; 629 const( void )* pNext; 630 VkFence fence; 631 VkExternalFenceHandleTypeFlagBits handleType; 632 } 633 634 alias PFN_vkImportFenceWin32HandleKHR = VkResult function( VkDevice device, const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ); 635 alias PFN_vkGetFenceWin32HandleKHR = VkResult function( VkDevice device, const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ); 636 } 637 638 // VK_KHR_portability_subset : types and function pointer type aliases 639 else static if( __traits( isSame, extension, KHR_portability_subset )) { 640 enum VK_KHR_portability_subset = 1; 641 642 enum VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION = 1; 643 enum VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME = "VK_KHR_portability_subset"; 644 645 struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { 646 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; 647 void* pNext; 648 VkBool32 constantAlphaColorBlendFactors; 649 VkBool32 events; 650 VkBool32 imageViewFormatReinterpretation; 651 VkBool32 imageViewFormatSwizzle; 652 VkBool32 imageView2DOn3DImage; 653 VkBool32 multisampleArrayImage; 654 VkBool32 mutableComparisonSamplers; 655 VkBool32 pointPolygons; 656 VkBool32 samplerMipLodBias; 657 VkBool32 separateStencilMaskRef; 658 VkBool32 shaderSampleRateInterpolationFunctions; 659 VkBool32 tessellationIsolines; 660 VkBool32 tessellationPointMode; 661 VkBool32 triangleFans; 662 VkBool32 vertexAttributeAccessBeyondStride; 663 } 664 665 struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { 666 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; 667 void* pNext; 668 uint32_t minVertexInputBindingStrideAlignment; 669 } 670 671 } 672 673 // VK_KHR_video_encode_queue : types and function pointer type aliases 674 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 675 enum VK_KHR_video_encode_queue = 1; 676 677 enum VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION = 3; 678 enum VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME = "VK_KHR_video_encode_queue"; 679 680 alias VkVideoEncodeFlagsKHR = VkFlags; 681 enum VkVideoEncodeFlagBitsKHR : VkVideoEncodeFlagsKHR { 682 VK_VIDEO_ENCODE_DEFAULT_KHR = 0, 683 VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001, 684 VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 685 } 686 687 enum VK_VIDEO_ENCODE_DEFAULT_KHR = VkVideoEncodeFlagBitsKHR.VK_VIDEO_ENCODE_DEFAULT_KHR; 688 enum VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = VkVideoEncodeFlagBitsKHR.VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR; 689 enum VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = VkVideoEncodeFlagBitsKHR.VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR; 690 691 alias VkVideoEncodeRateControlFlagsKHR = VkFlags; 692 enum VkVideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR { 693 VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0, 694 VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR = 0x00000001, 695 VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 696 } 697 698 enum VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = VkVideoEncodeRateControlFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR; 699 enum VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR = VkVideoEncodeRateControlFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR; 700 enum VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = VkVideoEncodeRateControlFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR; 701 702 alias VkVideoEncodeRateControlModeFlagsKHR = VkFlags; 703 enum VkVideoEncodeRateControlModeFlagBitsKHR : VkVideoEncodeRateControlModeFlagsKHR { 704 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0, 705 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1, 706 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2, 707 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 708 } 709 710 enum VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = VkVideoEncodeRateControlModeFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR; 711 enum VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = VkVideoEncodeRateControlModeFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; 712 enum VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = VkVideoEncodeRateControlModeFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; 713 enum VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = VkVideoEncodeRateControlModeFlagBitsKHR.VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR; 714 715 struct VkVideoEncodeInfoKHR { 716 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR; 717 const( void )* pNext; 718 VkVideoEncodeFlagsKHR flags; 719 uint32_t qualityLevel; 720 VkExtent2D codedExtent; 721 VkBuffer dstBitstreamBuffer; 722 VkDeviceSize dstBitstreamBufferOffset; 723 VkDeviceSize dstBitstreamBufferMaxRange; 724 VkVideoPictureResourceKHR srcPictureResource; 725 const( VkVideoReferenceSlotKHR )* pSetupReferenceSlot; 726 uint32_t referenceSlotCount; 727 const( VkVideoReferenceSlotKHR )* pReferenceSlots; 728 } 729 730 struct VkVideoEncodeRateControlInfoKHR { 731 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; 732 const( void )* pNext; 733 VkVideoEncodeRateControlFlagsKHR flags; 734 VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; 735 uint32_t averageBitrate; 736 uint16_t peakToAverageBitrateRatio; 737 uint16_t frameRateNumerator; 738 uint16_t frameRateDenominator; 739 uint32_t virtualBufferSizeInMs; 740 } 741 742 alias PFN_vkCmdEncodeVideoKHR = void function( VkCommandBuffer commandBuffer, const( VkVideoEncodeInfoKHR )* pEncodeInfo ); 743 } 744 745 // VK_EXT_video_encode_h264 : types and function pointer type aliases 746 else static if( __traits( isSame, extension, EXT_video_encode_h264 )) { 747 enum VK_EXT_video_encode_h264 = 1; 748 749 enum VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION = 2; 750 enum VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME = "VK_EXT_video_encode_h264"; 751 752 alias VkVideoEncodeH264CapabilityFlagsEXT = VkFlags; 753 enum VkVideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT { 754 VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001, 755 VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002, 756 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004, 757 VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00000008, 758 VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000010, 759 VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000020, 760 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00000040, 761 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00000080, 762 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100, 763 VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200, 764 VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400, 765 VK_VIDEO_ENCODE_H2_64_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 766 } 767 768 enum VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT; 769 enum VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT; 770 enum VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT; 771 enum VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT; 772 enum VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT; 773 enum VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT; 774 enum VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT; 775 enum VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT; 776 enum VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT; 777 enum VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT; 778 enum VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT; 779 enum VK_VIDEO_ENCODE_H2_64_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = VkVideoEncodeH264CapabilityFlagBitsEXT.VK_VIDEO_ENCODE_H2_64_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT; 780 781 alias VkVideoEncodeH264InputModeFlagsEXT = VkFlags; 782 enum VkVideoEncodeH264InputModeFlagBitsEXT : VkVideoEncodeH264InputModeFlagsEXT { 783 VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001, 784 VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002, 785 VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, 786 VK_VIDEO_ENCODE_H2_64_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 787 } 788 789 enum VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = VkVideoEncodeH264InputModeFlagBitsEXT.VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT; 790 enum VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = VkVideoEncodeH264InputModeFlagBitsEXT.VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT; 791 enum VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = VkVideoEncodeH264InputModeFlagBitsEXT.VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT; 792 enum VK_VIDEO_ENCODE_H2_64_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = VkVideoEncodeH264InputModeFlagBitsEXT.VK_VIDEO_ENCODE_H2_64_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT; 793 794 alias VkVideoEncodeH264OutputModeFlagsEXT = VkFlags; 795 enum VkVideoEncodeH264OutputModeFlagBitsEXT : VkVideoEncodeH264OutputModeFlagsEXT { 796 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001, 797 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002, 798 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, 799 VK_VIDEO_ENCODE_H2_64_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 800 } 801 802 enum VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = VkVideoEncodeH264OutputModeFlagBitsEXT.VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT; 803 enum VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = VkVideoEncodeH264OutputModeFlagBitsEXT.VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT; 804 enum VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = VkVideoEncodeH264OutputModeFlagBitsEXT.VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT; 805 enum VK_VIDEO_ENCODE_H2_64_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = VkVideoEncodeH264OutputModeFlagBitsEXT.VK_VIDEO_ENCODE_H2_64_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT; 806 807 alias VkVideoEncodeH264CreateFlagsEXT = VkFlags; 808 enum VkVideoEncodeH264CreateFlagBitsEXT : VkVideoEncodeH264CreateFlagsEXT { 809 VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT = 0, 810 VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT = 0x00000001, 811 VK_VIDEO_ENCODE_H2_64_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 812 } 813 814 enum VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT = VkVideoEncodeH264CreateFlagBitsEXT.VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT; 815 enum VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT = VkVideoEncodeH264CreateFlagBitsEXT.VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT; 816 enum VK_VIDEO_ENCODE_H2_64_CREATE_FLAG_BITS_MAX_ENUM_EXT = VkVideoEncodeH264CreateFlagBitsEXT.VK_VIDEO_ENCODE_H2_64_CREATE_FLAG_BITS_MAX_ENUM_EXT; 817 818 struct VkVideoEncodeH264CapabilitiesEXT { 819 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT; 820 const( void )* pNext; 821 VkVideoEncodeH264CapabilityFlagsEXT flags; 822 VkVideoEncodeH264InputModeFlagsEXT inputModeFlags; 823 VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags; 824 VkExtent2D minPictureSizeInMbs; 825 VkExtent2D maxPictureSizeInMbs; 826 VkExtent2D inputImageDataAlignment; 827 uint8_t maxNumL0ReferenceForP; 828 uint8_t maxNumL0ReferenceForB; 829 uint8_t maxNumL1Reference; 830 uint8_t qualityLevelCount; 831 VkExtensionProperties stdExtensionVersion; 832 } 833 834 struct VkVideoEncodeH264SessionCreateInfoEXT { 835 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT; 836 const( void )* pNext; 837 VkVideoEncodeH264CreateFlagsEXT flags; 838 VkExtent2D maxPictureSizeInMbs; 839 const( VkExtensionProperties )* pStdExtensionVersion; 840 } 841 842 struct VkVideoEncodeH264SessionParametersAddInfoEXT { 843 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; 844 const( void )* pNext; 845 uint32_t spsStdCount; 846 const( StdVideoH264SequenceParameterSet )* pSpsStd; 847 uint32_t ppsStdCount; 848 const( StdVideoH264PictureParameterSet )* pPpsStd; 849 } 850 851 struct VkVideoEncodeH264SessionParametersCreateInfoEXT { 852 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; 853 const( void )* pNext; 854 uint32_t maxSpsStdCount; 855 uint32_t maxPpsStdCount; 856 const( VkVideoEncodeH264SessionParametersAddInfoEXT )* pParametersAddInfo; 857 } 858 859 struct VkVideoEncodeH264DpbSlotInfoEXT { 860 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT; 861 const( void )* pNext; 862 int8_t slotIndex; 863 const( StdVideoEncodeH264PictureInfo )* pStdPictureInfo; 864 } 865 866 struct VkVideoEncodeH264NaluSliceEXT { 867 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT; 868 const( void )* pNext; 869 const( StdVideoEncodeH264SliceHeader )* pSliceHeaderStd; 870 uint32_t mbCount; 871 uint8_t refFinalList0EntryCount; 872 const( VkVideoEncodeH264DpbSlotInfoEXT )* pRefFinalList0Entries; 873 uint8_t refFinalList1EntryCount; 874 const( VkVideoEncodeH264DpbSlotInfoEXT )* pRefFinalList1Entries; 875 uint32_t precedingNaluBytes; 876 uint8_t minQp; 877 uint8_t maxQp; 878 } 879 880 struct VkVideoEncodeH264VclFrameInfoEXT { 881 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT; 882 const( void )* pNext; 883 uint8_t refDefaultFinalList0EntryCount; 884 const( VkVideoEncodeH264DpbSlotInfoEXT )* pRefDefaultFinalList0Entries; 885 uint8_t refDefaultFinalList1EntryCount; 886 const( VkVideoEncodeH264DpbSlotInfoEXT )* pRefDefaultFinalList1Entries; 887 uint32_t naluSliceEntryCount; 888 const( VkVideoEncodeH264NaluSliceEXT )* pNaluSliceEntries; 889 const( VkVideoEncodeH264DpbSlotInfoEXT )* pCurrentPictureInfo; 890 } 891 892 struct VkVideoEncodeH264EmitPictureParametersEXT { 893 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT; 894 const( void )* pNext; 895 uint8_t spsId; 896 VkBool32 emitSpsEnable; 897 uint32_t ppsIdEntryCount; 898 const( uint8_t )* ppsIdEntries; 899 } 900 901 struct VkVideoEncodeH264ProfileEXT { 902 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT; 903 const( void )* pNext; 904 StdVideoH264ProfileIdc stdProfileIdc; 905 } 906 907 } 908 909 // VK_EXT_video_decode_h264 : types and function pointer type aliases 910 else static if( __traits( isSame, extension, EXT_video_decode_h264 )) { 911 enum VK_EXT_video_decode_h264 = 1; 912 913 enum VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION = 3; 914 enum VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME = "VK_EXT_video_decode_h264"; 915 916 alias VkVideoDecodeH264PictureLayoutFlagsEXT = VkFlags; 917 enum VkVideoDecodeH264PictureLayoutFlagBitsEXT : VkVideoDecodeH264PictureLayoutFlagsEXT { 918 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT = 0, 919 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT = 0x00000001, 920 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT = 0x00000002, 921 VK_VIDEO_DECODE_H2_64_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 922 } 923 924 enum VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT = VkVideoDecodeH264PictureLayoutFlagBitsEXT.VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT; 925 enum VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT = VkVideoDecodeH264PictureLayoutFlagBitsEXT.VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT; 926 enum VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT = VkVideoDecodeH264PictureLayoutFlagBitsEXT.VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT; 927 enum VK_VIDEO_DECODE_H2_64_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = VkVideoDecodeH264PictureLayoutFlagBitsEXT.VK_VIDEO_DECODE_H2_64_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT; 928 alias VkVideoDecodeH264CreateFlagsEXT = VkFlags; 929 930 struct VkVideoDecodeH264ProfileEXT { 931 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT; 932 const( void )* pNext; 933 StdVideoH264ProfileIdc stdProfileIdc; 934 VkVideoDecodeH264PictureLayoutFlagsEXT pictureLayout; 935 } 936 937 struct VkVideoDecodeH264CapabilitiesEXT { 938 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT; 939 void* pNext; 940 uint32_t maxLevel; 941 VkOffset2D fieldOffsetGranularity; 942 VkExtensionProperties stdExtensionVersion; 943 } 944 945 struct VkVideoDecodeH264SessionCreateInfoEXT { 946 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT; 947 const( void )* pNext; 948 VkVideoDecodeH264CreateFlagsEXT flags; 949 const( VkExtensionProperties )* pStdExtensionVersion; 950 } 951 952 struct VkVideoDecodeH264SessionParametersAddInfoEXT { 953 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; 954 const( void )* pNext; 955 uint32_t spsStdCount; 956 const( StdVideoH264SequenceParameterSet )* pSpsStd; 957 uint32_t ppsStdCount; 958 const( StdVideoH264PictureParameterSet )* pPpsStd; 959 } 960 961 struct VkVideoDecodeH264SessionParametersCreateInfoEXT { 962 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; 963 const( void )* pNext; 964 uint32_t maxSpsStdCount; 965 uint32_t maxPpsStdCount; 966 const( VkVideoDecodeH264SessionParametersAddInfoEXT )* pParametersAddInfo; 967 } 968 969 struct VkVideoDecodeH264PictureInfoEXT { 970 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT; 971 const( void )* pNext; 972 const( StdVideoDecodeH264PictureInfo )* pStdPictureInfo; 973 uint32_t slicesCount; 974 const( uint32_t )* pSlicesDataOffsets; 975 } 976 977 struct VkVideoDecodeH264MvcEXT { 978 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT; 979 const( void )* pNext; 980 const( StdVideoDecodeH264Mvc )* pStdMvc; 981 } 982 983 struct VkVideoDecodeH264DpbSlotInfoEXT { 984 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT; 985 const( void )* pNext; 986 const( StdVideoDecodeH264ReferenceInfo )* pStdReferenceInfo; 987 } 988 989 } 990 991 // VK_GGP_stream_descriptor_surface : types and function pointer type aliases 992 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 993 enum VK_GGP_stream_descriptor_surface = 1; 994 995 enum VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION = 1; 996 enum VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME = "VK_GGP_stream_descriptor_surface"; 997 998 alias VkStreamDescriptorSurfaceCreateFlagsGGP = VkFlags; 999 1000 struct VkStreamDescriptorSurfaceCreateInfoGGP { 1001 VkStructureType sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; 1002 const( void )* pNext; 1003 VkStreamDescriptorSurfaceCreateFlagsGGP flags; 1004 GgpStreamDescriptor streamDescriptor; 1005 } 1006 1007 alias PFN_vkCreateStreamDescriptorSurfaceGGP = VkResult function( VkInstance instance, const( VkStreamDescriptorSurfaceCreateInfoGGP )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1008 } 1009 1010 // VK_NV_external_memory_win32 : types and function pointer type aliases 1011 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1012 enum VK_NV_external_memory_win32 = 1; 1013 1014 enum VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 1015 enum VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; 1016 1017 struct VkImportMemoryWin32HandleInfoNV { 1018 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 1019 const( void )* pNext; 1020 VkExternalMemoryHandleTypeFlagsNV handleType; 1021 HANDLE handle; 1022 } 1023 1024 struct VkExportMemoryWin32HandleInfoNV { 1025 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 1026 const( void )* pNext; 1027 const( SECURITY_ATTRIBUTES )* pAttributes; 1028 DWORD dwAccess; 1029 } 1030 1031 alias PFN_vkGetMemoryWin32HandleNV = VkResult function( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ); 1032 } 1033 1034 // VK_NV_win32_keyed_mutex : types and function pointer type aliases 1035 else static if( __traits( isSame, extension, NV_win32_keyed_mutex )) { 1036 enum VK_NV_win32_keyed_mutex = 1; 1037 1038 enum VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 2; 1039 enum VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; 1040 1041 struct VkWin32KeyedMutexAcquireReleaseInfoNV { 1042 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 1043 const( void )* pNext; 1044 uint32_t acquireCount; 1045 const( VkDeviceMemory )* pAcquireSyncs; 1046 const( uint64_t )* pAcquireKeys; 1047 const( uint32_t )* pAcquireTimeoutMilliseconds; 1048 uint32_t releaseCount; 1049 const( VkDeviceMemory )* pReleaseSyncs; 1050 const( uint64_t )* pReleaseKeys; 1051 } 1052 1053 } 1054 1055 // VK_NN_vi_surface : types and function pointer type aliases 1056 else static if( __traits( isSame, extension, NN_vi_surface )) { 1057 enum VK_NN_vi_surface = 1; 1058 1059 enum VK_NN_VI_SURFACE_SPEC_VERSION = 1; 1060 enum VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface"; 1061 1062 alias VkViSurfaceCreateFlagsNN = VkFlags; 1063 1064 struct VkViSurfaceCreateInfoNN { 1065 VkStructureType sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; 1066 const( void )* pNext; 1067 VkViSurfaceCreateFlagsNN flags; 1068 void* window; 1069 } 1070 1071 alias PFN_vkCreateViSurfaceNN = VkResult function( VkInstance instance, const( VkViSurfaceCreateInfoNN )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1072 } 1073 1074 // VK_EXT_acquire_xlib_display : types and function pointer type aliases 1075 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 1076 enum VK_EXT_acquire_xlib_display = 1; 1077 1078 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1; 1079 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_xlib_display"; 1080 1081 alias PFN_vkAcquireXlibDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ); 1082 alias PFN_vkGetRandROutputDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ); 1083 } 1084 1085 // VK_MVK_ios_surface : types and function pointer type aliases 1086 else static if( __traits( isSame, extension, MVK_ios_surface )) { 1087 enum VK_MVK_ios_surface = 1; 1088 1089 enum VK_MVK_IOS_SURFACE_SPEC_VERSION = 3; 1090 enum VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface"; 1091 1092 alias VkIOSSurfaceCreateFlagsMVK = VkFlags; 1093 1094 struct VkIOSSurfaceCreateInfoMVK { 1095 VkStructureType sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; 1096 const( void )* pNext; 1097 VkIOSSurfaceCreateFlagsMVK flags; 1098 const( void )* pView; 1099 } 1100 1101 alias PFN_vkCreateIOSSurfaceMVK = VkResult function( VkInstance instance, const( VkIOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1102 } 1103 1104 // VK_MVK_macos_surface : types and function pointer type aliases 1105 else static if( __traits( isSame, extension, MVK_macos_surface )) { 1106 enum VK_MVK_macos_surface = 1; 1107 1108 enum VK_MVK_MACOS_SURFACE_SPEC_VERSION = 3; 1109 enum VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface"; 1110 1111 alias VkMacOSSurfaceCreateFlagsMVK = VkFlags; 1112 1113 struct VkMacOSSurfaceCreateInfoMVK { 1114 VkStructureType sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; 1115 const( void )* pNext; 1116 VkMacOSSurfaceCreateFlagsMVK flags; 1117 const( void )* pView; 1118 } 1119 1120 alias PFN_vkCreateMacOSSurfaceMVK = VkResult function( VkInstance instance, const( VkMacOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1121 } 1122 1123 // VK_ANDROID_external_memory_android_hardware_buffer : types and function pointer type aliases 1124 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1125 enum VK_ANDROID_external_memory_android_hardware_buffer = 1; 1126 1127 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION = 4; 1128 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME = "VK_ANDROID_external_memory_android_hardware_buffer"; 1129 1130 struct VkAndroidHardwareBufferUsageANDROID { 1131 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; 1132 void* pNext; 1133 uint64_t androidHardwareBufferUsage; 1134 } 1135 1136 struct VkAndroidHardwareBufferPropertiesANDROID { 1137 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; 1138 void* pNext; 1139 VkDeviceSize allocationSize; 1140 uint32_t memoryTypeBits; 1141 } 1142 1143 struct VkAndroidHardwareBufferFormatPropertiesANDROID { 1144 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; 1145 void* pNext; 1146 VkFormat format; 1147 uint64_t externalFormat; 1148 VkFormatFeatureFlags formatFeatures; 1149 VkComponentMapping samplerYcbcrConversionComponents; 1150 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 1151 VkSamplerYcbcrRange suggestedYcbcrRange; 1152 VkChromaLocation suggestedXChromaOffset; 1153 VkChromaLocation suggestedYChromaOffset; 1154 } 1155 1156 struct VkImportAndroidHardwareBufferInfoANDROID { 1157 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 1158 const( void )* pNext; 1159 const( AHardwareBuffer )* buffer; 1160 } 1161 1162 struct VkMemoryGetAndroidHardwareBufferInfoANDROID { 1163 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 1164 const( void )* pNext; 1165 VkDeviceMemory memory; 1166 } 1167 1168 struct VkExternalFormatANDROID { 1169 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; 1170 void* pNext; 1171 uint64_t externalFormat; 1172 } 1173 1174 struct VkAndroidHardwareBufferFormatProperties2ANDROID { 1175 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; 1176 void* pNext; 1177 VkFormat format; 1178 uint64_t externalFormat; 1179 VkFormatFeatureFlags2KHR formatFeatures; 1180 VkComponentMapping samplerYcbcrConversionComponents; 1181 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 1182 VkSamplerYcbcrRange suggestedYcbcrRange; 1183 VkChromaLocation suggestedXChromaOffset; 1184 VkChromaLocation suggestedYChromaOffset; 1185 } 1186 1187 alias PFN_vkGetAndroidHardwareBufferPropertiesANDROID = VkResult function( VkDevice device, const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ); 1188 alias PFN_vkGetMemoryAndroidHardwareBufferANDROID = VkResult function( VkDevice device, const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ); 1189 } 1190 1191 // VK_EXT_video_decode_h265 : types and function pointer type aliases 1192 else static if( __traits( isSame, extension, EXT_video_decode_h265 )) { 1193 enum VK_EXT_video_decode_h265 = 1; 1194 1195 enum VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION = 1; 1196 enum VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME = "VK_EXT_video_decode_h265"; 1197 1198 alias VkVideoDecodeH265CreateFlagsEXT = VkFlags; 1199 1200 struct VkVideoDecodeH265ProfileEXT { 1201 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT; 1202 const( void )* pNext; 1203 StdVideoH265ProfileIdc stdProfileIdc; 1204 } 1205 1206 struct VkVideoDecodeH265CapabilitiesEXT { 1207 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT; 1208 void* pNext; 1209 uint32_t maxLevel; 1210 VkExtensionProperties stdExtensionVersion; 1211 } 1212 1213 struct VkVideoDecodeH265SessionCreateInfoEXT { 1214 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT; 1215 const( void )* pNext; 1216 VkVideoDecodeH265CreateFlagsEXT flags; 1217 const( VkExtensionProperties )* pStdExtensionVersion; 1218 } 1219 1220 struct VkVideoDecodeH265SessionParametersAddInfoEXT { 1221 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT; 1222 const( void )* pNext; 1223 uint32_t spsStdCount; 1224 const( StdVideoH265SequenceParameterSet )* pSpsStd; 1225 uint32_t ppsStdCount; 1226 const( StdVideoH265PictureParameterSet )* pPpsStd; 1227 } 1228 1229 struct VkVideoDecodeH265SessionParametersCreateInfoEXT { 1230 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT; 1231 const( void )* pNext; 1232 uint32_t maxSpsStdCount; 1233 uint32_t maxPpsStdCount; 1234 const( VkVideoDecodeH265SessionParametersAddInfoEXT )* pParametersAddInfo; 1235 } 1236 1237 struct VkVideoDecodeH265PictureInfoEXT { 1238 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT; 1239 const( void )* pNext; 1240 StdVideoDecodeH265PictureInfo* pStdPictureInfo; 1241 uint32_t slicesCount; 1242 const( uint32_t )* pSlicesDataOffsets; 1243 } 1244 1245 struct VkVideoDecodeH265DpbSlotInfoEXT { 1246 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT; 1247 const( void )* pNext; 1248 const( StdVideoDecodeH265ReferenceInfo )* pStdReferenceInfo; 1249 } 1250 1251 } 1252 1253 // VK_GGP_frame_token : types and function pointer type aliases 1254 else static if( __traits( isSame, extension, GGP_frame_token )) { 1255 enum VK_GGP_frame_token = 1; 1256 1257 enum VK_GGP_FRAME_TOKEN_SPEC_VERSION = 1; 1258 enum VK_GGP_FRAME_TOKEN_EXTENSION_NAME = "VK_GGP_frame_token"; 1259 1260 struct VkPresentFrameTokenGGP { 1261 VkStructureType sType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; 1262 const( void )* pNext; 1263 GgpFrameToken frameToken; 1264 } 1265 1266 } 1267 1268 // VK_FUCHSIA_imagepipe_surface : types and function pointer type aliases 1269 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 1270 enum VK_FUCHSIA_imagepipe_surface = 1; 1271 1272 enum VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION = 1; 1273 enum VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME = "VK_FUCHSIA_imagepipe_surface"; 1274 1275 alias VkImagePipeSurfaceCreateFlagsFUCHSIA = VkFlags; 1276 1277 struct VkImagePipeSurfaceCreateInfoFUCHSIA { 1278 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; 1279 const( void )* pNext; 1280 VkImagePipeSurfaceCreateFlagsFUCHSIA flags; 1281 zx_handle_t imagePipeHandle; 1282 } 1283 1284 alias PFN_vkCreateImagePipeSurfaceFUCHSIA = VkResult function( VkInstance instance, const( VkImagePipeSurfaceCreateInfoFUCHSIA )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1285 } 1286 1287 // VK_EXT_metal_surface : types and function pointer type aliases 1288 else static if( __traits( isSame, extension, EXT_metal_surface )) { 1289 enum VK_EXT_metal_surface = 1; 1290 1291 enum VK_EXT_METAL_SURFACE_SPEC_VERSION = 1; 1292 enum VK_EXT_METAL_SURFACE_EXTENSION_NAME = "VK_EXT_metal_surface"; 1293 1294 alias VkMetalSurfaceCreateFlagsEXT = VkFlags; 1295 1296 struct VkMetalSurfaceCreateInfoEXT { 1297 VkStructureType sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; 1298 const( void )* pNext; 1299 VkMetalSurfaceCreateFlagsEXT flags; 1300 const( CAMetalLayer )* pLayer; 1301 } 1302 1303 alias PFN_vkCreateMetalSurfaceEXT = VkResult function( VkInstance instance, const( VkMetalSurfaceCreateInfoEXT )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1304 } 1305 1306 // VK_EXT_full_screen_exclusive : types and function pointer type aliases 1307 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1308 enum VK_EXT_full_screen_exclusive = 1; 1309 1310 enum VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION = 4; 1311 enum VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME = "VK_EXT_full_screen_exclusive"; 1312 1313 enum VkFullScreenExclusiveEXT { 1314 VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, 1315 VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, 1316 VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, 1317 VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, 1318 VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, 1319 VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, 1320 VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1, 1321 VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF 1322 } 1323 1324 enum VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT; 1325 enum VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT; 1326 enum VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT; 1327 enum VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT; 1328 enum VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT; 1329 enum VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT; 1330 enum VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT; 1331 enum VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT; 1332 1333 struct VkSurfaceFullScreenExclusiveInfoEXT { 1334 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; 1335 void* pNext; 1336 VkFullScreenExclusiveEXT fullScreenExclusive; 1337 } 1338 1339 struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { 1340 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; 1341 void* pNext; 1342 VkBool32 fullScreenExclusiveSupported; 1343 } 1344 1345 struct VkSurfaceFullScreenExclusiveWin32InfoEXT { 1346 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; 1347 const( void )* pNext; 1348 HMONITOR hmonitor; 1349 } 1350 1351 alias PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = VkResult function( VkPhysicalDevice physicalDevice, const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ); 1352 alias PFN_vkAcquireFullScreenExclusiveModeEXT = VkResult function( VkDevice device, VkSwapchainKHR swapchain ); 1353 alias PFN_vkReleaseFullScreenExclusiveModeEXT = VkResult function( VkDevice device, VkSwapchainKHR swapchain ); 1354 alias PFN_vkGetDeviceGroupSurfacePresentModes2EXT = VkResult function( VkDevice device, const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ); 1355 } 1356 1357 // VK_NV_acquire_winrt_display : types and function pointer type aliases 1358 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 1359 enum VK_NV_acquire_winrt_display = 1; 1360 1361 enum VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION = 1; 1362 enum VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME = "VK_NV_acquire_winrt_display"; 1363 1364 alias PFN_vkAcquireWinrtDisplayNV = VkResult function( VkPhysicalDevice physicalDevice, VkDisplayKHR display ); 1365 alias PFN_vkGetWinrtDisplayNV = VkResult function( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay ); 1366 } 1367 1368 // VK_EXT_directfb_surface : types and function pointer type aliases 1369 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 1370 enum VK_EXT_directfb_surface = 1; 1371 1372 enum VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION = 1; 1373 enum VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME = "VK_EXT_directfb_surface"; 1374 1375 alias VkDirectFBSurfaceCreateFlagsEXT = VkFlags; 1376 1377 struct VkDirectFBSurfaceCreateInfoEXT { 1378 VkStructureType sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; 1379 const( void )* pNext; 1380 VkDirectFBSurfaceCreateFlagsEXT flags; 1381 IDirectFB* dfb; 1382 IDirectFBSurface* surface; 1383 } 1384 1385 alias PFN_vkCreateDirectFBSurfaceEXT = VkResult function( VkInstance instance, const( VkDirectFBSurfaceCreateInfoEXT )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1386 alias PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb ); 1387 } 1388 1389 // VK_FUCHSIA_external_memory : types and function pointer type aliases 1390 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 1391 enum VK_FUCHSIA_external_memory = 1; 1392 1393 enum VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION = 1; 1394 enum VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_FUCHSIA_external_memory"; 1395 1396 struct VkImportMemoryZirconHandleInfoFUCHSIA { 1397 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; 1398 const( void )* pNext; 1399 VkExternalMemoryHandleTypeFlagBits handleType; 1400 zx_handle_t handle; 1401 } 1402 1403 struct VkMemoryZirconHandlePropertiesFUCHSIA { 1404 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; 1405 void* pNext; 1406 uint32_t memoryTypeBits; 1407 } 1408 1409 struct VkMemoryGetZirconHandleInfoFUCHSIA { 1410 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; 1411 const( void )* pNext; 1412 VkDeviceMemory memory; 1413 VkExternalMemoryHandleTypeFlagBits handleType; 1414 } 1415 1416 alias PFN_vkGetMemoryZirconHandleFUCHSIA = VkResult function( VkDevice device, const( VkMemoryGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ); 1417 alias PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = VkResult function( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties ); 1418 } 1419 1420 // VK_FUCHSIA_external_semaphore : types and function pointer type aliases 1421 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 1422 enum VK_FUCHSIA_external_semaphore = 1; 1423 1424 enum VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1; 1425 enum VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME = "VK_FUCHSIA_external_semaphore"; 1426 1427 struct VkImportSemaphoreZirconHandleInfoFUCHSIA { 1428 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; 1429 const( void )* pNext; 1430 VkSemaphore semaphore; 1431 VkSemaphoreImportFlags flags; 1432 VkExternalSemaphoreHandleTypeFlagBits handleType; 1433 zx_handle_t zirconHandle; 1434 } 1435 1436 struct VkSemaphoreGetZirconHandleInfoFUCHSIA { 1437 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; 1438 const( void )* pNext; 1439 VkSemaphore semaphore; 1440 VkExternalSemaphoreHandleTypeFlagBits handleType; 1441 } 1442 1443 alias PFN_vkImportSemaphoreZirconHandleFUCHSIA = VkResult function( VkDevice device, const( VkImportSemaphoreZirconHandleInfoFUCHSIA )* pImportSemaphoreZirconHandleInfo ); 1444 alias PFN_vkGetSemaphoreZirconHandleFUCHSIA = VkResult function( VkDevice device, const( VkSemaphoreGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ); 1445 } 1446 1447 // VK_FUCHSIA_buffer_collection : types and function pointer type aliases 1448 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 1449 enum VK_FUCHSIA_buffer_collection = 1; 1450 1451 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBufferCollectionFUCHSIA} ); 1452 1453 enum VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION = 2; 1454 enum VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME = "VK_FUCHSIA_buffer_collection"; 1455 1456 alias VkImageFormatConstraintsFlagsFUCHSIA = VkFlags; 1457 enum VkImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA { 1458 VK_IMAGE_FORMAT_CONSTRAINTS_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF 1459 } 1460 1461 enum VK_IMAGE_FORMAT_CONSTRAINTS_FLAG_BITS_MAX_ENUM_FUCHSIA = VkImageFormatConstraintsFlagBitsFUCHSIA.VK_IMAGE_FORMAT_CONSTRAINTS_FLAG_BITS_MAX_ENUM_FUCHSIA; 1462 1463 alias VkImageConstraintsInfoFlagsFUCHSIA = VkFlags; 1464 enum VkImageConstraintsInfoFlagBitsFUCHSIA : VkImageConstraintsInfoFlagsFUCHSIA { 1465 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001, 1466 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002, 1467 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004, 1468 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008, 1469 VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010, 1470 VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF 1471 } 1472 1473 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA; 1474 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA; 1475 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA; 1476 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA; 1477 enum VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA; 1478 enum VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA; 1479 1480 struct VkBufferCollectionCreateInfoFUCHSIA { 1481 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; 1482 const( void )* pNext; 1483 zx_handle_t collectionToken; 1484 } 1485 1486 struct VkImportMemoryBufferCollectionFUCHSIA { 1487 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; 1488 const( void )* pNext; 1489 VkBufferCollectionFUCHSIA collection; 1490 uint32_t index; 1491 } 1492 1493 struct VkBufferCollectionImageCreateInfoFUCHSIA { 1494 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; 1495 const( void )* pNext; 1496 VkBufferCollectionFUCHSIA collection; 1497 uint32_t index; 1498 } 1499 1500 struct VkBufferCollectionConstraintsInfoFUCHSIA { 1501 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; 1502 const( void )* pNext; 1503 uint32_t minBufferCount; 1504 uint32_t maxBufferCount; 1505 uint32_t minBufferCountForCamping; 1506 uint32_t minBufferCountForDedicatedSlack; 1507 uint32_t minBufferCountForSharedSlack; 1508 } 1509 1510 struct VkBufferConstraintsInfoFUCHSIA { 1511 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA; 1512 const( void )* pNext; 1513 VkBufferCreateInfo createInfo; 1514 VkFormatFeatureFlags requiredFormatFeatures; 1515 VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; 1516 } 1517 1518 struct VkBufferCollectionBufferCreateInfoFUCHSIA { 1519 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; 1520 const( void )* pNext; 1521 VkBufferCollectionFUCHSIA collection; 1522 uint32_t index; 1523 } 1524 1525 struct VkSysmemColorSpaceFUCHSIA { 1526 VkStructureType sType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA; 1527 const( void )* pNext; 1528 uint32_t colorSpace; 1529 } 1530 1531 struct VkBufferCollectionPropertiesFUCHSIA { 1532 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA; 1533 void* pNext; 1534 uint32_t memoryTypeBits; 1535 uint32_t bufferCount; 1536 uint32_t createInfoIndex; 1537 uint64_t sysmemPixelFormat; 1538 VkFormatFeatureFlags formatFeatures; 1539 VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex; 1540 VkComponentMapping samplerYcbcrConversionComponents; 1541 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 1542 VkSamplerYcbcrRange suggestedYcbcrRange; 1543 VkChromaLocation suggestedXChromaOffset; 1544 VkChromaLocation suggestedYChromaOffset; 1545 } 1546 1547 struct VkImageFormatConstraintsInfoFUCHSIA { 1548 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; 1549 const( void )* pNext; 1550 VkImageCreateInfo imageCreateInfo; 1551 VkFormatFeatureFlags requiredFormatFeatures; 1552 VkImageFormatConstraintsFlagsFUCHSIA flags; 1553 uint64_t sysmemPixelFormat; 1554 uint32_t colorSpaceCount; 1555 const( VkSysmemColorSpaceFUCHSIA )* pColorSpaces; 1556 } 1557 1558 struct VkImageConstraintsInfoFUCHSIA { 1559 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA; 1560 const( void )* pNext; 1561 uint32_t formatConstraintsCount; 1562 const( VkImageFormatConstraintsInfoFUCHSIA )* pFormatConstraints; 1563 VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; 1564 VkImageConstraintsInfoFlagsFUCHSIA flags; 1565 } 1566 1567 alias PFN_vkCreateBufferCollectionFUCHSIA = VkResult function( VkDevice device, const( VkBufferCollectionCreateInfoFUCHSIA )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkBufferCollectionFUCHSIA* pCollection ); 1568 alias PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = VkResult function( VkDevice device, VkBufferCollectionFUCHSIA collection, const( VkImageConstraintsInfoFUCHSIA )* pImageConstraintsInfo ); 1569 alias PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = VkResult function( VkDevice device, VkBufferCollectionFUCHSIA collection, const( VkBufferConstraintsInfoFUCHSIA )* pBufferConstraintsInfo ); 1570 alias PFN_vkDestroyBufferCollectionFUCHSIA = void function( VkDevice device, VkBufferCollectionFUCHSIA collection, const( VkAllocationCallbacks )* pAllocator ); 1571 alias PFN_vkGetBufferCollectionPropertiesFUCHSIA = VkResult function( VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties ); 1572 } 1573 1574 // VK_QNX_screen_surface : types and function pointer type aliases 1575 else static if( __traits( isSame, extension, QNX_screen_surface )) { 1576 enum VK_QNX_screen_surface = 1; 1577 1578 enum VK_QNX_SCREEN_SURFACE_SPEC_VERSION = 1; 1579 enum VK_QNX_SCREEN_SURFACE_EXTENSION_NAME = "VK_QNX_screen_surface"; 1580 1581 alias VkScreenSurfaceCreateFlagsQNX = VkFlags; 1582 1583 struct VkScreenSurfaceCreateInfoQNX { 1584 VkStructureType sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX; 1585 const( void )* pNext; 1586 VkScreenSurfaceCreateFlagsQNX flags; 1587 const( _screen_context )* context; 1588 const( _screen_window )* window; 1589 } 1590 1591 alias PFN_vkCreateScreenSurfaceQNX = VkResult function( VkInstance instance, const( VkScreenSurfaceCreateInfoQNX )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1592 alias PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const( _screen_window )* window ); 1593 } 1594 1595 __gshared { 1596 1597 // VK_KHR_xlib_surface : function pointer decelerations 1598 static if( __traits( isSame, extension, KHR_xlib_surface )) { 1599 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 1600 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 1601 } 1602 1603 // VK_KHR_xcb_surface : function pointer decelerations 1604 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 1605 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 1606 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 1607 } 1608 1609 // VK_KHR_wayland_surface : function pointer decelerations 1610 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 1611 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 1612 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 1613 } 1614 1615 // VK_KHR_android_surface : function pointer decelerations 1616 else static if( __traits( isSame, extension, KHR_android_surface )) { 1617 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 1618 } 1619 1620 // VK_KHR_win32_surface : function pointer decelerations 1621 else static if( __traits( isSame, extension, KHR_win32_surface )) { 1622 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 1623 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 1624 } 1625 1626 // VK_KHR_video_queue : function pointer decelerations 1627 else static if( __traits( isSame, extension, KHR_video_queue )) { 1628 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; 1629 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; 1630 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; 1631 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; 1632 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; 1633 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; 1634 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; 1635 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; 1636 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; 1637 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; 1638 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; 1639 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; 1640 } 1641 1642 // VK_KHR_video_decode_queue : function pointer decelerations 1643 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 1644 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; 1645 } 1646 1647 // VK_KHR_external_memory_win32 : function pointer decelerations 1648 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 1649 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 1650 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 1651 } 1652 1653 // VK_KHR_external_semaphore_win32 : function pointer decelerations 1654 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 1655 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 1656 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 1657 } 1658 1659 // VK_KHR_external_fence_win32 : function pointer decelerations 1660 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 1661 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 1662 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 1663 } 1664 1665 // VK_KHR_video_encode_queue : function pointer decelerations 1666 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 1667 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR; 1668 } 1669 1670 // VK_GGP_stream_descriptor_surface : function pointer decelerations 1671 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 1672 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; 1673 } 1674 1675 // VK_NV_external_memory_win32 : function pointer decelerations 1676 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1677 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 1678 } 1679 1680 // VK_NN_vi_surface : function pointer decelerations 1681 else static if( __traits( isSame, extension, NN_vi_surface )) { 1682 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 1683 } 1684 1685 // VK_EXT_acquire_xlib_display : function pointer decelerations 1686 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 1687 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 1688 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 1689 } 1690 1691 // VK_MVK_ios_surface : function pointer decelerations 1692 else static if( __traits( isSame, extension, MVK_ios_surface )) { 1693 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 1694 } 1695 1696 // VK_MVK_macos_surface : function pointer decelerations 1697 else static if( __traits( isSame, extension, MVK_macos_surface )) { 1698 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 1699 } 1700 1701 // VK_ANDROID_external_memory_android_hardware_buffer : function pointer decelerations 1702 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1703 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 1704 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 1705 } 1706 1707 // VK_FUCHSIA_imagepipe_surface : function pointer decelerations 1708 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 1709 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; 1710 } 1711 1712 // VK_EXT_metal_surface : function pointer decelerations 1713 else static if( __traits( isSame, extension, EXT_metal_surface )) { 1714 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; 1715 } 1716 1717 // VK_EXT_full_screen_exclusive : function pointer decelerations 1718 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1719 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; 1720 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; 1721 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; 1722 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; 1723 } 1724 1725 // VK_NV_acquire_winrt_display : function pointer decelerations 1726 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 1727 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; 1728 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; 1729 } 1730 1731 // VK_EXT_directfb_surface : function pointer decelerations 1732 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 1733 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; 1734 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; 1735 } 1736 1737 // VK_FUCHSIA_external_memory : function pointer decelerations 1738 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 1739 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA; 1740 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA; 1741 } 1742 1743 // VK_FUCHSIA_external_semaphore : function pointer decelerations 1744 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 1745 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA; 1746 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA; 1747 } 1748 1749 // VK_FUCHSIA_buffer_collection : function pointer decelerations 1750 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 1751 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA; 1752 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA; 1753 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA; 1754 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA; 1755 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA; 1756 } 1757 1758 // VK_QNX_screen_surface : function pointer decelerations 1759 else static if( __traits( isSame, extension, QNX_screen_surface )) { 1760 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; 1761 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX; 1762 } 1763 } 1764 } 1765 1766 // workaround for not being able to mixin two overloads with the same symbol name 1767 alias loadDeviceLevelFunctionsExt = loadDeviceLevelFunctionsExtI; 1768 alias loadDeviceLevelFunctionsExt = loadDeviceLevelFunctionsExtD; 1769 1770 // backwards compatibility aliases 1771 alias loadInstanceLevelFunctions = loadInstanceLevelFunctionsExt; 1772 alias loadDeviceLevelFunctions = loadDeviceLevelFunctionsExt; 1773 alias DispatchDevice = DispatchDeviceExt; 1774 1775 // compose loadInstanceLevelFunctionsExt function out of unextended 1776 // loadInstanceLevelFunctions and additional function pointers from extensions 1777 void loadInstanceLevelFunctionsExt( VkInstance instance ) { 1778 1779 // first load all non platform related function pointers from implementation 1780 erupted.functions.loadInstanceLevelFunctions( instance ); 1781 1782 // 2. loop through alias sequence and mixin corresponding 1783 // instance level function pointer definitions 1784 static foreach( extension; noDuplicateExtensions ) { 1785 1786 // VK_KHR_xlib_surface : load instance level function definitions 1787 static if( __traits( isSame, extension, KHR_xlib_surface )) { 1788 vkCreateXlibSurfaceKHR = cast( PFN_vkCreateXlibSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ); 1789 vkGetPhysicalDeviceXlibPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ); 1790 } 1791 1792 // VK_KHR_xcb_surface : load instance level function definitions 1793 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 1794 vkCreateXcbSurfaceKHR = cast( PFN_vkCreateXcbSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ); 1795 vkGetPhysicalDeviceXcbPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ); 1796 } 1797 1798 // VK_KHR_wayland_surface : load instance level function definitions 1799 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 1800 vkCreateWaylandSurfaceKHR = cast( PFN_vkCreateWaylandSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ); 1801 vkGetPhysicalDeviceWaylandPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ); 1802 } 1803 1804 // VK_KHR_android_surface : load instance level function definitions 1805 else static if( __traits( isSame, extension, KHR_android_surface )) { 1806 vkCreateAndroidSurfaceKHR = cast( PFN_vkCreateAndroidSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ); 1807 } 1808 1809 // VK_KHR_win32_surface : load instance level function definitions 1810 else static if( __traits( isSame, extension, KHR_win32_surface )) { 1811 vkCreateWin32SurfaceKHR = cast( PFN_vkCreateWin32SurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ); 1812 vkGetPhysicalDeviceWin32PresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ); 1813 } 1814 1815 // VK_KHR_video_queue : load instance level function definitions 1816 else static if( __traits( isSame, extension, KHR_video_queue )) { 1817 vkGetPhysicalDeviceVideoCapabilitiesKHR = cast( PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ); 1818 vkGetPhysicalDeviceVideoFormatPropertiesKHR = cast( PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ); 1819 } 1820 1821 // VK_GGP_stream_descriptor_surface : load instance level function definitions 1822 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 1823 vkCreateStreamDescriptorSurfaceGGP = cast( PFN_vkCreateStreamDescriptorSurfaceGGP ) vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ); 1824 } 1825 1826 // VK_NN_vi_surface : load instance level function definitions 1827 else static if( __traits( isSame, extension, NN_vi_surface )) { 1828 vkCreateViSurfaceNN = cast( PFN_vkCreateViSurfaceNN ) vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ); 1829 } 1830 1831 // VK_EXT_acquire_xlib_display : load instance level function definitions 1832 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 1833 vkAcquireXlibDisplayEXT = cast( PFN_vkAcquireXlibDisplayEXT ) vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ); 1834 vkGetRandROutputDisplayEXT = cast( PFN_vkGetRandROutputDisplayEXT ) vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ); 1835 } 1836 1837 // VK_MVK_ios_surface : load instance level function definitions 1838 else static if( __traits( isSame, extension, MVK_ios_surface )) { 1839 vkCreateIOSSurfaceMVK = cast( PFN_vkCreateIOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ); 1840 } 1841 1842 // VK_MVK_macos_surface : load instance level function definitions 1843 else static if( __traits( isSame, extension, MVK_macos_surface )) { 1844 vkCreateMacOSSurfaceMVK = cast( PFN_vkCreateMacOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ); 1845 } 1846 1847 // VK_FUCHSIA_imagepipe_surface : load instance level function definitions 1848 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 1849 vkCreateImagePipeSurfaceFUCHSIA = cast( PFN_vkCreateImagePipeSurfaceFUCHSIA ) vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ); 1850 } 1851 1852 // VK_EXT_metal_surface : load instance level function definitions 1853 else static if( __traits( isSame, extension, EXT_metal_surface )) { 1854 vkCreateMetalSurfaceEXT = cast( PFN_vkCreateMetalSurfaceEXT ) vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ); 1855 } 1856 1857 // VK_EXT_full_screen_exclusive : load instance level function definitions 1858 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1859 vkGetPhysicalDeviceSurfacePresentModes2EXT = cast( PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ); 1860 } 1861 1862 // VK_NV_acquire_winrt_display : load instance level function definitions 1863 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 1864 vkAcquireWinrtDisplayNV = cast( PFN_vkAcquireWinrtDisplayNV ) vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ); 1865 vkGetWinrtDisplayNV = cast( PFN_vkGetWinrtDisplayNV ) vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ); 1866 } 1867 1868 // VK_EXT_directfb_surface : load instance level function definitions 1869 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 1870 vkCreateDirectFBSurfaceEXT = cast( PFN_vkCreateDirectFBSurfaceEXT ) vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ); 1871 vkGetPhysicalDeviceDirectFBPresentationSupportEXT = cast( PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ); 1872 } 1873 1874 // VK_QNX_screen_surface : load instance level function definitions 1875 else static if( __traits( isSame, extension, QNX_screen_surface )) { 1876 vkCreateScreenSurfaceQNX = cast( PFN_vkCreateScreenSurfaceQNX ) vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ); 1877 vkGetPhysicalDeviceScreenPresentationSupportQNX = cast( PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ); 1878 } 1879 } 1880 } 1881 1882 // compose instance based loadDeviceLevelFunctionsExtI function out of unextended 1883 // loadDeviceLevelFunctions and additional function pointers from extensions 1884 // suffix I is required, as we cannot mixin mixin two overloads with the same symbol name (any more!) 1885 void loadDeviceLevelFunctionsExtI( VkInstance instance ) { 1886 1887 // first load all non platform related function pointers from implementation 1888 erupted.functions.loadDeviceLevelFunctions( instance ); 1889 1890 // 3. loop through alias sequence and mixin corresponding 1891 // instance based device level function pointer definitions 1892 static foreach( extension; noDuplicateExtensions ) { 1893 1894 // VK_KHR_video_queue : load instance based device level function definitions 1895 static if( __traits( isSame, extension, KHR_video_queue )) { 1896 vkCreateVideoSessionKHR = cast( PFN_vkCreateVideoSessionKHR ) vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ); 1897 vkDestroyVideoSessionKHR = cast( PFN_vkDestroyVideoSessionKHR ) vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ); 1898 vkGetVideoSessionMemoryRequirementsKHR = cast( PFN_vkGetVideoSessionMemoryRequirementsKHR ) vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ); 1899 vkBindVideoSessionMemoryKHR = cast( PFN_vkBindVideoSessionMemoryKHR ) vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ); 1900 vkCreateVideoSessionParametersKHR = cast( PFN_vkCreateVideoSessionParametersKHR ) vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ); 1901 vkUpdateVideoSessionParametersKHR = cast( PFN_vkUpdateVideoSessionParametersKHR ) vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ); 1902 vkDestroyVideoSessionParametersKHR = cast( PFN_vkDestroyVideoSessionParametersKHR ) vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ); 1903 vkCmdBeginVideoCodingKHR = cast( PFN_vkCmdBeginVideoCodingKHR ) vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ); 1904 vkCmdEndVideoCodingKHR = cast( PFN_vkCmdEndVideoCodingKHR ) vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ); 1905 vkCmdControlVideoCodingKHR = cast( PFN_vkCmdControlVideoCodingKHR ) vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ); 1906 } 1907 1908 // VK_KHR_video_decode_queue : load instance based device level function definitions 1909 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 1910 vkCmdDecodeVideoKHR = cast( PFN_vkCmdDecodeVideoKHR ) vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ); 1911 } 1912 1913 // VK_KHR_external_memory_win32 : load instance based device level function definitions 1914 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 1915 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ); 1916 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ); 1917 } 1918 1919 // VK_KHR_external_semaphore_win32 : load instance based device level function definitions 1920 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 1921 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ); 1922 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ); 1923 } 1924 1925 // VK_KHR_external_fence_win32 : load instance based device level function definitions 1926 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 1927 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ); 1928 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ); 1929 } 1930 1931 // VK_KHR_video_encode_queue : load instance based device level function definitions 1932 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 1933 vkCmdEncodeVideoKHR = cast( PFN_vkCmdEncodeVideoKHR ) vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ); 1934 } 1935 1936 // VK_NV_external_memory_win32 : load instance based device level function definitions 1937 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1938 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ); 1939 } 1940 1941 // VK_ANDROID_external_memory_android_hardware_buffer : load instance based device level function definitions 1942 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1943 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 1944 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ); 1945 } 1946 1947 // VK_EXT_full_screen_exclusive : load instance based device level function definitions 1948 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1949 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ); 1950 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ); 1951 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 1952 } 1953 1954 // VK_FUCHSIA_external_memory : load instance based device level function definitions 1955 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 1956 vkGetMemoryZirconHandleFUCHSIA = cast( PFN_vkGetMemoryZirconHandleFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ); 1957 vkGetMemoryZirconHandlePropertiesFUCHSIA = cast( PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ); 1958 } 1959 1960 // VK_FUCHSIA_external_semaphore : load instance based device level function definitions 1961 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 1962 vkImportSemaphoreZirconHandleFUCHSIA = cast( PFN_vkImportSemaphoreZirconHandleFUCHSIA ) vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ); 1963 vkGetSemaphoreZirconHandleFUCHSIA = cast( PFN_vkGetSemaphoreZirconHandleFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ); 1964 } 1965 1966 // VK_FUCHSIA_buffer_collection : load instance based device level function definitions 1967 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 1968 vkCreateBufferCollectionFUCHSIA = cast( PFN_vkCreateBufferCollectionFUCHSIA ) vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ); 1969 vkSetBufferCollectionImageConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionImageConstraintsFUCHSIA ) vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ); 1970 vkSetBufferCollectionBufferConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA ) vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ); 1971 vkDestroyBufferCollectionFUCHSIA = cast( PFN_vkDestroyBufferCollectionFUCHSIA ) vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ); 1972 vkGetBufferCollectionPropertiesFUCHSIA = cast( PFN_vkGetBufferCollectionPropertiesFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ); 1973 } 1974 } 1975 } 1976 1977 // compose device based loadDeviceLevelFunctionsExtD function out of unextended 1978 // loadDeviceLevelFunctions and additional function pointers from extensions 1979 // suffix D is required as, we cannot mixin mixin two overloads with the same symbol name (any more!) 1980 void loadDeviceLevelFunctionsExtD( VkDevice device ) { 1981 1982 // first load all non platform related function pointers from implementation 1983 erupted.functions.loadDeviceLevelFunctions( device ); 1984 1985 // 4. loop through alias sequence and mixin corresponding 1986 // device based device level function pointer definitions 1987 static foreach( extension; noDuplicateExtensions ) { 1988 1989 // VK_KHR_video_queue : load device based device level function definitions 1990 static if( __traits( isSame, extension, KHR_video_queue )) { 1991 vkCreateVideoSessionKHR = cast( PFN_vkCreateVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ); 1992 vkDestroyVideoSessionKHR = cast( PFN_vkDestroyVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ); 1993 vkGetVideoSessionMemoryRequirementsKHR = cast( PFN_vkGetVideoSessionMemoryRequirementsKHR ) vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ); 1994 vkBindVideoSessionMemoryKHR = cast( PFN_vkBindVideoSessionMemoryKHR ) vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ); 1995 vkCreateVideoSessionParametersKHR = cast( PFN_vkCreateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ); 1996 vkUpdateVideoSessionParametersKHR = cast( PFN_vkUpdateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ); 1997 vkDestroyVideoSessionParametersKHR = cast( PFN_vkDestroyVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ); 1998 vkCmdBeginVideoCodingKHR = cast( PFN_vkCmdBeginVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ); 1999 vkCmdEndVideoCodingKHR = cast( PFN_vkCmdEndVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ); 2000 vkCmdControlVideoCodingKHR = cast( PFN_vkCmdControlVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ); 2001 } 2002 2003 // VK_KHR_video_decode_queue : load device based device level function definitions 2004 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2005 vkCmdDecodeVideoKHR = cast( PFN_vkCmdDecodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ); 2006 } 2007 2008 // VK_KHR_external_memory_win32 : load device based device level function definitions 2009 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2010 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 2011 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 2012 } 2013 2014 // VK_KHR_external_semaphore_win32 : load device based device level function definitions 2015 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2016 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 2017 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 2018 } 2019 2020 // VK_KHR_external_fence_win32 : load device based device level function definitions 2021 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2022 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 2023 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 2024 } 2025 2026 // VK_KHR_video_encode_queue : load device based device level function definitions 2027 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2028 vkCmdEncodeVideoKHR = cast( PFN_vkCmdEncodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ); 2029 } 2030 2031 // VK_NV_external_memory_win32 : load device based device level function definitions 2032 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2033 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 2034 } 2035 2036 // VK_ANDROID_external_memory_android_hardware_buffer : load device based device level function definitions 2037 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2038 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 2039 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 2040 } 2041 2042 // VK_EXT_full_screen_exclusive : load device based device level function definitions 2043 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2044 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ); 2045 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ); 2046 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 2047 } 2048 2049 // VK_FUCHSIA_external_memory : load device based device level function definitions 2050 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2051 vkGetMemoryZirconHandleFUCHSIA = cast( PFN_vkGetMemoryZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ); 2052 vkGetMemoryZirconHandlePropertiesFUCHSIA = cast( PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ); 2053 } 2054 2055 // VK_FUCHSIA_external_semaphore : load device based device level function definitions 2056 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2057 vkImportSemaphoreZirconHandleFUCHSIA = cast( PFN_vkImportSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ); 2058 vkGetSemaphoreZirconHandleFUCHSIA = cast( PFN_vkGetSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ); 2059 } 2060 2061 // VK_FUCHSIA_buffer_collection : load device based device level function definitions 2062 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2063 vkCreateBufferCollectionFUCHSIA = cast( PFN_vkCreateBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ); 2064 vkSetBufferCollectionImageConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionImageConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ); 2065 vkSetBufferCollectionBufferConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ); 2066 vkDestroyBufferCollectionFUCHSIA = cast( PFN_vkDestroyBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ); 2067 vkGetBufferCollectionPropertiesFUCHSIA = cast( PFN_vkGetBufferCollectionPropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ); 2068 } 2069 } 2070 } 2071 2072 // compose extended dispatch device out of unextended original dispatch device with 2073 // extended, device based loadDeviceLevelFunctionsExt member function, 2074 // device and command buffer based function pointer decelerations 2075 struct DispatchDeviceExt { 2076 2077 // use unextended dispatch device from module erupted.functions as member and alias this 2078 erupted.dispatch_device.DispatchDevice commonDispatchDevice; 2079 alias commonDispatchDevice this; 2080 2081 // Constructor forwards parameter 'device' to 'loadDeviceLevelFunctionsExt' 2082 this( VkDevice device ) { 2083 loadDeviceLevelFunctionsExt( device ); 2084 } 2085 2086 // backwards compatibility alias 2087 alias loadDeviceLevelFunctions = loadDeviceLevelFunctionsExt; 2088 2089 // compose device based loadDeviceLevelFunctionsExt member function out of unextended 2090 // loadDeviceLevelFunctions and additional member function pointers from extensions 2091 void loadDeviceLevelFunctionsExt( VkDevice device ) { 2092 2093 // first load all non platform related member function pointers of wrapped commonDispatchDevice 2094 commonDispatchDevice.loadDeviceLevelFunctions( device ); 2095 2096 // 5. loop through alias sequence and mixin corresponding 2097 // device level member function pointer definitions of this wrapping DispatchDevice 2098 static foreach( extension; noDuplicateExtensions ) { 2099 2100 // VK_KHR_video_queue : load dispatch device member function definitions 2101 static if( __traits( isSame, extension, KHR_video_queue )) { 2102 vkCreateVideoSessionKHR = cast( PFN_vkCreateVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ); 2103 vkDestroyVideoSessionKHR = cast( PFN_vkDestroyVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ); 2104 vkGetVideoSessionMemoryRequirementsKHR = cast( PFN_vkGetVideoSessionMemoryRequirementsKHR ) vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ); 2105 vkBindVideoSessionMemoryKHR = cast( PFN_vkBindVideoSessionMemoryKHR ) vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ); 2106 vkCreateVideoSessionParametersKHR = cast( PFN_vkCreateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ); 2107 vkUpdateVideoSessionParametersKHR = cast( PFN_vkUpdateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ); 2108 vkDestroyVideoSessionParametersKHR = cast( PFN_vkDestroyVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ); 2109 vkCmdBeginVideoCodingKHR = cast( PFN_vkCmdBeginVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ); 2110 vkCmdEndVideoCodingKHR = cast( PFN_vkCmdEndVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ); 2111 vkCmdControlVideoCodingKHR = cast( PFN_vkCmdControlVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ); 2112 } 2113 2114 // VK_KHR_video_decode_queue : load dispatch device member function definitions 2115 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2116 vkCmdDecodeVideoKHR = cast( PFN_vkCmdDecodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ); 2117 } 2118 2119 // VK_KHR_external_memory_win32 : load dispatch device member function definitions 2120 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2121 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 2122 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 2123 } 2124 2125 // VK_KHR_external_semaphore_win32 : load dispatch device member function definitions 2126 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2127 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 2128 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 2129 } 2130 2131 // VK_KHR_external_fence_win32 : load dispatch device member function definitions 2132 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2133 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 2134 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 2135 } 2136 2137 // VK_KHR_video_encode_queue : load dispatch device member function definitions 2138 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2139 vkCmdEncodeVideoKHR = cast( PFN_vkCmdEncodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ); 2140 } 2141 2142 // VK_NV_external_memory_win32 : load dispatch device member function definitions 2143 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2144 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 2145 } 2146 2147 // VK_ANDROID_external_memory_android_hardware_buffer : load dispatch device member function definitions 2148 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2149 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 2150 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 2151 } 2152 2153 // VK_EXT_full_screen_exclusive : load dispatch device member function definitions 2154 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2155 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ); 2156 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ); 2157 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 2158 } 2159 2160 // VK_FUCHSIA_external_memory : load dispatch device member function definitions 2161 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2162 vkGetMemoryZirconHandleFUCHSIA = cast( PFN_vkGetMemoryZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ); 2163 vkGetMemoryZirconHandlePropertiesFUCHSIA = cast( PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ); 2164 } 2165 2166 // VK_FUCHSIA_external_semaphore : load dispatch device member function definitions 2167 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2168 vkImportSemaphoreZirconHandleFUCHSIA = cast( PFN_vkImportSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ); 2169 vkGetSemaphoreZirconHandleFUCHSIA = cast( PFN_vkGetSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ); 2170 } 2171 2172 // VK_FUCHSIA_buffer_collection : load dispatch device member function definitions 2173 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2174 vkCreateBufferCollectionFUCHSIA = cast( PFN_vkCreateBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ); 2175 vkSetBufferCollectionImageConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionImageConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ); 2176 vkSetBufferCollectionBufferConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ); 2177 vkDestroyBufferCollectionFUCHSIA = cast( PFN_vkDestroyBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ); 2178 vkGetBufferCollectionPropertiesFUCHSIA = cast( PFN_vkGetBufferCollectionPropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ); 2179 } 2180 } 2181 } 2182 2183 // 6. loop through alias sequence and mixin corresponding convenience member functions 2184 // omitting device parameter of this wrapping DispatchDevice. Member vkDevice of commonDispatchDevice is used instead 2185 static foreach( extension; noDuplicateExtensions ) { 2186 2187 // VK_KHR_video_queue : dispatch device convenience member functions 2188 static if( __traits( isSame, extension, KHR_video_queue )) { 2189 VkResult CreateVideoSessionKHR( const( VkVideoSessionCreateInfoKHR )* pCreateInfo, VkVideoSessionKHR* pVideoSession ) { return vkCreateVideoSessionKHR( vkDevice, pCreateInfo, pAllocator, pVideoSession ); } 2190 void DestroyVideoSessionKHR( VkVideoSessionKHR videoSession ) { vkDestroyVideoSessionKHR( vkDevice, videoSession, pAllocator ); } 2191 VkResult GetVideoSessionMemoryRequirementsKHR( VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements ) { return vkGetVideoSessionMemoryRequirementsKHR( vkDevice, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements ); } 2192 VkResult BindVideoSessionMemoryKHR( VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const( VkVideoBindMemoryKHR )* pVideoSessionBindMemories ) { return vkBindVideoSessionMemoryKHR( vkDevice, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories ); } 2193 VkResult CreateVideoSessionParametersKHR( const( VkVideoSessionParametersCreateInfoKHR )* pCreateInfo, VkVideoSessionParametersKHR* pVideoSessionParameters ) { return vkCreateVideoSessionParametersKHR( vkDevice, pCreateInfo, pAllocator, pVideoSessionParameters ); } 2194 VkResult UpdateVideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParameters, const( VkVideoSessionParametersUpdateInfoKHR )* pUpdateInfo ) { return vkUpdateVideoSessionParametersKHR( vkDevice, videoSessionParameters, pUpdateInfo ); } 2195 void DestroyVideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParameters ) { vkDestroyVideoSessionParametersKHR( vkDevice, videoSessionParameters, pAllocator ); } 2196 void CmdBeginVideoCodingKHR( const( VkVideoBeginCodingInfoKHR )* pBeginInfo ) { vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo ); } 2197 void CmdEndVideoCodingKHR( const( VkVideoEndCodingInfoKHR )* pEndCodingInfo ) { vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo ); } 2198 void CmdControlVideoCodingKHR( const( VkVideoCodingControlInfoKHR )* pCodingControlInfo ) { vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo ); } 2199 } 2200 2201 // VK_KHR_video_decode_queue : dispatch device convenience member functions 2202 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2203 void CmdDecodeVideoKHR( const( VkVideoDecodeInfoKHR )* pFrameInfo ) { vkCmdDecodeVideoKHR( commandBuffer, pFrameInfo ); } 2204 } 2205 2206 // VK_KHR_external_memory_win32 : dispatch device convenience member functions 2207 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2208 VkResult GetMemoryWin32HandleKHR( const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetMemoryWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 2209 VkResult GetMemoryWin32HandlePropertiesKHR( VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) { return vkGetMemoryWin32HandlePropertiesKHR( vkDevice, handleType, handle, pMemoryWin32HandleProperties ); } 2210 } 2211 2212 // VK_KHR_external_semaphore_win32 : dispatch device convenience member functions 2213 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2214 VkResult ImportSemaphoreWin32HandleKHR( const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ) { return vkImportSemaphoreWin32HandleKHR( vkDevice, pImportSemaphoreWin32HandleInfo ); } 2215 VkResult GetSemaphoreWin32HandleKHR( const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetSemaphoreWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 2216 } 2217 2218 // VK_KHR_external_fence_win32 : dispatch device convenience member functions 2219 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2220 VkResult ImportFenceWin32HandleKHR( const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ) { return vkImportFenceWin32HandleKHR( vkDevice, pImportFenceWin32HandleInfo ); } 2221 VkResult GetFenceWin32HandleKHR( const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetFenceWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 2222 } 2223 2224 // VK_KHR_video_encode_queue : dispatch device convenience member functions 2225 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2226 void CmdEncodeVideoKHR( const( VkVideoEncodeInfoKHR )* pEncodeInfo ) { vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo ); } 2227 } 2228 2229 // VK_NV_external_memory_win32 : dispatch device convenience member functions 2230 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2231 VkResult GetMemoryWin32HandleNV( VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) { return vkGetMemoryWin32HandleNV( vkDevice, memory, handleType, pHandle ); } 2232 } 2233 2234 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device convenience member functions 2235 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2236 VkResult GetAndroidHardwareBufferPropertiesANDROID( const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) { return vkGetAndroidHardwareBufferPropertiesANDROID( vkDevice, buffer, pProperties ); } 2237 VkResult GetMemoryAndroidHardwareBufferANDROID( const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ) { return vkGetMemoryAndroidHardwareBufferANDROID( vkDevice, pInfo, pBuffer ); } 2238 } 2239 2240 // VK_EXT_full_screen_exclusive : dispatch device convenience member functions 2241 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2242 VkResult AcquireFullScreenExclusiveModeEXT( VkSwapchainKHR swapchain ) { return vkAcquireFullScreenExclusiveModeEXT( vkDevice, swapchain ); } 2243 VkResult ReleaseFullScreenExclusiveModeEXT( VkSwapchainKHR swapchain ) { return vkReleaseFullScreenExclusiveModeEXT( vkDevice, swapchain ); } 2244 VkResult GetDeviceGroupSurfacePresentModes2EXT( const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ) { return vkGetDeviceGroupSurfacePresentModes2EXT( vkDevice, pSurfaceInfo, pModes ); } 2245 } 2246 2247 // VK_FUCHSIA_external_memory : dispatch device convenience member functions 2248 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2249 VkResult GetMemoryZirconHandleFUCHSIA( const( VkMemoryGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ) { return vkGetMemoryZirconHandleFUCHSIA( vkDevice, pGetZirconHandleInfo, pZirconHandle ); } 2250 VkResult GetMemoryZirconHandlePropertiesFUCHSIA( VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties ) { return vkGetMemoryZirconHandlePropertiesFUCHSIA( vkDevice, handleType, zirconHandle, pMemoryZirconHandleProperties ); } 2251 } 2252 2253 // VK_FUCHSIA_external_semaphore : dispatch device convenience member functions 2254 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2255 VkResult ImportSemaphoreZirconHandleFUCHSIA( const( VkImportSemaphoreZirconHandleInfoFUCHSIA )* pImportSemaphoreZirconHandleInfo ) { return vkImportSemaphoreZirconHandleFUCHSIA( vkDevice, pImportSemaphoreZirconHandleInfo ); } 2256 VkResult GetSemaphoreZirconHandleFUCHSIA( const( VkSemaphoreGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ) { return vkGetSemaphoreZirconHandleFUCHSIA( vkDevice, pGetZirconHandleInfo, pZirconHandle ); } 2257 } 2258 2259 // VK_FUCHSIA_buffer_collection : dispatch device convenience member functions 2260 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2261 VkResult CreateBufferCollectionFUCHSIA( const( VkBufferCollectionCreateInfoFUCHSIA )* pCreateInfo, VkBufferCollectionFUCHSIA* pCollection ) { return vkCreateBufferCollectionFUCHSIA( vkDevice, pCreateInfo, pAllocator, pCollection ); } 2262 VkResult SetBufferCollectionImageConstraintsFUCHSIA( VkBufferCollectionFUCHSIA collection, const( VkImageConstraintsInfoFUCHSIA )* pImageConstraintsInfo ) { return vkSetBufferCollectionImageConstraintsFUCHSIA( vkDevice, collection, pImageConstraintsInfo ); } 2263 VkResult SetBufferCollectionBufferConstraintsFUCHSIA( VkBufferCollectionFUCHSIA collection, const( VkBufferConstraintsInfoFUCHSIA )* pBufferConstraintsInfo ) { return vkSetBufferCollectionBufferConstraintsFUCHSIA( vkDevice, collection, pBufferConstraintsInfo ); } 2264 void DestroyBufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA collection ) { vkDestroyBufferCollectionFUCHSIA( vkDevice, collection, pAllocator ); } 2265 VkResult GetBufferCollectionPropertiesFUCHSIA( VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties ) { return vkGetBufferCollectionPropertiesFUCHSIA( vkDevice, collection, pProperties ); } 2266 } 2267 } 2268 2269 // 7. loop last time through alias sequence and mixin corresponding function pointer declarations 2270 static foreach( extension; noDuplicateExtensions ) { 2271 2272 // VK_KHR_xlib_surface : dispatch device member function pointer decelerations 2273 static if( __traits( isSame, extension, KHR_xlib_surface )) { 2274 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 2275 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 2276 } 2277 2278 // VK_KHR_xcb_surface : dispatch device member function pointer decelerations 2279 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 2280 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 2281 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 2282 } 2283 2284 // VK_KHR_wayland_surface : dispatch device member function pointer decelerations 2285 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 2286 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 2287 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 2288 } 2289 2290 // VK_KHR_android_surface : dispatch device member function pointer decelerations 2291 else static if( __traits( isSame, extension, KHR_android_surface )) { 2292 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 2293 } 2294 2295 // VK_KHR_win32_surface : dispatch device member function pointer decelerations 2296 else static if( __traits( isSame, extension, KHR_win32_surface )) { 2297 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 2298 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 2299 } 2300 2301 // VK_KHR_video_queue : dispatch device member function pointer decelerations 2302 else static if( __traits( isSame, extension, KHR_video_queue )) { 2303 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; 2304 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; 2305 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; 2306 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; 2307 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; 2308 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; 2309 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; 2310 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; 2311 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; 2312 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; 2313 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; 2314 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; 2315 } 2316 2317 // VK_KHR_video_decode_queue : dispatch device member function pointer decelerations 2318 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2319 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; 2320 } 2321 2322 // VK_KHR_external_memory_win32 : dispatch device member function pointer decelerations 2323 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2324 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 2325 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 2326 } 2327 2328 // VK_KHR_external_semaphore_win32 : dispatch device member function pointer decelerations 2329 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2330 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 2331 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 2332 } 2333 2334 // VK_KHR_external_fence_win32 : dispatch device member function pointer decelerations 2335 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2336 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 2337 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 2338 } 2339 2340 // VK_KHR_video_encode_queue : dispatch device member function pointer decelerations 2341 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2342 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR; 2343 } 2344 2345 // VK_GGP_stream_descriptor_surface : dispatch device member function pointer decelerations 2346 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 2347 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; 2348 } 2349 2350 // VK_NV_external_memory_win32 : dispatch device member function pointer decelerations 2351 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2352 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 2353 } 2354 2355 // VK_NN_vi_surface : dispatch device member function pointer decelerations 2356 else static if( __traits( isSame, extension, NN_vi_surface )) { 2357 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 2358 } 2359 2360 // VK_EXT_acquire_xlib_display : dispatch device member function pointer decelerations 2361 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 2362 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 2363 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 2364 } 2365 2366 // VK_MVK_ios_surface : dispatch device member function pointer decelerations 2367 else static if( __traits( isSame, extension, MVK_ios_surface )) { 2368 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 2369 } 2370 2371 // VK_MVK_macos_surface : dispatch device member function pointer decelerations 2372 else static if( __traits( isSame, extension, MVK_macos_surface )) { 2373 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 2374 } 2375 2376 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device member function pointer decelerations 2377 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2378 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 2379 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 2380 } 2381 2382 // VK_FUCHSIA_imagepipe_surface : dispatch device member function pointer decelerations 2383 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 2384 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; 2385 } 2386 2387 // VK_EXT_metal_surface : dispatch device member function pointer decelerations 2388 else static if( __traits( isSame, extension, EXT_metal_surface )) { 2389 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; 2390 } 2391 2392 // VK_EXT_full_screen_exclusive : dispatch device member function pointer decelerations 2393 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2394 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; 2395 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; 2396 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; 2397 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; 2398 } 2399 2400 // VK_NV_acquire_winrt_display : dispatch device member function pointer decelerations 2401 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 2402 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; 2403 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; 2404 } 2405 2406 // VK_EXT_directfb_surface : dispatch device member function pointer decelerations 2407 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 2408 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; 2409 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; 2410 } 2411 2412 // VK_FUCHSIA_external_memory : dispatch device member function pointer decelerations 2413 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2414 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA; 2415 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA; 2416 } 2417 2418 // VK_FUCHSIA_external_semaphore : dispatch device member function pointer decelerations 2419 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2420 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA; 2421 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA; 2422 } 2423 2424 // VK_FUCHSIA_buffer_collection : dispatch device member function pointer decelerations 2425 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2426 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA; 2427 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA; 2428 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA; 2429 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA; 2430 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA; 2431 } 2432 2433 // VK_QNX_screen_surface : dispatch device member function pointer decelerations 2434 else static if( __traits( isSame, extension, QNX_screen_surface )) { 2435 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; 2436 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX; 2437 } 2438 } 2439 } 2440 }