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