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