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