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 = 5; 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 capabilityFlags; 341 VkDeviceSize minBitstreamBufferOffsetAlignment; 342 VkDeviceSize minBitstreamBufferSizeAlignment; 343 VkExtent2D videoPictureExtentGranularity; 344 VkExtent2D minExtent; 345 VkExtent2D maxExtent; 346 uint32_t maxReferencePicturesSlotsCount; 347 uint32_t maxReferencePicturesActiveCount; 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 int8_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 referencePicturesFormat; 409 uint32_t maxReferencePicturesSlotsCount; 410 uint32_t maxReferencePicturesActiveCount; 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 )* pFrameInfo ); 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 = 8; 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 spsStdCount; 973 const( StdVideoH264SequenceParameterSet )* pSpsStd; 974 uint32_t ppsStdCount; 975 const( StdVideoH264PictureParameterSet )* pPpsStd; 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 maxSpsStdCount; 982 uint32_t maxPpsStdCount; 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 = 8; 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 vpsStdCount; 1240 const( StdVideoH265VideoParameterSet )* pVpsStd; 1241 uint32_t spsStdCount; 1242 const( StdVideoH265SequenceParameterSet )* pSpsStd; 1243 uint32_t ppsStdCount; 1244 const( StdVideoH265PictureParameterSet )* pPpsStd; 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 maxVpsStdCount; 1251 uint32_t maxSpsStdCount; 1252 uint32_t maxPpsStdCount; 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 = 6; 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 VkVideoDecodeH264PictureLayoutFlagsEXT pictureLayout; 1370 } 1371 1372 struct VkVideoDecodeH264CapabilitiesEXT { 1373 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT; 1374 void* pNext; 1375 StdVideoH264Level maxLevel; 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 spsStdCount; 1383 const( StdVideoH264SequenceParameterSet )* pSpsStd; 1384 uint32_t ppsStdCount; 1385 const( StdVideoH264PictureParameterSet )* pPpsStd; 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 maxSpsStdCount; 1392 uint32_t maxPpsStdCount; 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 slicesCount; 1401 const( uint32_t )* pSlicesDataOffsets; 1402 } 1403 1404 struct VkVideoDecodeH264MvcInfoEXT { 1405 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_INFO_EXT; 1406 const( void )* pNext; 1407 const( StdVideoDecodeH264Mvc )* pStdMvc; 1408 } 1409 1410 struct VkVideoDecodeH264DpbSlotInfoEXT { 1411 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT; 1412 const( void )* pNext; 1413 const( StdVideoDecodeH264ReferenceInfo )* pStdReferenceInfo; 1414 } 1415 1416 } 1417 1418 // VK_GGP_stream_descriptor_surface : types and function pointer type aliases 1419 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 1420 enum VK_GGP_stream_descriptor_surface = 1; 1421 1422 enum VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION = 1; 1423 enum const( char )* VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME = "VK_GGP_stream_descriptor_surface"; 1424 1425 alias VkStreamDescriptorSurfaceCreateFlagsGGP = VkFlags; 1426 1427 struct VkStreamDescriptorSurfaceCreateInfoGGP { 1428 VkStructureType sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; 1429 const( void )* pNext; 1430 VkStreamDescriptorSurfaceCreateFlagsGGP flags; 1431 GgpStreamDescriptor streamDescriptor; 1432 } 1433 1434 alias PFN_vkCreateStreamDescriptorSurfaceGGP = VkResult function( VkInstance instance, const( VkStreamDescriptorSurfaceCreateInfoGGP )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1435 } 1436 1437 // VK_NV_external_memory_win32 : types and function pointer type aliases 1438 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 1439 enum VK_NV_external_memory_win32 = 1; 1440 1441 enum VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 1442 enum const( char )* VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; 1443 1444 struct VkImportMemoryWin32HandleInfoNV { 1445 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 1446 const( void )* pNext; 1447 VkExternalMemoryHandleTypeFlagsNV handleType; 1448 HANDLE handle; 1449 } 1450 1451 struct VkExportMemoryWin32HandleInfoNV { 1452 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 1453 const( void )* pNext; 1454 const( SECURITY_ATTRIBUTES )* pAttributes; 1455 DWORD dwAccess; 1456 } 1457 1458 alias PFN_vkGetMemoryWin32HandleNV = VkResult function( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ); 1459 } 1460 1461 // VK_NV_win32_keyed_mutex : types and function pointer type aliases 1462 else static if( __traits( isSame, extension, NV_win32_keyed_mutex )) { 1463 enum VK_NV_win32_keyed_mutex = 1; 1464 1465 enum VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 2; 1466 enum const( char )* VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; 1467 1468 struct VkWin32KeyedMutexAcquireReleaseInfoNV { 1469 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 1470 const( void )* pNext; 1471 uint32_t acquireCount; 1472 const( VkDeviceMemory )* pAcquireSyncs; 1473 const( uint64_t )* pAcquireKeys; 1474 const( uint32_t )* pAcquireTimeoutMilliseconds; 1475 uint32_t releaseCount; 1476 const( VkDeviceMemory )* pReleaseSyncs; 1477 const( uint64_t )* pReleaseKeys; 1478 } 1479 1480 } 1481 1482 // VK_NN_vi_surface : types and function pointer type aliases 1483 else static if( __traits( isSame, extension, NN_vi_surface )) { 1484 enum VK_NN_vi_surface = 1; 1485 1486 enum VK_NN_VI_SURFACE_SPEC_VERSION = 1; 1487 enum const( char )* VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface"; 1488 1489 alias VkViSurfaceCreateFlagsNN = VkFlags; 1490 1491 struct VkViSurfaceCreateInfoNN { 1492 VkStructureType sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; 1493 const( void )* pNext; 1494 VkViSurfaceCreateFlagsNN flags; 1495 void* window; 1496 } 1497 1498 alias PFN_vkCreateViSurfaceNN = VkResult function( VkInstance instance, const( VkViSurfaceCreateInfoNN )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1499 } 1500 1501 // VK_EXT_acquire_xlib_display : types and function pointer type aliases 1502 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 1503 enum VK_EXT_acquire_xlib_display = 1; 1504 1505 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1; 1506 enum const( char )* VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_xlib_display"; 1507 1508 alias PFN_vkAcquireXlibDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ); 1509 alias PFN_vkGetRandROutputDisplayEXT = VkResult function( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ); 1510 } 1511 1512 // VK_MVK_ios_surface : types and function pointer type aliases 1513 else static if( __traits( isSame, extension, MVK_ios_surface )) { 1514 enum VK_MVK_ios_surface = 1; 1515 1516 enum VK_MVK_IOS_SURFACE_SPEC_VERSION = 3; 1517 enum const( char )* VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface"; 1518 1519 alias VkIOSSurfaceCreateFlagsMVK = VkFlags; 1520 1521 struct VkIOSSurfaceCreateInfoMVK { 1522 VkStructureType sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; 1523 const( void )* pNext; 1524 VkIOSSurfaceCreateFlagsMVK flags; 1525 const( void )* pView; 1526 } 1527 1528 alias PFN_vkCreateIOSSurfaceMVK = VkResult function( VkInstance instance, const( VkIOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1529 } 1530 1531 // VK_MVK_macos_surface : types and function pointer type aliases 1532 else static if( __traits( isSame, extension, MVK_macos_surface )) { 1533 enum VK_MVK_macos_surface = 1; 1534 1535 enum VK_MVK_MACOS_SURFACE_SPEC_VERSION = 3; 1536 enum const( char )* VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface"; 1537 1538 alias VkMacOSSurfaceCreateFlagsMVK = VkFlags; 1539 1540 struct VkMacOSSurfaceCreateInfoMVK { 1541 VkStructureType sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; 1542 const( void )* pNext; 1543 VkMacOSSurfaceCreateFlagsMVK flags; 1544 const( void )* pView; 1545 } 1546 1547 alias PFN_vkCreateMacOSSurfaceMVK = VkResult function( VkInstance instance, const( VkMacOSSurfaceCreateInfoMVK )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1548 } 1549 1550 // VK_ANDROID_external_memory_android_hardware_buffer : types and function pointer type aliases 1551 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 1552 enum VK_ANDROID_external_memory_android_hardware_buffer = 1; 1553 1554 enum VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION = 5; 1555 enum const( char )* VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME = "VK_ANDROID_external_memory_android_hardware_buffer"; 1556 1557 struct VkAndroidHardwareBufferUsageANDROID { 1558 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; 1559 void* pNext; 1560 uint64_t androidHardwareBufferUsage; 1561 } 1562 1563 struct VkAndroidHardwareBufferPropertiesANDROID { 1564 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; 1565 void* pNext; 1566 VkDeviceSize allocationSize; 1567 uint32_t memoryTypeBits; 1568 } 1569 1570 struct VkAndroidHardwareBufferFormatPropertiesANDROID { 1571 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; 1572 void* pNext; 1573 VkFormat format; 1574 uint64_t externalFormat; 1575 VkFormatFeatureFlags formatFeatures; 1576 VkComponentMapping samplerYcbcrConversionComponents; 1577 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 1578 VkSamplerYcbcrRange suggestedYcbcrRange; 1579 VkChromaLocation suggestedXChromaOffset; 1580 VkChromaLocation suggestedYChromaOffset; 1581 } 1582 1583 struct VkImportAndroidHardwareBufferInfoANDROID { 1584 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 1585 const( void )* pNext; 1586 const( AHardwareBuffer )* buffer; 1587 } 1588 1589 struct VkMemoryGetAndroidHardwareBufferInfoANDROID { 1590 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; 1591 const( void )* pNext; 1592 VkDeviceMemory memory; 1593 } 1594 1595 struct VkExternalFormatANDROID { 1596 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; 1597 void* pNext; 1598 uint64_t externalFormat; 1599 } 1600 1601 struct VkAndroidHardwareBufferFormatProperties2ANDROID { 1602 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; 1603 void* pNext; 1604 VkFormat format; 1605 uint64_t externalFormat; 1606 VkFormatFeatureFlags2 formatFeatures; 1607 VkComponentMapping samplerYcbcrConversionComponents; 1608 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 1609 VkSamplerYcbcrRange suggestedYcbcrRange; 1610 VkChromaLocation suggestedXChromaOffset; 1611 VkChromaLocation suggestedYChromaOffset; 1612 } 1613 1614 alias PFN_vkGetAndroidHardwareBufferPropertiesANDROID = VkResult function( VkDevice device, const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ); 1615 alias PFN_vkGetMemoryAndroidHardwareBufferANDROID = VkResult function( VkDevice device, const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ); 1616 } 1617 1618 // VK_EXT_video_decode_h265 : types and function pointer type aliases 1619 else static if( __traits( isSame, extension, EXT_video_decode_h265 )) { 1620 enum VK_EXT_video_decode_h265 = 1; 1621 1622 enum VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION = 4; 1623 enum const( char )* VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME = "VK_EXT_video_decode_h265"; 1624 1625 struct VkVideoDecodeH265ProfileInfoEXT { 1626 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_EXT; 1627 const( void )* pNext; 1628 StdVideoH265ProfileIdc stdProfileIdc; 1629 } 1630 1631 struct VkVideoDecodeH265CapabilitiesEXT { 1632 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT; 1633 void* pNext; 1634 StdVideoH265Level maxLevel; 1635 } 1636 1637 struct VkVideoDecodeH265SessionParametersAddInfoEXT { 1638 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT; 1639 const( void )* pNext; 1640 uint32_t vpsStdCount; 1641 const( StdVideoH265VideoParameterSet )* pVpsStd; 1642 uint32_t spsStdCount; 1643 const( StdVideoH265SequenceParameterSet )* pSpsStd; 1644 uint32_t ppsStdCount; 1645 const( StdVideoH265PictureParameterSet )* pPpsStd; 1646 } 1647 1648 struct VkVideoDecodeH265SessionParametersCreateInfoEXT { 1649 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT; 1650 const( void )* pNext; 1651 uint32_t maxVpsStdCount; 1652 uint32_t maxSpsStdCount; 1653 uint32_t maxPpsStdCount; 1654 const( VkVideoDecodeH265SessionParametersAddInfoEXT )* pParametersAddInfo; 1655 } 1656 1657 struct VkVideoDecodeH265PictureInfoEXT { 1658 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT; 1659 const( void )* pNext; 1660 StdVideoDecodeH265PictureInfo* pStdPictureInfo; 1661 uint32_t slicesCount; 1662 const( uint32_t )* pSlicesDataOffsets; 1663 } 1664 1665 struct VkVideoDecodeH265DpbSlotInfoEXT { 1666 VkStructureType sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT; 1667 const( void )* pNext; 1668 const( StdVideoDecodeH265ReferenceInfo )* pStdReferenceInfo; 1669 } 1670 1671 } 1672 1673 // VK_GGP_frame_token : types and function pointer type aliases 1674 else static if( __traits( isSame, extension, GGP_frame_token )) { 1675 enum VK_GGP_frame_token = 1; 1676 1677 enum VK_GGP_FRAME_TOKEN_SPEC_VERSION = 1; 1678 enum const( char )* VK_GGP_FRAME_TOKEN_EXTENSION_NAME = "VK_GGP_frame_token"; 1679 1680 struct VkPresentFrameTokenGGP { 1681 VkStructureType sType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; 1682 const( void )* pNext; 1683 GgpFrameToken frameToken; 1684 } 1685 1686 } 1687 1688 // VK_FUCHSIA_imagepipe_surface : types and function pointer type aliases 1689 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 1690 enum VK_FUCHSIA_imagepipe_surface = 1; 1691 1692 enum VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION = 1; 1693 enum const( char )* VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME = "VK_FUCHSIA_imagepipe_surface"; 1694 1695 alias VkImagePipeSurfaceCreateFlagsFUCHSIA = VkFlags; 1696 1697 struct VkImagePipeSurfaceCreateInfoFUCHSIA { 1698 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; 1699 const( void )* pNext; 1700 VkImagePipeSurfaceCreateFlagsFUCHSIA flags; 1701 zx_handle_t imagePipeHandle; 1702 } 1703 1704 alias PFN_vkCreateImagePipeSurfaceFUCHSIA = VkResult function( VkInstance instance, const( VkImagePipeSurfaceCreateInfoFUCHSIA )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1705 } 1706 1707 // VK_EXT_metal_surface : types and function pointer type aliases 1708 else static if( __traits( isSame, extension, EXT_metal_surface )) { 1709 enum VK_EXT_metal_surface = 1; 1710 1711 enum VK_EXT_METAL_SURFACE_SPEC_VERSION = 1; 1712 enum const( char )* VK_EXT_METAL_SURFACE_EXTENSION_NAME = "VK_EXT_metal_surface"; 1713 1714 alias VkMetalSurfaceCreateFlagsEXT = VkFlags; 1715 1716 struct VkMetalSurfaceCreateInfoEXT { 1717 VkStructureType sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; 1718 const( void )* pNext; 1719 VkMetalSurfaceCreateFlagsEXT flags; 1720 const( CAMetalLayer )* pLayer; 1721 } 1722 1723 alias PFN_vkCreateMetalSurfaceEXT = VkResult function( VkInstance instance, const( VkMetalSurfaceCreateInfoEXT )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1724 } 1725 1726 // VK_EXT_full_screen_exclusive : types and function pointer type aliases 1727 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 1728 enum VK_EXT_full_screen_exclusive = 1; 1729 1730 enum VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION = 4; 1731 enum const( char )* VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME = "VK_EXT_full_screen_exclusive"; 1732 1733 enum VkFullScreenExclusiveEXT { 1734 VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, 1735 VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, 1736 VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, 1737 VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, 1738 VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, 1739 VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, 1740 VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1, 1741 VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF 1742 } 1743 1744 enum VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT; 1745 enum VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT; 1746 enum VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT; 1747 enum VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT; 1748 enum VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT; 1749 enum VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT; 1750 enum VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT; 1751 enum VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = VkFullScreenExclusiveEXT.VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT; 1752 1753 struct VkSurfaceFullScreenExclusiveInfoEXT { 1754 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; 1755 void* pNext; 1756 VkFullScreenExclusiveEXT fullScreenExclusive; 1757 } 1758 1759 struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { 1760 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; 1761 void* pNext; 1762 VkBool32 fullScreenExclusiveSupported; 1763 } 1764 1765 struct VkSurfaceFullScreenExclusiveWin32InfoEXT { 1766 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; 1767 const( void )* pNext; 1768 HMONITOR hmonitor; 1769 } 1770 1771 alias PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = VkResult function( VkPhysicalDevice physicalDevice, const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ); 1772 alias PFN_vkAcquireFullScreenExclusiveModeEXT = VkResult function( VkDevice device, VkSwapchainKHR swapchain ); 1773 alias PFN_vkReleaseFullScreenExclusiveModeEXT = VkResult function( VkDevice device, VkSwapchainKHR swapchain ); 1774 alias PFN_vkGetDeviceGroupSurfacePresentModes2EXT = VkResult function( VkDevice device, const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ); 1775 } 1776 1777 // VK_EXT_metal_objects : types and function pointer type aliases 1778 else static if( __traits( isSame, extension, EXT_metal_objects )) { 1779 enum VK_EXT_metal_objects = 1; 1780 1781 enum VK_EXT_METAL_OBJECTS_SPEC_VERSION = 1; 1782 enum const( char )* VK_EXT_METAL_OBJECTS_EXTENSION_NAME = "VK_EXT_metal_objects"; 1783 1784 alias VkExportMetalObjectTypeFlagsEXT = VkFlags; 1785 enum VkExportMetalObjectTypeFlagBitsEXT : VkExportMetalObjectTypeFlagsEXT { 1786 VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001, 1787 VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002, 1788 VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004, 1789 VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008, 1790 VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010, 1791 VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020, 1792 VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 1793 } 1794 1795 enum VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT; 1796 enum VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT; 1797 enum VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT; 1798 enum VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT; 1799 enum VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT; 1800 enum VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT; 1801 enum VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = VkExportMetalObjectTypeFlagBitsEXT.VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT; 1802 1803 struct VkExportMetalObjectCreateInfoEXT { 1804 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; 1805 const( void )* pNext; 1806 VkExportMetalObjectTypeFlagBitsEXT exportObjectType; 1807 } 1808 1809 struct VkExportMetalObjectsInfoEXT { 1810 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT; 1811 const( void )* pNext; 1812 } 1813 1814 struct VkExportMetalDeviceInfoEXT { 1815 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT; 1816 const( void )* pNext; 1817 MTLDevice_id mtlDevice; 1818 } 1819 1820 struct VkExportMetalCommandQueueInfoEXT { 1821 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; 1822 const( void )* pNext; 1823 VkQueue queue; 1824 MTLCommandQueue_id mtlCommandQueue; 1825 } 1826 1827 struct VkExportMetalBufferInfoEXT { 1828 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT; 1829 const( void )* pNext; 1830 VkDeviceMemory memory; 1831 MTLBuffer_id mtlBuffer; 1832 } 1833 1834 struct VkImportMetalBufferInfoEXT { 1835 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT; 1836 const( void )* pNext; 1837 MTLBuffer_id mtlBuffer; 1838 } 1839 1840 struct VkExportMetalTextureInfoEXT { 1841 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT; 1842 const( void )* pNext; 1843 VkImage image; 1844 VkImageView imageView; 1845 VkBufferView bufferView; 1846 VkImageAspectFlagBits plane; 1847 MTLTexture_id mtlTexture; 1848 } 1849 1850 struct VkImportMetalTextureInfoEXT { 1851 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT; 1852 const( void )* pNext; 1853 VkImageAspectFlagBits plane; 1854 MTLTexture_id mtlTexture; 1855 } 1856 1857 struct VkExportMetalIOSurfaceInfoEXT { 1858 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT; 1859 const( void )* pNext; 1860 VkImage image; 1861 IOSurfaceRef ioSurface; 1862 } 1863 1864 struct VkImportMetalIOSurfaceInfoEXT { 1865 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT; 1866 const( void )* pNext; 1867 IOSurfaceRef ioSurface; 1868 } 1869 1870 struct VkExportMetalSharedEventInfoEXT { 1871 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT; 1872 const( void )* pNext; 1873 VkSemaphore semaphore; 1874 VkEvent event; 1875 MTLSharedEvent_id mtlSharedEvent; 1876 } 1877 1878 struct VkImportMetalSharedEventInfoEXT { 1879 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT; 1880 const( void )* pNext; 1881 MTLSharedEvent_id mtlSharedEvent; 1882 } 1883 1884 alias PFN_vkExportMetalObjectsEXT = void function( VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo ); 1885 } 1886 1887 // VK_NV_acquire_winrt_display : types and function pointer type aliases 1888 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 1889 enum VK_NV_acquire_winrt_display = 1; 1890 1891 enum VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION = 1; 1892 enum const( char )* VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME = "VK_NV_acquire_winrt_display"; 1893 1894 alias PFN_vkAcquireWinrtDisplayNV = VkResult function( VkPhysicalDevice physicalDevice, VkDisplayKHR display ); 1895 alias PFN_vkGetWinrtDisplayNV = VkResult function( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay ); 1896 } 1897 1898 // VK_EXT_directfb_surface : types and function pointer type aliases 1899 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 1900 enum VK_EXT_directfb_surface = 1; 1901 1902 enum VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION = 1; 1903 enum const( char )* VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME = "VK_EXT_directfb_surface"; 1904 1905 alias VkDirectFBSurfaceCreateFlagsEXT = VkFlags; 1906 1907 struct VkDirectFBSurfaceCreateInfoEXT { 1908 VkStructureType sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; 1909 const( void )* pNext; 1910 VkDirectFBSurfaceCreateFlagsEXT flags; 1911 IDirectFB* dfb; 1912 IDirectFBSurface* surface; 1913 } 1914 1915 alias PFN_vkCreateDirectFBSurfaceEXT = VkResult function( VkInstance instance, const( VkDirectFBSurfaceCreateInfoEXT )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 1916 alias PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb ); 1917 } 1918 1919 // VK_FUCHSIA_external_memory : types and function pointer type aliases 1920 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 1921 enum VK_FUCHSIA_external_memory = 1; 1922 1923 enum VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION = 1; 1924 enum const( char )* VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_FUCHSIA_external_memory"; 1925 1926 struct VkImportMemoryZirconHandleInfoFUCHSIA { 1927 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; 1928 const( void )* pNext; 1929 VkExternalMemoryHandleTypeFlagBits handleType; 1930 zx_handle_t handle; 1931 } 1932 1933 struct VkMemoryZirconHandlePropertiesFUCHSIA { 1934 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; 1935 void* pNext; 1936 uint32_t memoryTypeBits; 1937 } 1938 1939 struct VkMemoryGetZirconHandleInfoFUCHSIA { 1940 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; 1941 const( void )* pNext; 1942 VkDeviceMemory memory; 1943 VkExternalMemoryHandleTypeFlagBits handleType; 1944 } 1945 1946 alias PFN_vkGetMemoryZirconHandleFUCHSIA = VkResult function( VkDevice device, const( VkMemoryGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ); 1947 alias PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = VkResult function( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties ); 1948 } 1949 1950 // VK_FUCHSIA_external_semaphore : types and function pointer type aliases 1951 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 1952 enum VK_FUCHSIA_external_semaphore = 1; 1953 1954 enum VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1; 1955 enum const( char )* VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME = "VK_FUCHSIA_external_semaphore"; 1956 1957 struct VkImportSemaphoreZirconHandleInfoFUCHSIA { 1958 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; 1959 const( void )* pNext; 1960 VkSemaphore semaphore; 1961 VkSemaphoreImportFlags flags; 1962 VkExternalSemaphoreHandleTypeFlagBits handleType; 1963 zx_handle_t zirconHandle; 1964 } 1965 1966 struct VkSemaphoreGetZirconHandleInfoFUCHSIA { 1967 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; 1968 const( void )* pNext; 1969 VkSemaphore semaphore; 1970 VkExternalSemaphoreHandleTypeFlagBits handleType; 1971 } 1972 1973 alias PFN_vkImportSemaphoreZirconHandleFUCHSIA = VkResult function( VkDevice device, const( VkImportSemaphoreZirconHandleInfoFUCHSIA )* pImportSemaphoreZirconHandleInfo ); 1974 alias PFN_vkGetSemaphoreZirconHandleFUCHSIA = VkResult function( VkDevice device, const( VkSemaphoreGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ); 1975 } 1976 1977 // VK_FUCHSIA_buffer_collection : types and function pointer type aliases 1978 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 1979 enum VK_FUCHSIA_buffer_collection = 1; 1980 1981 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBufferCollectionFUCHSIA} ); 1982 1983 enum VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION = 2; 1984 enum const( char )* VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME = "VK_FUCHSIA_buffer_collection"; 1985 1986 alias VkImageFormatConstraintsFlagsFUCHSIA = VkFlags; 1987 1988 alias VkImageConstraintsInfoFlagsFUCHSIA = VkFlags; 1989 enum VkImageConstraintsInfoFlagBitsFUCHSIA : VkImageConstraintsInfoFlagsFUCHSIA { 1990 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001, 1991 VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002, 1992 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004, 1993 VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008, 1994 VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010, 1995 VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF 1996 } 1997 1998 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA; 1999 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA; 2000 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA; 2001 enum VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA; 2002 enum VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA; 2003 enum VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = VkImageConstraintsInfoFlagBitsFUCHSIA.VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA; 2004 2005 struct VkBufferCollectionCreateInfoFUCHSIA { 2006 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; 2007 const( void )* pNext; 2008 zx_handle_t collectionToken; 2009 } 2010 2011 struct VkImportMemoryBufferCollectionFUCHSIA { 2012 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; 2013 const( void )* pNext; 2014 VkBufferCollectionFUCHSIA collection; 2015 uint32_t index; 2016 } 2017 2018 struct VkBufferCollectionImageCreateInfoFUCHSIA { 2019 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; 2020 const( void )* pNext; 2021 VkBufferCollectionFUCHSIA collection; 2022 uint32_t index; 2023 } 2024 2025 struct VkBufferCollectionConstraintsInfoFUCHSIA { 2026 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; 2027 const( void )* pNext; 2028 uint32_t minBufferCount; 2029 uint32_t maxBufferCount; 2030 uint32_t minBufferCountForCamping; 2031 uint32_t minBufferCountForDedicatedSlack; 2032 uint32_t minBufferCountForSharedSlack; 2033 } 2034 2035 struct VkBufferConstraintsInfoFUCHSIA { 2036 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA; 2037 const( void )* pNext; 2038 VkBufferCreateInfo createInfo; 2039 VkFormatFeatureFlags requiredFormatFeatures; 2040 VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; 2041 } 2042 2043 struct VkBufferCollectionBufferCreateInfoFUCHSIA { 2044 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; 2045 const( void )* pNext; 2046 VkBufferCollectionFUCHSIA collection; 2047 uint32_t index; 2048 } 2049 2050 struct VkSysmemColorSpaceFUCHSIA { 2051 VkStructureType sType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA; 2052 const( void )* pNext; 2053 uint32_t colorSpace; 2054 } 2055 2056 struct VkBufferCollectionPropertiesFUCHSIA { 2057 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA; 2058 void* pNext; 2059 uint32_t memoryTypeBits; 2060 uint32_t bufferCount; 2061 uint32_t createInfoIndex; 2062 uint64_t sysmemPixelFormat; 2063 VkFormatFeatureFlags formatFeatures; 2064 VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex; 2065 VkComponentMapping samplerYcbcrConversionComponents; 2066 VkSamplerYcbcrModelConversion suggestedYcbcrModel; 2067 VkSamplerYcbcrRange suggestedYcbcrRange; 2068 VkChromaLocation suggestedXChromaOffset; 2069 VkChromaLocation suggestedYChromaOffset; 2070 } 2071 2072 struct VkImageFormatConstraintsInfoFUCHSIA { 2073 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; 2074 const( void )* pNext; 2075 VkImageCreateInfo imageCreateInfo; 2076 VkFormatFeatureFlags requiredFormatFeatures; 2077 VkImageFormatConstraintsFlagsFUCHSIA flags; 2078 uint64_t sysmemPixelFormat; 2079 uint32_t colorSpaceCount; 2080 const( VkSysmemColorSpaceFUCHSIA )* pColorSpaces; 2081 } 2082 2083 struct VkImageConstraintsInfoFUCHSIA { 2084 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA; 2085 const( void )* pNext; 2086 uint32_t formatConstraintsCount; 2087 const( VkImageFormatConstraintsInfoFUCHSIA )* pFormatConstraints; 2088 VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; 2089 VkImageConstraintsInfoFlagsFUCHSIA flags; 2090 } 2091 2092 alias PFN_vkCreateBufferCollectionFUCHSIA = VkResult function( VkDevice device, const( VkBufferCollectionCreateInfoFUCHSIA )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkBufferCollectionFUCHSIA* pCollection ); 2093 alias PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = VkResult function( VkDevice device, VkBufferCollectionFUCHSIA collection, const( VkImageConstraintsInfoFUCHSIA )* pImageConstraintsInfo ); 2094 alias PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = VkResult function( VkDevice device, VkBufferCollectionFUCHSIA collection, const( VkBufferConstraintsInfoFUCHSIA )* pBufferConstraintsInfo ); 2095 alias PFN_vkDestroyBufferCollectionFUCHSIA = void function( VkDevice device, VkBufferCollectionFUCHSIA collection, const( VkAllocationCallbacks )* pAllocator ); 2096 alias PFN_vkGetBufferCollectionPropertiesFUCHSIA = VkResult function( VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties ); 2097 } 2098 2099 // VK_QNX_screen_surface : types and function pointer type aliases 2100 else static if( __traits( isSame, extension, QNX_screen_surface )) { 2101 enum VK_QNX_screen_surface = 1; 2102 2103 enum VK_QNX_SCREEN_SURFACE_SPEC_VERSION = 1; 2104 enum const( char )* VK_QNX_SCREEN_SURFACE_EXTENSION_NAME = "VK_QNX_screen_surface"; 2105 2106 alias VkScreenSurfaceCreateFlagsQNX = VkFlags; 2107 2108 struct VkScreenSurfaceCreateInfoQNX { 2109 VkStructureType sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX; 2110 const( void )* pNext; 2111 VkScreenSurfaceCreateFlagsQNX flags; 2112 const( _screen_context )* context; 2113 const( _screen_window )* window; 2114 } 2115 2116 alias PFN_vkCreateScreenSurfaceQNX = VkResult function( VkInstance instance, const( VkScreenSurfaceCreateInfoQNX )* pCreateInfo, const( VkAllocationCallbacks )* pAllocator, VkSurfaceKHR* pSurface ); 2117 alias PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = VkBool32 function( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const( _screen_window )* window ); 2118 } 2119 2120 __gshared { 2121 2122 // VK_KHR_xlib_surface : function pointer decelerations 2123 static if( __traits( isSame, extension, KHR_xlib_surface )) { 2124 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 2125 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 2126 } 2127 2128 // VK_KHR_xcb_surface : function pointer decelerations 2129 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 2130 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 2131 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 2132 } 2133 2134 // VK_KHR_wayland_surface : function pointer decelerations 2135 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 2136 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 2137 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 2138 } 2139 2140 // VK_KHR_android_surface : function pointer decelerations 2141 else static if( __traits( isSame, extension, KHR_android_surface )) { 2142 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 2143 } 2144 2145 // VK_KHR_win32_surface : function pointer decelerations 2146 else static if( __traits( isSame, extension, KHR_win32_surface )) { 2147 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 2148 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 2149 } 2150 2151 // VK_KHR_video_queue : function pointer decelerations 2152 else static if( __traits( isSame, extension, KHR_video_queue )) { 2153 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; 2154 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; 2155 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; 2156 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; 2157 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; 2158 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; 2159 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; 2160 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; 2161 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; 2162 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; 2163 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; 2164 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; 2165 } 2166 2167 // VK_KHR_video_decode_queue : function pointer decelerations 2168 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2169 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; 2170 } 2171 2172 // VK_KHR_external_memory_win32 : function pointer decelerations 2173 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2174 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 2175 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 2176 } 2177 2178 // VK_KHR_external_semaphore_win32 : function pointer decelerations 2179 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2180 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 2181 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 2182 } 2183 2184 // VK_KHR_external_fence_win32 : function pointer decelerations 2185 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2186 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 2187 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 2188 } 2189 2190 // VK_KHR_video_encode_queue : function pointer decelerations 2191 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2192 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR; 2193 } 2194 2195 // VK_GGP_stream_descriptor_surface : function pointer decelerations 2196 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 2197 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; 2198 } 2199 2200 // VK_NV_external_memory_win32 : function pointer decelerations 2201 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2202 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 2203 } 2204 2205 // VK_NN_vi_surface : function pointer decelerations 2206 else static if( __traits( isSame, extension, NN_vi_surface )) { 2207 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 2208 } 2209 2210 // VK_EXT_acquire_xlib_display : function pointer decelerations 2211 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 2212 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 2213 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 2214 } 2215 2216 // VK_MVK_ios_surface : function pointer decelerations 2217 else static if( __traits( isSame, extension, MVK_ios_surface )) { 2218 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 2219 } 2220 2221 // VK_MVK_macos_surface : function pointer decelerations 2222 else static if( __traits( isSame, extension, MVK_macos_surface )) { 2223 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 2224 } 2225 2226 // VK_ANDROID_external_memory_android_hardware_buffer : function pointer decelerations 2227 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2228 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 2229 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 2230 } 2231 2232 // VK_FUCHSIA_imagepipe_surface : function pointer decelerations 2233 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 2234 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; 2235 } 2236 2237 // VK_EXT_metal_surface : function pointer decelerations 2238 else static if( __traits( isSame, extension, EXT_metal_surface )) { 2239 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; 2240 } 2241 2242 // VK_EXT_full_screen_exclusive : function pointer decelerations 2243 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2244 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; 2245 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; 2246 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; 2247 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; 2248 } 2249 2250 // VK_EXT_metal_objects : function pointer decelerations 2251 else static if( __traits( isSame, extension, EXT_metal_objects )) { 2252 PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT; 2253 } 2254 2255 // VK_NV_acquire_winrt_display : function pointer decelerations 2256 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 2257 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; 2258 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; 2259 } 2260 2261 // VK_EXT_directfb_surface : function pointer decelerations 2262 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 2263 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; 2264 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; 2265 } 2266 2267 // VK_FUCHSIA_external_memory : function pointer decelerations 2268 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2269 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA; 2270 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA; 2271 } 2272 2273 // VK_FUCHSIA_external_semaphore : function pointer decelerations 2274 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2275 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA; 2276 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA; 2277 } 2278 2279 // VK_FUCHSIA_buffer_collection : function pointer decelerations 2280 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2281 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA; 2282 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA; 2283 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA; 2284 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA; 2285 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA; 2286 } 2287 2288 // VK_QNX_screen_surface : function pointer decelerations 2289 else static if( __traits( isSame, extension, QNX_screen_surface )) { 2290 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; 2291 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX; 2292 } 2293 } 2294 } 2295 2296 // workaround for not being able to mixin two overloads with the same symbol name 2297 alias loadDeviceLevelFunctionsExt = loadDeviceLevelFunctionsExtI; 2298 alias loadDeviceLevelFunctionsExt = loadDeviceLevelFunctionsExtD; 2299 2300 // backwards compatibility aliases 2301 alias loadInstanceLevelFunctions = loadInstanceLevelFunctionsExt; 2302 alias loadDeviceLevelFunctions = loadDeviceLevelFunctionsExt; 2303 alias DispatchDevice = DispatchDeviceExt; 2304 2305 // compose loadInstanceLevelFunctionsExt function out of unextended 2306 // loadInstanceLevelFunctions and additional function pointers from extensions 2307 void loadInstanceLevelFunctionsExt( VkInstance instance ) { 2308 2309 // first load all non platform related function pointers from implementation 2310 erupted.functions.loadInstanceLevelFunctions( instance ); 2311 2312 // 2. loop through alias sequence and mixin corresponding 2313 // instance level function pointer definitions 2314 static foreach( extension; noDuplicateExtensions ) { 2315 2316 // VK_KHR_xlib_surface : load instance level function definitions 2317 static if( __traits( isSame, extension, KHR_xlib_surface )) { 2318 vkCreateXlibSurfaceKHR = cast( PFN_vkCreateXlibSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ); 2319 vkGetPhysicalDeviceXlibPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ); 2320 } 2321 2322 // VK_KHR_xcb_surface : load instance level function definitions 2323 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 2324 vkCreateXcbSurfaceKHR = cast( PFN_vkCreateXcbSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ); 2325 vkGetPhysicalDeviceXcbPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ); 2326 } 2327 2328 // VK_KHR_wayland_surface : load instance level function definitions 2329 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 2330 vkCreateWaylandSurfaceKHR = cast( PFN_vkCreateWaylandSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ); 2331 vkGetPhysicalDeviceWaylandPresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ); 2332 } 2333 2334 // VK_KHR_android_surface : load instance level function definitions 2335 else static if( __traits( isSame, extension, KHR_android_surface )) { 2336 vkCreateAndroidSurfaceKHR = cast( PFN_vkCreateAndroidSurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ); 2337 } 2338 2339 // VK_KHR_win32_surface : load instance level function definitions 2340 else static if( __traits( isSame, extension, KHR_win32_surface )) { 2341 vkCreateWin32SurfaceKHR = cast( PFN_vkCreateWin32SurfaceKHR ) vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ); 2342 vkGetPhysicalDeviceWin32PresentationSupportKHR = cast( PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ); 2343 } 2344 2345 // VK_KHR_video_queue : load instance level function definitions 2346 else static if( __traits( isSame, extension, KHR_video_queue )) { 2347 vkGetPhysicalDeviceVideoCapabilitiesKHR = cast( PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ); 2348 vkGetPhysicalDeviceVideoFormatPropertiesKHR = cast( PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ); 2349 } 2350 2351 // VK_GGP_stream_descriptor_surface : load instance level function definitions 2352 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 2353 vkCreateStreamDescriptorSurfaceGGP = cast( PFN_vkCreateStreamDescriptorSurfaceGGP ) vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ); 2354 } 2355 2356 // VK_NN_vi_surface : load instance level function definitions 2357 else static if( __traits( isSame, extension, NN_vi_surface )) { 2358 vkCreateViSurfaceNN = cast( PFN_vkCreateViSurfaceNN ) vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ); 2359 } 2360 2361 // VK_EXT_acquire_xlib_display : load instance level function definitions 2362 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 2363 vkAcquireXlibDisplayEXT = cast( PFN_vkAcquireXlibDisplayEXT ) vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ); 2364 vkGetRandROutputDisplayEXT = cast( PFN_vkGetRandROutputDisplayEXT ) vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ); 2365 } 2366 2367 // VK_MVK_ios_surface : load instance level function definitions 2368 else static if( __traits( isSame, extension, MVK_ios_surface )) { 2369 vkCreateIOSSurfaceMVK = cast( PFN_vkCreateIOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ); 2370 } 2371 2372 // VK_MVK_macos_surface : load instance level function definitions 2373 else static if( __traits( isSame, extension, MVK_macos_surface )) { 2374 vkCreateMacOSSurfaceMVK = cast( PFN_vkCreateMacOSSurfaceMVK ) vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ); 2375 } 2376 2377 // VK_FUCHSIA_imagepipe_surface : load instance level function definitions 2378 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 2379 vkCreateImagePipeSurfaceFUCHSIA = cast( PFN_vkCreateImagePipeSurfaceFUCHSIA ) vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ); 2380 } 2381 2382 // VK_EXT_metal_surface : load instance level function definitions 2383 else static if( __traits( isSame, extension, EXT_metal_surface )) { 2384 vkCreateMetalSurfaceEXT = cast( PFN_vkCreateMetalSurfaceEXT ) vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ); 2385 } 2386 2387 // VK_EXT_full_screen_exclusive : load instance level function definitions 2388 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2389 vkGetPhysicalDeviceSurfacePresentModes2EXT = cast( PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ); 2390 } 2391 2392 // VK_NV_acquire_winrt_display : load instance level function definitions 2393 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 2394 vkAcquireWinrtDisplayNV = cast( PFN_vkAcquireWinrtDisplayNV ) vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ); 2395 vkGetWinrtDisplayNV = cast( PFN_vkGetWinrtDisplayNV ) vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ); 2396 } 2397 2398 // VK_EXT_directfb_surface : load instance level function definitions 2399 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 2400 vkCreateDirectFBSurfaceEXT = cast( PFN_vkCreateDirectFBSurfaceEXT ) vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ); 2401 vkGetPhysicalDeviceDirectFBPresentationSupportEXT = cast( PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ); 2402 } 2403 2404 // VK_QNX_screen_surface : load instance level function definitions 2405 else static if( __traits( isSame, extension, QNX_screen_surface )) { 2406 vkCreateScreenSurfaceQNX = cast( PFN_vkCreateScreenSurfaceQNX ) vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ); 2407 vkGetPhysicalDeviceScreenPresentationSupportQNX = cast( PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX ) vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ); 2408 } 2409 } 2410 } 2411 2412 // compose instance based loadDeviceLevelFunctionsExtI function out of unextended 2413 // loadDeviceLevelFunctions and additional function pointers from extensions 2414 // suffix I is required, as we cannot mixin mixin two overloads with the same symbol name (any more!) 2415 void loadDeviceLevelFunctionsExtI( VkInstance instance ) { 2416 2417 // first load all non platform related function pointers from implementation 2418 erupted.functions.loadDeviceLevelFunctions( instance ); 2419 2420 // 3. loop through alias sequence and mixin corresponding 2421 // instance based device level function pointer definitions 2422 static foreach( extension; noDuplicateExtensions ) { 2423 2424 // VK_KHR_video_queue : load instance based device level function definitions 2425 static if( __traits( isSame, extension, KHR_video_queue )) { 2426 vkCreateVideoSessionKHR = cast( PFN_vkCreateVideoSessionKHR ) vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ); 2427 vkDestroyVideoSessionKHR = cast( PFN_vkDestroyVideoSessionKHR ) vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ); 2428 vkGetVideoSessionMemoryRequirementsKHR = cast( PFN_vkGetVideoSessionMemoryRequirementsKHR ) vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ); 2429 vkBindVideoSessionMemoryKHR = cast( PFN_vkBindVideoSessionMemoryKHR ) vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ); 2430 vkCreateVideoSessionParametersKHR = cast( PFN_vkCreateVideoSessionParametersKHR ) vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ); 2431 vkUpdateVideoSessionParametersKHR = cast( PFN_vkUpdateVideoSessionParametersKHR ) vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ); 2432 vkDestroyVideoSessionParametersKHR = cast( PFN_vkDestroyVideoSessionParametersKHR ) vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ); 2433 vkCmdBeginVideoCodingKHR = cast( PFN_vkCmdBeginVideoCodingKHR ) vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ); 2434 vkCmdEndVideoCodingKHR = cast( PFN_vkCmdEndVideoCodingKHR ) vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ); 2435 vkCmdControlVideoCodingKHR = cast( PFN_vkCmdControlVideoCodingKHR ) vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ); 2436 } 2437 2438 // VK_KHR_video_decode_queue : load instance based device level function definitions 2439 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2440 vkCmdDecodeVideoKHR = cast( PFN_vkCmdDecodeVideoKHR ) vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ); 2441 } 2442 2443 // VK_KHR_external_memory_win32 : load instance based device level function definitions 2444 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2445 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ); 2446 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ); 2447 } 2448 2449 // VK_KHR_external_semaphore_win32 : load instance based device level function definitions 2450 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2451 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ); 2452 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ); 2453 } 2454 2455 // VK_KHR_external_fence_win32 : load instance based device level function definitions 2456 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2457 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ); 2458 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ); 2459 } 2460 2461 // VK_KHR_video_encode_queue : load instance based device level function definitions 2462 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2463 vkCmdEncodeVideoKHR = cast( PFN_vkCmdEncodeVideoKHR ) vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ); 2464 } 2465 2466 // VK_NV_external_memory_win32 : load instance based device level function definitions 2467 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2468 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ); 2469 } 2470 2471 // VK_ANDROID_external_memory_android_hardware_buffer : load instance based device level function definitions 2472 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2473 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 2474 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ); 2475 } 2476 2477 // VK_EXT_full_screen_exclusive : load instance based device level function definitions 2478 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2479 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ); 2480 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ); 2481 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 2482 } 2483 2484 // VK_EXT_metal_objects : load instance based device level function definitions 2485 else static if( __traits( isSame, extension, EXT_metal_objects )) { 2486 vkExportMetalObjectsEXT = cast( PFN_vkExportMetalObjectsEXT ) vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ); 2487 } 2488 2489 // VK_FUCHSIA_external_memory : load instance based device level function definitions 2490 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2491 vkGetMemoryZirconHandleFUCHSIA = cast( PFN_vkGetMemoryZirconHandleFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ); 2492 vkGetMemoryZirconHandlePropertiesFUCHSIA = cast( PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ); 2493 } 2494 2495 // VK_FUCHSIA_external_semaphore : load instance based device level function definitions 2496 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2497 vkImportSemaphoreZirconHandleFUCHSIA = cast( PFN_vkImportSemaphoreZirconHandleFUCHSIA ) vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ); 2498 vkGetSemaphoreZirconHandleFUCHSIA = cast( PFN_vkGetSemaphoreZirconHandleFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ); 2499 } 2500 2501 // VK_FUCHSIA_buffer_collection : load instance based device level function definitions 2502 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2503 vkCreateBufferCollectionFUCHSIA = cast( PFN_vkCreateBufferCollectionFUCHSIA ) vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ); 2504 vkSetBufferCollectionImageConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionImageConstraintsFUCHSIA ) vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ); 2505 vkSetBufferCollectionBufferConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA ) vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ); 2506 vkDestroyBufferCollectionFUCHSIA = cast( PFN_vkDestroyBufferCollectionFUCHSIA ) vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ); 2507 vkGetBufferCollectionPropertiesFUCHSIA = cast( PFN_vkGetBufferCollectionPropertiesFUCHSIA ) vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ); 2508 } 2509 } 2510 } 2511 2512 // compose device based loadDeviceLevelFunctionsExtD function out of unextended 2513 // loadDeviceLevelFunctions and additional function pointers from extensions 2514 // suffix D is required as, we cannot mixin mixin two overloads with the same symbol name (any more!) 2515 void loadDeviceLevelFunctionsExtD( VkDevice device ) { 2516 2517 // first load all non platform related function pointers from implementation 2518 erupted.functions.loadDeviceLevelFunctions( device ); 2519 2520 // 4. loop through alias sequence and mixin corresponding 2521 // device based device level function pointer definitions 2522 static foreach( extension; noDuplicateExtensions ) { 2523 2524 // VK_KHR_video_queue : load device based device level function definitions 2525 static if( __traits( isSame, extension, KHR_video_queue )) { 2526 vkCreateVideoSessionKHR = cast( PFN_vkCreateVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ); 2527 vkDestroyVideoSessionKHR = cast( PFN_vkDestroyVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ); 2528 vkGetVideoSessionMemoryRequirementsKHR = cast( PFN_vkGetVideoSessionMemoryRequirementsKHR ) vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ); 2529 vkBindVideoSessionMemoryKHR = cast( PFN_vkBindVideoSessionMemoryKHR ) vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ); 2530 vkCreateVideoSessionParametersKHR = cast( PFN_vkCreateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ); 2531 vkUpdateVideoSessionParametersKHR = cast( PFN_vkUpdateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ); 2532 vkDestroyVideoSessionParametersKHR = cast( PFN_vkDestroyVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ); 2533 vkCmdBeginVideoCodingKHR = cast( PFN_vkCmdBeginVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ); 2534 vkCmdEndVideoCodingKHR = cast( PFN_vkCmdEndVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ); 2535 vkCmdControlVideoCodingKHR = cast( PFN_vkCmdControlVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ); 2536 } 2537 2538 // VK_KHR_video_decode_queue : load device based device level function definitions 2539 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2540 vkCmdDecodeVideoKHR = cast( PFN_vkCmdDecodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ); 2541 } 2542 2543 // VK_KHR_external_memory_win32 : load device based device level function definitions 2544 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2545 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 2546 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 2547 } 2548 2549 // VK_KHR_external_semaphore_win32 : load device based device level function definitions 2550 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2551 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 2552 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 2553 } 2554 2555 // VK_KHR_external_fence_win32 : load device based device level function definitions 2556 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2557 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 2558 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 2559 } 2560 2561 // VK_KHR_video_encode_queue : load device based device level function definitions 2562 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2563 vkCmdEncodeVideoKHR = cast( PFN_vkCmdEncodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ); 2564 } 2565 2566 // VK_NV_external_memory_win32 : load device based device level function definitions 2567 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2568 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 2569 } 2570 2571 // VK_ANDROID_external_memory_android_hardware_buffer : load device based device level function definitions 2572 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2573 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 2574 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 2575 } 2576 2577 // VK_EXT_full_screen_exclusive : load device based device level function definitions 2578 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2579 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ); 2580 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ); 2581 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 2582 } 2583 2584 // VK_EXT_metal_objects : load device based device level function definitions 2585 else static if( __traits( isSame, extension, EXT_metal_objects )) { 2586 vkExportMetalObjectsEXT = cast( PFN_vkExportMetalObjectsEXT ) vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ); 2587 } 2588 2589 // VK_FUCHSIA_external_memory : load device based device level function definitions 2590 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2591 vkGetMemoryZirconHandleFUCHSIA = cast( PFN_vkGetMemoryZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ); 2592 vkGetMemoryZirconHandlePropertiesFUCHSIA = cast( PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ); 2593 } 2594 2595 // VK_FUCHSIA_external_semaphore : load device based device level function definitions 2596 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2597 vkImportSemaphoreZirconHandleFUCHSIA = cast( PFN_vkImportSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ); 2598 vkGetSemaphoreZirconHandleFUCHSIA = cast( PFN_vkGetSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ); 2599 } 2600 2601 // VK_FUCHSIA_buffer_collection : load device based device level function definitions 2602 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2603 vkCreateBufferCollectionFUCHSIA = cast( PFN_vkCreateBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ); 2604 vkSetBufferCollectionImageConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionImageConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ); 2605 vkSetBufferCollectionBufferConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ); 2606 vkDestroyBufferCollectionFUCHSIA = cast( PFN_vkDestroyBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ); 2607 vkGetBufferCollectionPropertiesFUCHSIA = cast( PFN_vkGetBufferCollectionPropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ); 2608 } 2609 } 2610 } 2611 2612 // compose extended dispatch device out of unextended original dispatch device with 2613 // extended, device based loadDeviceLevelFunctionsExt member function, 2614 // device and command buffer based function pointer decelerations 2615 struct DispatchDeviceExt { 2616 2617 // use unextended dispatch device from module erupted.functions as member and alias this 2618 erupted.dispatch_device.DispatchDevice commonDispatchDevice; 2619 alias commonDispatchDevice this; 2620 2621 // Constructor forwards parameter 'device' to 'loadDeviceLevelFunctionsExt' 2622 this( VkDevice device ) { 2623 loadDeviceLevelFunctionsExt( device ); 2624 } 2625 2626 // backwards compatibility alias 2627 alias loadDeviceLevelFunctions = loadDeviceLevelFunctionsExt; 2628 2629 // compose device based loadDeviceLevelFunctionsExt member function out of unextended 2630 // loadDeviceLevelFunctions and additional member function pointers from extensions 2631 void loadDeviceLevelFunctionsExt( VkDevice device ) { 2632 2633 // first load all non platform related member function pointers of wrapped commonDispatchDevice 2634 commonDispatchDevice.loadDeviceLevelFunctions( device ); 2635 2636 // 5. loop through alias sequence and mixin corresponding 2637 // device level member function pointer definitions of this wrapping DispatchDevice 2638 static foreach( extension; noDuplicateExtensions ) { 2639 2640 // VK_KHR_video_queue : load dispatch device member function definitions 2641 static if( __traits( isSame, extension, KHR_video_queue )) { 2642 vkCreateVideoSessionKHR = cast( PFN_vkCreateVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ); 2643 vkDestroyVideoSessionKHR = cast( PFN_vkDestroyVideoSessionKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ); 2644 vkGetVideoSessionMemoryRequirementsKHR = cast( PFN_vkGetVideoSessionMemoryRequirementsKHR ) vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ); 2645 vkBindVideoSessionMemoryKHR = cast( PFN_vkBindVideoSessionMemoryKHR ) vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ); 2646 vkCreateVideoSessionParametersKHR = cast( PFN_vkCreateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ); 2647 vkUpdateVideoSessionParametersKHR = cast( PFN_vkUpdateVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ); 2648 vkDestroyVideoSessionParametersKHR = cast( PFN_vkDestroyVideoSessionParametersKHR ) vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ); 2649 vkCmdBeginVideoCodingKHR = cast( PFN_vkCmdBeginVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ); 2650 vkCmdEndVideoCodingKHR = cast( PFN_vkCmdEndVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ); 2651 vkCmdControlVideoCodingKHR = cast( PFN_vkCmdControlVideoCodingKHR ) vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ); 2652 } 2653 2654 // VK_KHR_video_decode_queue : load dispatch device member function definitions 2655 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2656 vkCmdDecodeVideoKHR = cast( PFN_vkCmdDecodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ); 2657 } 2658 2659 // VK_KHR_external_memory_win32 : load dispatch device member function definitions 2660 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2661 vkGetMemoryWin32HandleKHR = cast( PFN_vkGetMemoryWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ); 2662 vkGetMemoryWin32HandlePropertiesKHR = cast( PFN_vkGetMemoryWin32HandlePropertiesKHR ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ); 2663 } 2664 2665 // VK_KHR_external_semaphore_win32 : load dispatch device member function definitions 2666 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2667 vkImportSemaphoreWin32HandleKHR = cast( PFN_vkImportSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ); 2668 vkGetSemaphoreWin32HandleKHR = cast( PFN_vkGetSemaphoreWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ); 2669 } 2670 2671 // VK_KHR_external_fence_win32 : load dispatch device member function definitions 2672 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2673 vkImportFenceWin32HandleKHR = cast( PFN_vkImportFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ); 2674 vkGetFenceWin32HandleKHR = cast( PFN_vkGetFenceWin32HandleKHR ) vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ); 2675 } 2676 2677 // VK_KHR_video_encode_queue : load dispatch device member function definitions 2678 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2679 vkCmdEncodeVideoKHR = cast( PFN_vkCmdEncodeVideoKHR ) vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ); 2680 } 2681 2682 // VK_NV_external_memory_win32 : load dispatch device member function definitions 2683 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2684 vkGetMemoryWin32HandleNV = cast( PFN_vkGetMemoryWin32HandleNV ) vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ); 2685 } 2686 2687 // VK_ANDROID_external_memory_android_hardware_buffer : load dispatch device member function definitions 2688 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2689 vkGetAndroidHardwareBufferPropertiesANDROID = cast( PFN_vkGetAndroidHardwareBufferPropertiesANDROID ) vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ); 2690 vkGetMemoryAndroidHardwareBufferANDROID = cast( PFN_vkGetMemoryAndroidHardwareBufferANDROID ) vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ); 2691 } 2692 2693 // VK_EXT_full_screen_exclusive : load dispatch device member function definitions 2694 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2695 vkAcquireFullScreenExclusiveModeEXT = cast( PFN_vkAcquireFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ); 2696 vkReleaseFullScreenExclusiveModeEXT = cast( PFN_vkReleaseFullScreenExclusiveModeEXT ) vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ); 2697 vkGetDeviceGroupSurfacePresentModes2EXT = cast( PFN_vkGetDeviceGroupSurfacePresentModes2EXT ) vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ); 2698 } 2699 2700 // VK_EXT_metal_objects : load dispatch device member function definitions 2701 else static if( __traits( isSame, extension, EXT_metal_objects )) { 2702 vkExportMetalObjectsEXT = cast( PFN_vkExportMetalObjectsEXT ) vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ); 2703 } 2704 2705 // VK_FUCHSIA_external_memory : load dispatch device member function definitions 2706 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2707 vkGetMemoryZirconHandleFUCHSIA = cast( PFN_vkGetMemoryZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ); 2708 vkGetMemoryZirconHandlePropertiesFUCHSIA = cast( PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ); 2709 } 2710 2711 // VK_FUCHSIA_external_semaphore : load dispatch device member function definitions 2712 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2713 vkImportSemaphoreZirconHandleFUCHSIA = cast( PFN_vkImportSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ); 2714 vkGetSemaphoreZirconHandleFUCHSIA = cast( PFN_vkGetSemaphoreZirconHandleFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ); 2715 } 2716 2717 // VK_FUCHSIA_buffer_collection : load dispatch device member function definitions 2718 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2719 vkCreateBufferCollectionFUCHSIA = cast( PFN_vkCreateBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ); 2720 vkSetBufferCollectionImageConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionImageConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ); 2721 vkSetBufferCollectionBufferConstraintsFUCHSIA = cast( PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA ) vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ); 2722 vkDestroyBufferCollectionFUCHSIA = cast( PFN_vkDestroyBufferCollectionFUCHSIA ) vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ); 2723 vkGetBufferCollectionPropertiesFUCHSIA = cast( PFN_vkGetBufferCollectionPropertiesFUCHSIA ) vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ); 2724 } 2725 } 2726 } 2727 2728 // 6. loop through alias sequence and mixin corresponding convenience member functions 2729 // omitting device parameter of this wrapping DispatchDevice. Member vkDevice of commonDispatchDevice is used instead 2730 static foreach( extension; noDuplicateExtensions ) { 2731 2732 // VK_KHR_video_queue : dispatch device convenience member functions 2733 static if( __traits( isSame, extension, KHR_video_queue )) { 2734 VkResult CreateVideoSessionKHR( const( VkVideoSessionCreateInfoKHR )* pCreateInfo, VkVideoSessionKHR* pVideoSession ) { return vkCreateVideoSessionKHR( vkDevice, pCreateInfo, pAllocator, pVideoSession ); } 2735 void DestroyVideoSessionKHR( VkVideoSessionKHR videoSession ) { vkDestroyVideoSessionKHR( vkDevice, videoSession, pAllocator ); } 2736 VkResult GetVideoSessionMemoryRequirementsKHR( VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements ) { return vkGetVideoSessionMemoryRequirementsKHR( vkDevice, videoSession, pMemoryRequirementsCount, pMemoryRequirements ); } 2737 VkResult BindVideoSessionMemoryKHR( VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const( VkBindVideoSessionMemoryInfoKHR )* pBindSessionMemoryInfos ) { return vkBindVideoSessionMemoryKHR( vkDevice, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos ); } 2738 VkResult CreateVideoSessionParametersKHR( const( VkVideoSessionParametersCreateInfoKHR )* pCreateInfo, VkVideoSessionParametersKHR* pVideoSessionParameters ) { return vkCreateVideoSessionParametersKHR( vkDevice, pCreateInfo, pAllocator, pVideoSessionParameters ); } 2739 VkResult UpdateVideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParameters, const( VkVideoSessionParametersUpdateInfoKHR )* pUpdateInfo ) { return vkUpdateVideoSessionParametersKHR( vkDevice, videoSessionParameters, pUpdateInfo ); } 2740 void DestroyVideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParameters ) { vkDestroyVideoSessionParametersKHR( vkDevice, videoSessionParameters, pAllocator ); } 2741 void CmdBeginVideoCodingKHR( const( VkVideoBeginCodingInfoKHR )* pBeginInfo ) { vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo ); } 2742 void CmdEndVideoCodingKHR( const( VkVideoEndCodingInfoKHR )* pEndCodingInfo ) { vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo ); } 2743 void CmdControlVideoCodingKHR( const( VkVideoCodingControlInfoKHR )* pCodingControlInfo ) { vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo ); } 2744 } 2745 2746 // VK_KHR_video_decode_queue : dispatch device convenience member functions 2747 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2748 void CmdDecodeVideoKHR( const( VkVideoDecodeInfoKHR )* pFrameInfo ) { vkCmdDecodeVideoKHR( commandBuffer, pFrameInfo ); } 2749 } 2750 2751 // VK_KHR_external_memory_win32 : dispatch device convenience member functions 2752 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2753 VkResult GetMemoryWin32HandleKHR( const( VkMemoryGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetMemoryWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 2754 VkResult GetMemoryWin32HandlePropertiesKHR( VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) { return vkGetMemoryWin32HandlePropertiesKHR( vkDevice, handleType, handle, pMemoryWin32HandleProperties ); } 2755 } 2756 2757 // VK_KHR_external_semaphore_win32 : dispatch device convenience member functions 2758 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2759 VkResult ImportSemaphoreWin32HandleKHR( const( VkImportSemaphoreWin32HandleInfoKHR )* pImportSemaphoreWin32HandleInfo ) { return vkImportSemaphoreWin32HandleKHR( vkDevice, pImportSemaphoreWin32HandleInfo ); } 2760 VkResult GetSemaphoreWin32HandleKHR( const( VkSemaphoreGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetSemaphoreWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 2761 } 2762 2763 // VK_KHR_external_fence_win32 : dispatch device convenience member functions 2764 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2765 VkResult ImportFenceWin32HandleKHR( const( VkImportFenceWin32HandleInfoKHR )* pImportFenceWin32HandleInfo ) { return vkImportFenceWin32HandleKHR( vkDevice, pImportFenceWin32HandleInfo ); } 2766 VkResult GetFenceWin32HandleKHR( const( VkFenceGetWin32HandleInfoKHR )* pGetWin32HandleInfo, HANDLE* pHandle ) { return vkGetFenceWin32HandleKHR( vkDevice, pGetWin32HandleInfo, pHandle ); } 2767 } 2768 2769 // VK_KHR_video_encode_queue : dispatch device convenience member functions 2770 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2771 void CmdEncodeVideoKHR( const( VkVideoEncodeInfoKHR )* pEncodeInfo ) { vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo ); } 2772 } 2773 2774 // VK_NV_external_memory_win32 : dispatch device convenience member functions 2775 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2776 VkResult GetMemoryWin32HandleNV( VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) { return vkGetMemoryWin32HandleNV( vkDevice, memory, handleType, pHandle ); } 2777 } 2778 2779 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device convenience member functions 2780 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2781 VkResult GetAndroidHardwareBufferPropertiesANDROID( const( AHardwareBuffer )* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) { return vkGetAndroidHardwareBufferPropertiesANDROID( vkDevice, buffer, pProperties ); } 2782 VkResult GetMemoryAndroidHardwareBufferANDROID( const( VkMemoryGetAndroidHardwareBufferInfoANDROID )* pInfo, AHardwareBuffer pBuffer ) { return vkGetMemoryAndroidHardwareBufferANDROID( vkDevice, pInfo, pBuffer ); } 2783 } 2784 2785 // VK_EXT_full_screen_exclusive : dispatch device convenience member functions 2786 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2787 VkResult AcquireFullScreenExclusiveModeEXT( VkSwapchainKHR swapchain ) { return vkAcquireFullScreenExclusiveModeEXT( vkDevice, swapchain ); } 2788 VkResult ReleaseFullScreenExclusiveModeEXT( VkSwapchainKHR swapchain ) { return vkReleaseFullScreenExclusiveModeEXT( vkDevice, swapchain ); } 2789 VkResult GetDeviceGroupSurfacePresentModes2EXT( const( VkPhysicalDeviceSurfaceInfo2KHR )* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes ) { return vkGetDeviceGroupSurfacePresentModes2EXT( vkDevice, pSurfaceInfo, pModes ); } 2790 } 2791 2792 // VK_EXT_metal_objects : dispatch device convenience member functions 2793 else static if( __traits( isSame, extension, EXT_metal_objects )) { 2794 void ExportMetalObjectsEXT( VkExportMetalObjectsInfoEXT* pMetalObjectsInfo ) { vkExportMetalObjectsEXT( vkDevice, pMetalObjectsInfo ); } 2795 } 2796 2797 // VK_FUCHSIA_external_memory : dispatch device convenience member functions 2798 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2799 VkResult GetMemoryZirconHandleFUCHSIA( const( VkMemoryGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ) { return vkGetMemoryZirconHandleFUCHSIA( vkDevice, pGetZirconHandleInfo, pZirconHandle ); } 2800 VkResult GetMemoryZirconHandlePropertiesFUCHSIA( VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties ) { return vkGetMemoryZirconHandlePropertiesFUCHSIA( vkDevice, handleType, zirconHandle, pMemoryZirconHandleProperties ); } 2801 } 2802 2803 // VK_FUCHSIA_external_semaphore : dispatch device convenience member functions 2804 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2805 VkResult ImportSemaphoreZirconHandleFUCHSIA( const( VkImportSemaphoreZirconHandleInfoFUCHSIA )* pImportSemaphoreZirconHandleInfo ) { return vkImportSemaphoreZirconHandleFUCHSIA( vkDevice, pImportSemaphoreZirconHandleInfo ); } 2806 VkResult GetSemaphoreZirconHandleFUCHSIA( const( VkSemaphoreGetZirconHandleInfoFUCHSIA )* pGetZirconHandleInfo, zx_handle_t* pZirconHandle ) { return vkGetSemaphoreZirconHandleFUCHSIA( vkDevice, pGetZirconHandleInfo, pZirconHandle ); } 2807 } 2808 2809 // VK_FUCHSIA_buffer_collection : dispatch device convenience member functions 2810 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2811 VkResult CreateBufferCollectionFUCHSIA( const( VkBufferCollectionCreateInfoFUCHSIA )* pCreateInfo, VkBufferCollectionFUCHSIA* pCollection ) { return vkCreateBufferCollectionFUCHSIA( vkDevice, pCreateInfo, pAllocator, pCollection ); } 2812 VkResult SetBufferCollectionImageConstraintsFUCHSIA( VkBufferCollectionFUCHSIA collection, const( VkImageConstraintsInfoFUCHSIA )* pImageConstraintsInfo ) { return vkSetBufferCollectionImageConstraintsFUCHSIA( vkDevice, collection, pImageConstraintsInfo ); } 2813 VkResult SetBufferCollectionBufferConstraintsFUCHSIA( VkBufferCollectionFUCHSIA collection, const( VkBufferConstraintsInfoFUCHSIA )* pBufferConstraintsInfo ) { return vkSetBufferCollectionBufferConstraintsFUCHSIA( vkDevice, collection, pBufferConstraintsInfo ); } 2814 void DestroyBufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA collection ) { vkDestroyBufferCollectionFUCHSIA( vkDevice, collection, pAllocator ); } 2815 VkResult GetBufferCollectionPropertiesFUCHSIA( VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties ) { return vkGetBufferCollectionPropertiesFUCHSIA( vkDevice, collection, pProperties ); } 2816 } 2817 } 2818 2819 // 7. loop last time through alias sequence and mixin corresponding function pointer declarations 2820 static foreach( extension; noDuplicateExtensions ) { 2821 2822 // VK_KHR_xlib_surface : dispatch device member function pointer decelerations 2823 static if( __traits( isSame, extension, KHR_xlib_surface )) { 2824 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR; 2825 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR; 2826 } 2827 2828 // VK_KHR_xcb_surface : dispatch device member function pointer decelerations 2829 else static if( __traits( isSame, extension, KHR_xcb_surface )) { 2830 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR; 2831 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR; 2832 } 2833 2834 // VK_KHR_wayland_surface : dispatch device member function pointer decelerations 2835 else static if( __traits( isSame, extension, KHR_wayland_surface )) { 2836 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR; 2837 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR; 2838 } 2839 2840 // VK_KHR_android_surface : dispatch device member function pointer decelerations 2841 else static if( __traits( isSame, extension, KHR_android_surface )) { 2842 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR; 2843 } 2844 2845 // VK_KHR_win32_surface : dispatch device member function pointer decelerations 2846 else static if( __traits( isSame, extension, KHR_win32_surface )) { 2847 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR; 2848 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR; 2849 } 2850 2851 // VK_KHR_video_queue : dispatch device member function pointer decelerations 2852 else static if( __traits( isSame, extension, KHR_video_queue )) { 2853 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; 2854 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; 2855 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; 2856 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; 2857 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; 2858 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; 2859 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; 2860 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; 2861 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; 2862 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; 2863 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; 2864 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; 2865 } 2866 2867 // VK_KHR_video_decode_queue : dispatch device member function pointer decelerations 2868 else static if( __traits( isSame, extension, KHR_video_decode_queue )) { 2869 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; 2870 } 2871 2872 // VK_KHR_external_memory_win32 : dispatch device member function pointer decelerations 2873 else static if( __traits( isSame, extension, KHR_external_memory_win32 )) { 2874 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR; 2875 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR; 2876 } 2877 2878 // VK_KHR_external_semaphore_win32 : dispatch device member function pointer decelerations 2879 else static if( __traits( isSame, extension, KHR_external_semaphore_win32 )) { 2880 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR; 2881 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR; 2882 } 2883 2884 // VK_KHR_external_fence_win32 : dispatch device member function pointer decelerations 2885 else static if( __traits( isSame, extension, KHR_external_fence_win32 )) { 2886 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR; 2887 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR; 2888 } 2889 2890 // VK_KHR_video_encode_queue : dispatch device member function pointer decelerations 2891 else static if( __traits( isSame, extension, KHR_video_encode_queue )) { 2892 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR; 2893 } 2894 2895 // VK_GGP_stream_descriptor_surface : dispatch device member function pointer decelerations 2896 else static if( __traits( isSame, extension, GGP_stream_descriptor_surface )) { 2897 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP; 2898 } 2899 2900 // VK_NV_external_memory_win32 : dispatch device member function pointer decelerations 2901 else static if( __traits( isSame, extension, NV_external_memory_win32 )) { 2902 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV; 2903 } 2904 2905 // VK_NN_vi_surface : dispatch device member function pointer decelerations 2906 else static if( __traits( isSame, extension, NN_vi_surface )) { 2907 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN; 2908 } 2909 2910 // VK_EXT_acquire_xlib_display : dispatch device member function pointer decelerations 2911 else static if( __traits( isSame, extension, EXT_acquire_xlib_display )) { 2912 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT; 2913 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT; 2914 } 2915 2916 // VK_MVK_ios_surface : dispatch device member function pointer decelerations 2917 else static if( __traits( isSame, extension, MVK_ios_surface )) { 2918 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK; 2919 } 2920 2921 // VK_MVK_macos_surface : dispatch device member function pointer decelerations 2922 else static if( __traits( isSame, extension, MVK_macos_surface )) { 2923 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK; 2924 } 2925 2926 // VK_ANDROID_external_memory_android_hardware_buffer : dispatch device member function pointer decelerations 2927 else static if( __traits( isSame, extension, ANDROID_external_memory_android_hardware_buffer )) { 2928 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID; 2929 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID; 2930 } 2931 2932 // VK_FUCHSIA_imagepipe_surface : dispatch device member function pointer decelerations 2933 else static if( __traits( isSame, extension, FUCHSIA_imagepipe_surface )) { 2934 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA; 2935 } 2936 2937 // VK_EXT_metal_surface : dispatch device member function pointer decelerations 2938 else static if( __traits( isSame, extension, EXT_metal_surface )) { 2939 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT; 2940 } 2941 2942 // VK_EXT_full_screen_exclusive : dispatch device member function pointer decelerations 2943 else static if( __traits( isSame, extension, EXT_full_screen_exclusive )) { 2944 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT; 2945 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT; 2946 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT; 2947 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT; 2948 } 2949 2950 // VK_EXT_metal_objects : dispatch device member function pointer decelerations 2951 else static if( __traits( isSame, extension, EXT_metal_objects )) { 2952 PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT; 2953 } 2954 2955 // VK_NV_acquire_winrt_display : dispatch device member function pointer decelerations 2956 else static if( __traits( isSame, extension, NV_acquire_winrt_display )) { 2957 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; 2958 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; 2959 } 2960 2961 // VK_EXT_directfb_surface : dispatch device member function pointer decelerations 2962 else static if( __traits( isSame, extension, EXT_directfb_surface )) { 2963 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT; 2964 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT; 2965 } 2966 2967 // VK_FUCHSIA_external_memory : dispatch device member function pointer decelerations 2968 else static if( __traits( isSame, extension, FUCHSIA_external_memory )) { 2969 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA; 2970 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA; 2971 } 2972 2973 // VK_FUCHSIA_external_semaphore : dispatch device member function pointer decelerations 2974 else static if( __traits( isSame, extension, FUCHSIA_external_semaphore )) { 2975 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA; 2976 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA; 2977 } 2978 2979 // VK_FUCHSIA_buffer_collection : dispatch device member function pointer decelerations 2980 else static if( __traits( isSame, extension, FUCHSIA_buffer_collection )) { 2981 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA; 2982 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA; 2983 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA; 2984 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA; 2985 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA; 2986 } 2987 2988 // VK_QNX_screen_surface : dispatch device member function pointer decelerations 2989 else static if( __traits( isSame, extension, QNX_screen_surface )) { 2990 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX; 2991 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX; 2992 } 2993 } 2994 } 2995 }