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